public void TestPutObject()
{
var client = new MinioClient("localhost", 9000, "", "");
client.PutObject("bucket-name", "object-name", null, 5 * 1024L * 1024L * 11000, null);
}
public void TestSetAppInfoFailsNullVersion()
{
var client = new MinioClient("http://localhost:9000");
client.SetAppInfo("Hello-App", null);
}
public AudioEncoderPipelineActivity(MinioClient minio, DataService dataService) : base(minio)
{
this.dataService = dataService;
this.minio = minio;
}
public AssumeRoleBaseProvider(MinioClient client)
{
this.Client = client;
}
public ReceiversController(ILogger <ReceiversController> logger, MinioClient minio)
{
_logger = logger;
_minio = minio;
}
public VideoDownloaderPipelineActivity(MinioClient minio, DataService dataService) : base(minio)
{
this.dataService = dataService;
}
public async IAsyncEnumerable <DataAcquirerPost> GetPostsAsync(
DataAcquirerInputModel acquirerInputModel,
[EnumeratorCancellation] CancellationToken cancellationToken = default)
{
var minio = new MinioClient(
_endpoint,
_accessKey,
_secret);
var attributes = acquirerInputModel.Attributes;
var bucketName = attributes.GetValue(_bucketElementName, null);
var objectName = attributes.GetValue(_objectElementName, null);
var mappingName = attributes.GetValue(_mappingElementName, null);
var atts = await GetMappingAttributesAsync(minio, bucketName, mappingName);
if (atts == null ||
string.IsNullOrEmpty(atts.DataFormat) ||
atts.MappingAttributes == null)
{
throw new InvalidOperationException("Invalid config");
}
try
{
await minio.StatObjectAsync(bucketName, objectName);
}
catch (MinioException)
{
//_logger.TrackError(
// "CustomDataAcquirer",
// $"Object '{bucketName}-{objectName}' does not exist",
// new
// {
// bucketName,
// objectName,
// exception = e
// });
throw new InvalidOperationException($"Mapping object {mappingName} does not exits");
}
var reader = _customStreamReaderFactory.Create(atts);
using (var cts = new CancellationTokenSource())
{
var listeningTask = Task.Run(async() =>
{
await minio.GetObjectAsync(bucketName, objectName, reader.StartPopulating)
.ConfigureAwait(false);
});
while (!reader.IsCompleted)
{
if (reader.TryGetPost(out var post))
{
var validation = PostValidator.ValidatePost(post);
if (validation.IsSuccessful)
{
yield return(post);
}
else
{
_logger.TrackWarning(
"CustomStaticData",
"Invalid post encountered",
new
{
errorMessage = validation.ErrorMessage,
post
});
}
}
else
{
await Task.Delay(TimeSpan.FromSeconds(1));
}
}
cts.Cancel();
try
{
await listeningTask;
}
catch (TaskCanceledException) { }
}
}
// Set Replication configuration for the bucket
public async static Task Run(MinioClient minio,
string bucketName = "my-bucket-name",
string destBucketName = "dest-bucket-name",
string replicationCfgID = "my-replication-ID")
{
var setArgs = new SetVersioningArgs()
.WithBucket(bucketName)
.WithVersioningEnabled();
await minio.SetVersioningAsync(setArgs);
setArgs = new SetVersioningArgs()
.WithBucket(destBucketName)
.WithVersioningEnabled();
await minio.SetVersioningAsync(setArgs);
string serverEndPoint = "";
string schema = "http://";
string accessKey = "";
string secretKey = "";
if (Environment.GetEnvironmentVariable("SERVER_ENDPOINT") != null)
{
serverEndPoint = Environment.GetEnvironmentVariable("SERVER_ENDPOINT");
accessKey = Environment.GetEnvironmentVariable("ACCESS_KEY");
secretKey = Environment.GetEnvironmentVariable("SECRET_KEY");
if (Environment.GetEnvironmentVariable("ENABLE_HTTPS") != null)
{
if (Environment.GetEnvironmentVariable("ENABLE_HTTPS").Equals("1"))
{
schema = "https://";
}
}
}
else
{
serverEndPoint = "play.min.io";
accessKey = "Q3AM3UQ867SPQQA43P2F";
secretKey = "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG";
schema = "http://";
}
var cmdFullPathMC = Bash("which mc").TrimEnd('\r', '\n', ' ');
var cmdAlias = cmdFullPathMC + " alias list | egrep -B1 \"" +
schema + serverEndPoint + "\" | grep -v URL";
var alias = Bash(cmdAlias).TrimEnd('\r', '\n', ' ');
var cmdRemoteAdd = cmdFullPathMC + " admin bucket remote add " +
alias + "/" + bucketName + "/ " + schema +
accessKey + ":" + secretKey + "@" +
serverEndPoint + "/" + destBucketName +
" --service replication --region us-east-1";
var arn = Bash(cmdRemoteAdd).Replace("Remote ARN = `", "").Replace("`.", "");
ReplicationRule rule =
new ReplicationRule(
new DeleteMarkerReplication(DeleteMarkerReplication.StatusDisabled),
new ReplicationDestination(null, null,
"arn:aws:s3:::" + destBucketName,
null, null, null, null),
new ExistingObjectReplication(ExistingObjectReplication.StatusEnabled),
new RuleFilter(null, null, null),
new DeleteReplication(DeleteReplication.StatusDisabled),
1,
replicationCfgID,
"",
new SourceSelectionCriteria(new SseKmsEncryptedObjects(
SseKmsEncryptedObjects.StatusEnabled)),
ReplicationRule.StatusEnabled
);
List <ReplicationRule> rules = new List <ReplicationRule>();
rules.Add(rule);
ReplicationConfiguration repl = new ReplicationConfiguration(arn, rules);
await minio.SetBucketReplicationAsync(
new SetBucketReplicationArgs()
.WithBucket(bucketName)
.WithConfiguration(repl)
);
}
public AwsBlobStorageProvider(ILogger <AwsBlobStorageProvider> logger, MinioClient minioClient)
{
_logger = logger;
_minioClient = minioClient;
}
public FileSystemUtilities(IOptions <FileSystemOptions> fileSystemOptions)
{
_fileSystemOptions = fileSystemOptions.Value;
_minioClient = new MinioClient(_fileSystemOptions.Endpoint, _fileSystemOptions.AccessKey,
_fileSystemOptions.SecretKey);
}
public ScriptsController(MinioClient minioClient, MongoDbContext mongoDbContext)
{
_minioClient = minioClient;
_mongoDbContext = mongoDbContext;
}
internal MinioS3UploadClient(MinioClient client) => this.client_ = client;
internal ObjectService(string bucketName, string name, MinioClient client)
{
Client = client;
BucketName = bucketName;
Name = name;
}
public static void Main(string[] args)
{
String endPoint = null;
String accessKey = null;
String secretKey = null;
bool enableHTTPS = false;
if (Environment.GetEnvironmentVariable("SERVER_ENDPOINT") != null)
{
endPoint = Environment.GetEnvironmentVariable("SERVER_ENDPOINT");
accessKey = Environment.GetEnvironmentVariable("ACCESS_KEY");
secretKey = Environment.GetEnvironmentVariable("SECRET_KEY");
if (Environment.GetEnvironmentVariable("ENABLE_HTTPS") != null)
{
enableHTTPS = Environment.GetEnvironmentVariable("ENABLE_HTTPS").Equals("1");
}
}
else
{
endPoint = "play.minio.io:9000";
accessKey = "Q3AM3UQ867SPQQA43P2F";
secretKey = "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG";
enableHTTPS = true;
}
ServicePointManager.ServerCertificateValidationCallback +=
(sender, certificate, chain, sslPolicyErrors) => true;
// WithSSL() enables SSL support in Minio client
MinioClient minioClient = null;
if (enableHTTPS)
{
minioClient = new Minio.MinioClient(endPoint, accessKey, secretKey).WithSSL();
}
else
{
minioClient = new Minio.MinioClient(endPoint, accessKey, secretKey);
}
try
{
// Assign parameters before starting the test
string bucketName = GetRandomName();
string smallFileName = CreateFile(1 * UNIT_MB);
string bigFileName = CreateFile(6 * UNIT_MB);
string objectName = GetRandomName();
string destBucketName = GetRandomName();
string destObjectName = GetRandomName();
List <string> objectsList = new List <string>();
for (int i = 0; i < 10; i++)
{
objectsList.Add(objectName + i.ToString());
}
// Set app Info
minioClient.SetAppInfo("app-name", "app-version");
// Set HTTP Tracing On
// minioClient.SetTraceOn();
// Set HTTP Tracing Off
// minioClient.SetTraceOff();
// Check if bucket exists
Cases.BucketExists.Run(minioClient, bucketName).Wait();
// Create a new bucket
Cases.MakeBucket.Run(minioClient, bucketName).Wait();
Cases.MakeBucket.Run(minioClient, destBucketName).Wait();
// List all the buckets on the server
Cases.ListBuckets.Run(minioClient).Wait();
// Put an object to the new bucket
Cases.PutObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
// Get object metadata
Cases.StatObject.Run(minioClient, bucketName, objectName).Wait();
// List the objects in the new bucket
Cases.ListObjects.Run(minioClient, bucketName);
// Delete the file and Download the object as file
Cases.GetObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
// Delete the file and Download partial object as file
Cases.GetPartialObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
// Server side copyObject
Cases.CopyObject.Run(minioClient, bucketName, objectName, destBucketName, objectName).Wait();
// Server side copyObject with metadata replacement
Cases.CopyObjectMetadata.Run(minioClient, bucketName, objectName, destBucketName, objectName).Wait();
// Upload a File with PutObject
Cases.FPutObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
// Delete the file and Download the object as file
Cases.FGetObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
// Automatic Multipart Upload with object more than 5Mb
Cases.PutObject.Run(minioClient, bucketName, objectName, bigFileName).Wait();
// Specify SSE-C encryption options
Aes aesEncryption = Aes.Create();
aesEncryption.KeySize = 256;
aesEncryption.GenerateKey();
var ssec = new SSEC(aesEncryption.Key);
// Specify SSE-C source side encryption for Copy operations
var sseCpy = new SSECopy(aesEncryption.Key);
// Uncommment to specify SSE-S3 encryption option
// var sses3 = new SSES3();
// Uncommment to specify SSE-KMS encryption option
// var sseKms = new SSEKMS("kms-key",new Dictionary<string,string>{{ "kms-context", "somevalue"}});
// Upload encrypted object
Cases.PutObject.Run(minioClient, bucketName, objectName, smallFileName, sse: ssec).Wait();
// Copy SSE-C encrypted object to unencrypted object
Cases.CopyObject.Run(minioClient, bucketName, objectName, destBucketName, objectName, sseSrc: sseCpy, sseDest: ssec).Wait();
// Download SSE-C encrypted object
Cases.FGetObject.Run(minioClient, destBucketName, objectName, bigFileName, sse: ssec).Wait();
// List the incomplete uploads
Cases.ListIncompleteUploads.Run(minioClient, bucketName);
// Remove all the incomplete uploads
Cases.RemoveIncompleteUpload.Run(minioClient, bucketName, objectName).Wait();
// Set a policy for given bucket
Cases.SetBucketPolicy.Run(minioClient, bucketName).Wait();
// Get the policy for given bucket
Cases.GetBucketPolicy.Run(minioClient, bucketName).Wait();
// Set bucket notifications
Cases.SetBucketNotification.Run(minioClient, bucketName).Wait();
// Get bucket notifications
Cases.GetBucketNotification.Run(minioClient, bucketName).Wait();
// Remove all bucket notifications
Cases.RemoveAllBucketNotifications.Run(minioClient, bucketName).Wait();
// Get the presigned url for a GET object request
Cases.PresignedGetObject.Run(minioClient, bucketName, objectName).Wait();
// Get the presigned POST policy curl url
Cases.PresignedPostPolicy.Run(minioClient).Wait();
// Get the presigned url for a PUT object request
Cases.PresignedPutObject.Run(minioClient, bucketName, objectName).Wait();
// Delete the list of objects
Cases.RemoveObjects.Run(minioClient, bucketName, objectsList).Wait();
// Delete the object
Cases.RemoveObject.Run(minioClient, bucketName, objectName).Wait();
// Delete the object
Cases.RemoveObject.Run(minioClient, destBucketName, objectName).Wait();
// Tacing request with custom logger
Cases.CustomRequestLogger.Run(minioClient).Wait();
// Remove the buckets
Cases.RemoveBucket.Run(minioClient, bucketName).Wait();
Cases.RemoveBucket.Run(minioClient, destBucketName).Wait();
// Remove the binary files created for test
File.Delete(smallFileName);
File.Delete(bigFileName);
Console.ReadLine();
}
catch (MinioException ex)
{
Console.Out.WriteLine(ex.Message);
}
}
public void TestSetAppInfoFailsNullVersion()
{
var client = new MinioClient("http://localhost:9000");
client.SetAppInfo("Hello-App", null);
}
public SMinio()
{
minioClient = new MinioClient(minioConn.minioIp, minioConn.secretKey, minioConn.accessKey);
}
/// <summary>
/// 初始化客户端
/// </summary>
/// <param name="endpoint">端点</param>
/// <param name="accessKey">账号</param>
/// <param name="secretKey">私钥</param>
public MinIOHelper(string endpoint, string accessKey, string secretKey)
{
_minioClient = new MinioClient(endpoint, accessKey, secretKey);
}
public ResourceBootstrapService(MinioClient minio, RabbitMQ.Client.IModel model)
{
this.minio = minio;
this.model = model;
}
public static void Main(string[] args)
{
String endPoint = null;
String accessKey = null;
String secretKey = null;
bool enableHTTPS = false;
if (Environment.GetEnvironmentVariable("SERVER_ENDPOINT") != null)
{
endPoint = Environment.GetEnvironmentVariable("SERVER_ENDPOINT");
accessKey = Environment.GetEnvironmentVariable("ACCESS_KEY");
secretKey = Environment.GetEnvironmentVariable("SECRET_KEY");
if (Environment.GetEnvironmentVariable("ENABLE_HTTPS") != null)
{
enableHTTPS = Environment.GetEnvironmentVariable("ENABLE_HTTPS").Equals("1");
}
}
else
{
endPoint = "172.16.131.38:9003";
accessKey = "LO47Y1RNP2LVJ1A495A3";
secretKey = "5nZWV/8v9WbuDd7Gvcdepqklp/P7D6S/hvIT19dV";
enableHTTPS = false;
}
#if NET452
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12
| SecurityProtocolType.Tls11
| SecurityProtocolType.Tls12;
#endif
// WithSSL() enables SSL support in Minio client
MinioClient minioClient = null;
if (enableHTTPS)
{
minioClient = new Minio.MinioClient(endPoint, accessKey, secretKey).WithSSL();
}
else
{
minioClient = new Minio.MinioClient(endPoint, accessKey, secretKey);
}
try
{
// Assign parameters before starting the test
//string bucketName = GetRandomName();
string bucketName = "myleebucket";
//string smallFileName = CreateFile(1 * UNIT_MB);
//string bigFileName = CreateFile(6 * UNIT_MB);
//string objectName = GetRandomName();
string objectName = "objectlee";
//string destBucketName = GetRandomName();
//string destObjectName = GetRandomName();
List <string> objectsList = new List <string>();
for (int i = 0; i < 10; i++)
{
objectsList.Add(objectName + i.ToString());
}
// Set app Info
minioClient.SetAppInfo("app-name", "app-version");
// Set HTTP Tracing On
minioClient.SetTraceOn();
// Set HTTP Tracing Off
// minioClient.SetTraceOff();
// Check if bucket exists
Cases.BucketExists.Run(minioClient, bucketName).Wait();
// Create a new bucket
Cases.MakeBucket.Run(minioClient, bucketName).Wait();
//Cases.MakeBucket.Run(minioClient, destBucketName).Wait();
// List all the buckets on the server
// Cases.ListBuckets.Run(minioClient).Wait();
//// Put an object to the new bucket
//Cases.PutObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
//// Get object metadata
//Cases.StatObject.Run(minioClient, bucketName, objectName).Wait();
//// List the objects in the new bucket
//Cases.ListObjects.Run(minioClient, bucketName);
//// Delete the file and Download the object as file
//Cases.GetObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
//// Delete the file and Download partial object as file
//Cases.GetPartialObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
//// Server side copyObject
//Cases.CopyObject.Run(minioClient, bucketName, objectName, destBucketName, objectName).Wait();
//// Upload a File with PutObject
//Cases.FPutObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
//// Delete the file and Download the object as file
//Cases.FGetObject.Run(minioClient, bucketName, objectName, smallFileName).Wait();
//// Automatic Multipart Upload with object more than 5Mb
//Cases.PutObject.Run(minioClient, bucketName, objectName, bigFileName).Wait();
//// List the incomplete uploads
//Cases.ListIncompleteUploads.Run(minioClient, bucketName);
//// Remove all the incomplete uploads
//Cases.RemoveIncompleteUpload.Run(minioClient, bucketName, objectName).Wait();
//// Set a policy for given bucket
//Cases.SetBucketPolicy.Run(minioClient, bucketName).Wait();
//// Get the policy for given bucket
//Cases.GetBucketPolicy.Run(minioClient, bucketName).Wait();
//// Set bucket notifications
//Cases.SetBucketNotification.Run(minioClient, bucketName).Wait();
//// Get bucket notifications
//Cases.GetBucketNotification.Run(minioClient, bucketName).Wait();
//// Remove all bucket notifications
//Cases.RemoveAllBucketNotifications.Run(minioClient, bucketName).Wait();
//// Get the presigned url for a GET object request
//Cases.PresignedGetObject.Run(minioClient, bucketName, objectName).Wait();
//// Get the presigned POST policy curl url
//Cases.PresignedPostPolicy.Run(minioClient).Wait();
//// Get the presigned url for a PUT object request
//Cases.PresignedPutObject.Run(minioClient, bucketName, objectName).Wait();
//// Delete the list of objects
//Cases.RemoveObjects.Run(minioClient, bucketName, objectsList).Wait();
//// Delete the object
//Cases.RemoveObject.Run(minioClient, bucketName, objectName).Wait();
//// Delete the object
//Cases.RemoveObject.Run(minioClient, destBucketName, objectName).Wait();
//// Remove the buckets
//Cases.RemoveBucket.Run(minioClient, bucketName).Wait();
//Cases.RemoveBucket.Run(minioClient, destBucketName).Wait();
// Remove the binary files created for test
//File.Delete(smallFileName);
//File.Delete(bigFileName);
Console.ReadLine();
}
catch (MinioException ex)
{
Console.Out.WriteLine(ex.Message);
}
}
public MinioService()
{
_minioClient = ConnectionHelper.MinioConnection();
}
public AgentsController(ICommandExecutor commandExecutor, IConfiguration configuration, MinioClient minioClient)
{
_commandExecutor = commandExecutor;
_serverIp = configuration["RemoteServer:Ip"];
_serverPort = int.Parse(configuration["RemoteServer:Port"]);
_minioClient = minioClient;
}
public MinioAttachmentStoreService(IOptions <MinioOption> minioOptionAccessor)
{
_minioOption = minioOptionAccessor.Value;
_client = new MinioClient(_minioOption.Endpoint, _minioOption.AccessKey, _minioOption.SecretKey);
_logger = Log.ForContext <MinioAttachmentStoreService>();
}
public static void Main(string[] args)
{
string endPoint = null;
string accessKey = null;
string secretKey = null;
string enableHttps = "0";
string kmsEnabled = "0";
bool useAWS = Environment.GetEnvironmentVariable("AWS_ENDPOINT") != null;
if (Environment.GetEnvironmentVariable("SERVER_ENDPOINT") != null)
{
endPoint = Environment.GetEnvironmentVariable("SERVER_ENDPOINT");
accessKey = Environment.GetEnvironmentVariable("ACCESS_KEY");
secretKey = Environment.GetEnvironmentVariable("SECRET_KEY");
enableHttps = Environment.GetEnvironmentVariable("ENABLE_HTTPS");
kmsEnabled = Environment.GetEnvironmentVariable("ENABLE_KMS");
}
else
{
endPoint = "play.min.io";
accessKey = "Q3AM3UQ867SPQQA43P2F";
secretKey = "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG";
enableHttps = "1";
kmsEnabled = "1";
}
MinioClient minioClient = null;
if (enableHttps == "1")
{
// WithSSL() enables SSL support in MinIO client
minioClient = new MinioClient(endPoint, accessKey, secretKey).WithSSL();
}
else
{
minioClient = new MinioClient(endPoint, accessKey, secretKey);
}
// Assign parameters before starting the test
string bucketName = FunctionalTest.GetRandomName();
string objectName = FunctionalTest.GetRandomName();
string destBucketName = FunctionalTest.GetRandomName();
string destObjectName = FunctionalTest.GetRandomName();
// Set app Info
minioClient.SetAppInfo("app-name", "app-version");
// Set HTTP Tracing On
// minioClient.SetTraceOn(new JsonNetLogger());
// Set HTTP Tracing Off
// minioClient.SetTraceOff();
string runMode = Environment.GetEnvironmentVariable("MINT_MODE");
if (!string.IsNullOrEmpty(runMode) && runMode == "core")
{
FunctionalTest.RunCoreTests(minioClient);
Environment.Exit(0);
}
FunctionalTest.ListenBucketNotificationsAsync_Test1(minioClient).Wait();
// Check if bucket exists
FunctionalTest.BucketExists_Test(minioClient).Wait();
// Create a new bucket
FunctionalTest.MakeBucket_Test1(minioClient).Wait();
FunctionalTest.MakeBucket_Test2(minioClient).Wait();
FunctionalTest.MakeBucket_Test5(minioClient).Wait();
if (useAWS)
{
FunctionalTest.MakeBucket_Test3(minioClient).Wait();
FunctionalTest.MakeBucket_Test4(minioClient).Wait();
}
// Test removal of bucket
FunctionalTest.RemoveBucket_Test1(minioClient).Wait();
// Test ListBuckets function
FunctionalTest.ListBuckets_Test(minioClient).Wait();
// Test Putobject function
FunctionalTest.PutObject_Test1(minioClient).Wait();
FunctionalTest.PutObject_Test2(minioClient).Wait();
FunctionalTest.PutObject_Test3(minioClient).Wait();
FunctionalTest.PutObject_Test4(minioClient).Wait();
FunctionalTest.PutObject_Test5(minioClient).Wait();
FunctionalTest.PutObject_Test7(minioClient).Wait();
FunctionalTest.PutObject_Test8(minioClient).Wait();
// Test StatObject function
FunctionalTest.StatObject_Test1(minioClient).Wait();
// Test GetObjectAsync function
FunctionalTest.GetObject_Test1(minioClient).Wait();
FunctionalTest.GetObject_Test2(minioClient).Wait();
FunctionalTest.GetObject_Test3(minioClient).Wait();
// Test File GetObject and PutObject functions
FunctionalTest.FGetObject_Test1(minioClient).Wait();
// FIX=> FPutObject_Test1(minioClient).Wait();
FunctionalTest.FPutObject_Test2(minioClient).Wait();
// Test SelectObjectContentAsync function
FunctionalTest.SelectObjectContent_Test(minioClient).Wait();
// Test ListObjectAsync function
FunctionalTest.ListObjects_Test1(minioClient).Wait();
FunctionalTest.ListObjects_Test2(minioClient).Wait();
FunctionalTest.ListObjects_Test3(minioClient).Wait();
FunctionalTest.ListObjects_Test4(minioClient).Wait();
FunctionalTest.ListObjects_Test5(minioClient).Wait();
// Test RemoveObjectAsync function
FunctionalTest.RemoveObject_Test1(minioClient).Wait();
FunctionalTest.RemoveObjects_Test2(minioClient).Wait();
// Test CopyObjectAsync function
FunctionalTest.CopyObject_Test1(minioClient).Wait();
FunctionalTest.CopyObject_Test2(minioClient).Wait();
FunctionalTest.CopyObject_Test3(minioClient).Wait();
FunctionalTest.CopyObject_Test4(minioClient).Wait();
FunctionalTest.CopyObject_Test5(minioClient).Wait();
FunctionalTest.CopyObject_Test6(minioClient).Wait();
FunctionalTest.CopyObject_Test7(minioClient).Wait();
FunctionalTest.CopyObject_Test8(minioClient).Wait();
// Test SetPolicyAsync function
FunctionalTest.SetBucketPolicy_Test1(minioClient).Wait();
// Test Presigned Get/Put operations
FunctionalTest.PresignedGetObject_Test1(minioClient).Wait();
FunctionalTest.PresignedGetObject_Test2(minioClient).Wait();
FunctionalTest.PresignedGetObject_Test3(minioClient).Wait();
FunctionalTest.PresignedPutObject_Test1(minioClient).Wait();
FunctionalTest.PresignedPutObject_Test2(minioClient).Wait();
// Test incomplete uploads
FunctionalTest.ListIncompleteUpload_Test1(minioClient).Wait();
FunctionalTest.ListIncompleteUpload_Test2(minioClient).Wait();
FunctionalTest.ListIncompleteUpload_Test3(minioClient).Wait();
FunctionalTest.RemoveIncompleteUpload_Test(minioClient).Wait();
// Test GetBucket policy
FunctionalTest.GetBucketPolicy_Test1(minioClient).Wait();
// Test encryption
if (enableHttps == "1")
{
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;
FunctionalTest.PutGetStatEncryptedObject_Test1(minioClient).Wait();
FunctionalTest.PutGetStatEncryptedObject_Test2(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test1(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test2(minioClient).Wait();
}
if (kmsEnabled != null && kmsEnabled == "1")
{
FunctionalTest.PutGetStatEncryptedObject_Test3(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test3(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test4(minioClient).Wait();
}
}
public static void Main(string[] args)
{
string endPoint = null;
string accessKey = null;
string secretKey = null;
var enableHttps = "0";
var kmsEnabled = "0";
var useAWS = Environment.GetEnvironmentVariable("AWS_ENDPOINT") != null;
if (Environment.GetEnvironmentVariable("SERVER_ENDPOINT") != null)
{
endPoint = Environment.GetEnvironmentVariable("SERVER_ENDPOINT");
accessKey = Environment.GetEnvironmentVariable("ACCESS_KEY");
secretKey = Environment.GetEnvironmentVariable("SECRET_KEY");
enableHttps = Environment.GetEnvironmentVariable("ENABLE_HTTPS");
kmsEnabled = Environment.GetEnvironmentVariable("ENABLE_KMS");
}
else
{
endPoint = "play.min.io";
accessKey = "Q3AM3UQ867SPQQA43P2F";
secretKey = "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG";
enableHttps = "1";
kmsEnabled = "1";
}
MinioClient minioClient = null;
var clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) =>
{
return(true);
};
clientHandler.UseProxy = false;
var httpClient = new HttpClient(clientHandler);
if (enableHttps == "1")
{
// WithSSL() enables SSL support in MinIO client
minioClient = new MinioClient()
.WithSSL()
.WithCredentials(accessKey, secretKey)
.WithEndpoint(endPoint)
.WithHttpClient(httpClient)
.Build();
}
else
{
minioClient = new MinioClient()
.WithCredentials(accessKey, secretKey)
.WithEndpoint(endPoint)
.Build();
}
// Assign parameters before starting the test
var bucketName = FunctionalTest.GetRandomName();
var objectName = FunctionalTest.GetRandomName();
var destBucketName = FunctionalTest.GetRandomName();
var destObjectName = FunctionalTest.GetRandomName();
// Set app Info
minioClient.SetAppInfo("app-name", "app-version");
// Set HTTP Tracing On
// minioClient.SetTraceOn(new JsonNetLogger());
// Set HTTP Tracing Off
// minioClient.SetTraceOff();
var runMode = Environment.GetEnvironmentVariable("MINT_MODE");
if (!string.IsNullOrEmpty(runMode) && runMode == "core")
{
FunctionalTest.RunCoreTests(minioClient);
Environment.Exit(0);
}
// Try catch as 'finally' section needs to run in the Functional Tests
// Bucket notification is a minio specific feature.
// If the following test is run against AWS, then the SDK throws
// "Listening for bucket notification is specific only to `minio`
// server endpoints".
FunctionalTest.ListenBucketNotificationsAsync_Test1(minioClient).Wait();
// Check if bucket exists
FunctionalTest.BucketExists_Test(minioClient).Wait();
FunctionalTest.MakeBucket_Test5(minioClient).Wait();
if (useAWS)
{
FunctionalTest.MakeBucket_Test2(minioClient, useAWS).Wait();
FunctionalTest.MakeBucket_Test3(minioClient, useAWS).Wait();
FunctionalTest.MakeBucket_Test4(minioClient, useAWS).Wait();
}
// Test removal of bucket
FunctionalTest.RemoveBucket_Test1(minioClient).Wait();
// Test ListBuckets function
FunctionalTest.ListBuckets_Test(minioClient).Wait();
// Test Putobject function
FunctionalTest.PutObject_Test1(minioClient).Wait();
FunctionalTest.PutObject_Test2(minioClient).Wait();
FunctionalTest.PutObject_Test3(minioClient).Wait();
FunctionalTest.PutObject_Test4(minioClient).Wait();
FunctionalTest.PutObject_Test5(minioClient).Wait();
FunctionalTest.PutObject_Test7(minioClient).Wait();
FunctionalTest.PutObject_Test8(minioClient).Wait();
// Test StatObject function
FunctionalTest.StatObject_Test1(minioClient).Wait();
// Test GetObjectAsync function
FunctionalTest.GetObject_Test1(minioClient).Wait();
FunctionalTest.GetObject_Test2(minioClient).Wait();
FunctionalTest.GetObject_Test3(minioClient).Wait();
// Test File GetObject and PutObject functions
FunctionalTest.FGetObject_Test1(minioClient).Wait();
FunctionalTest.FPutObject_Test2(minioClient).Wait();
// Test SelectObjectContentAsync function
FunctionalTest.SelectObjectContent_Test(minioClient).Wait();
// Test ListObjectAsync function
FunctionalTest.ListObjects_Test1(minioClient).Wait();
FunctionalTest.ListObjects_Test2(minioClient).Wait();
FunctionalTest.ListObjects_Test3(minioClient).Wait();
FunctionalTest.ListObjects_Test4(minioClient).Wait();
FunctionalTest.ListObjects_Test5(minioClient).Wait();
FunctionalTest.ListObjects_Test6(minioClient).Wait();
// Test RemoveObjectAsync function
FunctionalTest.RemoveObject_Test1(minioClient).Wait();
FunctionalTest.RemoveObjects_Test2(minioClient).Wait();
FunctionalTest.RemoveObjects_Test3(minioClient).Wait();
// Test CopyObjectAsync function
FunctionalTest.CopyObject_Test1(minioClient).Wait();
FunctionalTest.CopyObject_Test2(minioClient).Wait();
FunctionalTest.CopyObject_Test3(minioClient).Wait();
FunctionalTest.CopyObject_Test4(minioClient).Wait();
FunctionalTest.CopyObject_Test5(minioClient).Wait();
FunctionalTest.CopyObject_Test6(minioClient).Wait();
FunctionalTest.CopyObject_Test7(minioClient).Wait();
FunctionalTest.CopyObject_Test8(minioClient).Wait();
// Test SetPolicyAsync function
FunctionalTest.SetBucketPolicy_Test1(minioClient).Wait();
// Test Presigned Get/Put operations
FunctionalTest.PresignedGetObject_Test1(minioClient).Wait();
FunctionalTest.PresignedGetObject_Test2(minioClient).Wait();
FunctionalTest.PresignedGetObject_Test3(minioClient).Wait();
FunctionalTest.PresignedPutObject_Test1(minioClient).Wait();
FunctionalTest.PresignedPutObject_Test2(minioClient).Wait();
FunctionalTest.PresignedGetObject_Test1(minioClient).Wait();
// FunctionalTest.PresignedPostPolicy_Test1(minioClient).Wait();
// Test incomplete uploads
FunctionalTest.ListIncompleteUpload_Test1(minioClient).Wait();
FunctionalTest.ListIncompleteUpload_Test2(minioClient).Wait();
FunctionalTest.ListIncompleteUpload_Test3(minioClient).Wait();
FunctionalTest.RemoveIncompleteUpload_Test(minioClient).Wait();
// Test GetBucket policy
FunctionalTest.GetBucketPolicy_Test1(minioClient).Wait();
// Test Object Lock Configuration
FunctionalTest.ObjectLockConfigurationAsync_Test1(minioClient).Wait();
// Test Bucket, Object Tags
FunctionalTest.BucketTagsAsync_Test1(minioClient).Wait();
FunctionalTest.ObjectTagsAsync_Test1(minioClient).Wait();
// Test Bucket Lifecycle configuration
FunctionalTest.BucketLifecycleAsync_Test1(minioClient).Wait();
FunctionalTest.BucketLifecycleAsync_Test2(minioClient).Wait();
// Test encryption
if (enableHttps == "1")
{
ServicePointManager.ServerCertificateValidationCallback +=
(sender, certificate, chain, sslPolicyErrors) => true;
FunctionalTest.PutGetStatEncryptedObject_Test1(minioClient).Wait();
FunctionalTest.PutGetStatEncryptedObject_Test2(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test1(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test2(minioClient).Wait();
}
if (kmsEnabled != null && kmsEnabled == "1")
{
FunctionalTest.PutGetStatEncryptedObject_Test3(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test3(minioClient).Wait();
FunctionalTest.EncryptedCopyObject_Test4(minioClient).Wait();
}
}
public void TestSetAppInfoFailsNullApp()
{
var client = new MinioClient("http://localhost:9000");
client.SetAppInfo(null, "1.2.2");
}
public ReportPdfBucketService(MinioClient minioClient, TradeUnionCommitteeCloudStorageContext context)
{
_minioClient = minioClient;
_context = context;
}
public void TestSetAppInfoSuccess()
{
var client = new MinioClient("http://localhost:9000");
client.SetAppInfo("Hello-App", "1.2.1");
}
public DocumentService(MinioClient minio, IConfiguration configuration)
{
_minio = minio ?? throw new ArgumentNullException(nameof(minio));
_bucketName = configuration["Minio:MinioBucket:bucketName"];
}
public ViewJournalModel(MSSQLDB db, MinioClient minioClient)
{
_db = db;
_minioClient = minioClient;
}
internal S3ObjectsListingClient(MinioClient client) => this.client_ = client;
public void TestSetAppInfoFailsNullApp()
{
var client = new MinioClient("http://localhost:9000");
client.SetAppInfo(null, "1.2.2");
}
public MinioWriteBucket(MinioClient client) : base(client)
{
}
public void TestSetAppInfoSuccess()
{
var client = new MinioClient("http://localhost:9000");
client.SetAppInfo("Hello-App", "1.2.1");
}
public MinioBucketStorage(MinioClient client, string bucketName)
{
_client = client;
_bucketName = bucketName;
}
