private static async Task UploadDirAsync()
{
var putRequest2 = new PutObjectRequest
{
};
try
{
var directoryTransferUtility =
new TransferUtility(s3Client);
// 1. Upload a directory.
await directoryTransferUtility.UploadDirectoryAsync(directoryPath,
existingBucketName);
Console.WriteLine("Upload statement 1 completed");
// 2. Upload only the .txt files from a directory
// and search recursively.
await directoryTransferUtility.UploadDirectoryAsync(
directoryPath,
existingBucketName,
wildCard,
SearchOption.AllDirectories);
Console.WriteLine("Upload statement 2 completed");
// 3. The same as Step 2 and some optional configuration.
// Search recursively for .txt files to upload.
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = existingBucketName,
Directory = directoryPath,
SearchOption = SearchOption.AllDirectories,
SearchPattern = wildCard
};
await directoryTransferUtility.UploadDirectoryAsync(request);
Console.WriteLine("Upload statement 3 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine(
"Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine(
"Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
/// <summary>
/// Uses an S3 multi-part transfer to upload all of the text files in
/// a local directory to an S3 bucket.
/// </summary>
/// <param name="client">The initialized S3 client object used to
/// perform the multi-part upload.</param>
/// <param name="bucketName">The name of the bucket to which the files
/// will be uploaded from the local directory.</param>
/// <param name="directoryPath">The path of the local directory that
/// contains the files to upload to the S3 bucket.</param>
/// <param name="wildCard">The wild card used to filter the files to
/// be uploaded.</param>
private static async Task UploadDirAsync(
IAmazonS3 client,
string bucketName,
string directoryPath,
string wildCard)
{
try
{
var directoryTransferUtility =
new TransferUtility(client);
// Upload the entire contents of a local directory to an S3
// bucket.
await directoryTransferUtility.UploadDirectoryAsync(
directoryPath,
bucketName);
Console.WriteLine("Upload statement 1 completed");
// Upload only the text files from a local directory using a
// recursive search to find text files in child directories.
await directoryTransferUtility.UploadDirectoryAsync(
directoryPath,
bucketName,
wildCard,
SearchOption.AllDirectories);
Console.WriteLine("Upload statement 2 completed");
// Performs the same as before using the
// TransferUtilityUploadDirectoryRequest instead of individual
// parameters.
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = bucketName,
Directory = directoryPath,
SearchOption = SearchOption.AllDirectories,
SearchPattern = wildCard,
};
await directoryTransferUtility.UploadDirectoryAsync(request);
Console.WriteLine("Upload statement 3 completed");
}
catch (AmazonS3Exception ex)
{
Console.WriteLine(
$"Error: {ex.Message}");
}
}
public async Task UploadDirectory(string uploadDirectoryPath)
{
using (var fileTransferUtility = new TransferUtility(client))
{
await fileTransferUtility.UploadDirectoryAsync(uploadDirectoryPath, BucketName);
}
}
private static async void UploadAsync(RegionEndpoint bucketRegion, string bucketName, string iamAccessKeyId, string iamSecretKey, string path)
{
try
{
Debug.Log("Starting upload...");
BasicAWSCredentials credentials = new BasicAWSCredentials(iamAccessKeyId, iamSecretKey);
AmazonS3Client s3Client = new AmazonS3Client(credentials, bucketRegion);
TransferUtility transferUtility = new TransferUtility(s3Client);
TransferUtilityUploadDirectoryRequest transferUtilityRequest = new TransferUtilityUploadDirectoryRequest
{
BucketName = bucketName,
Directory = path,
StorageClass = S3StorageClass.StandardInfrequentAccess,
CannedACL = S3CannedACL.PublicRead,
SearchOption = SearchOption.AllDirectories,
};
await transferUtility.UploadDirectoryAsync(transferUtilityRequest);
Debug.Log("Upload completed");
}
catch (AmazonS3Exception e)
{
Debug.LogError("Error encountered on server when writing an object: " + e.Message);
}
catch (Exception e)
{
Debug.LogError("Unknown encountered on server when writing an object: " + e.Message);
}
}
private async Task SaveLogsToS3(string finalLogDir)
{
var bucketName = s3BucketName;
var bucketKey = s3BucketKey;
var bucketRegion = RegionEndpoint.GetBySystemName(awsRegion);
LogWriter.LogInfo("AWS.S3", "Beginning S3 Upload");
s3Client = new AmazonS3Client(bucketRegion);
var transferUtility = new TransferUtility(s3Client);
await transferUtility.UploadDirectoryAsync(finalLogDir, bucketName);
LogWriter.LogInfo("AWS.S3", "Completed S3 Upload");
}
public async Task RunCode()
{
var client = new AmazonS3Client();
Console.Write("Upload yapmak istediğiniz bucket ismini giriniz : ");
var bucketName = Console.ReadLine();
Console.Write("Upload yapmak istediğiniz nedir ? [Dosya = 1 , Klasör = 2] : ");
var fileType = Console.ReadLine();
Console.WriteLine();
Console.Write("Upload yapmak istediğiniz dosya/klasör public olarak kullanılabilsin mi ? [y/n] : ");
var accessType = Console.ReadLine();
Console.WriteLine();
Console.Write("Upload yapmak istediğiniz dosya/klasör tam yolunu giriniz : ");
var filePath = Console.ReadLine();
#region Bucket Upload için kullanılan Kod Bloğu
var transferUtility = new TransferUtility(client);
switch (fileType)
{
// Dosya yüklemek için kullanılan alan
case "1":
var transferForFileRequest = new TransferUtilityUploadRequest {
FilePath = filePath,
BucketName = bucketName,
CannedACL = (accessType == "y") ? S3CannedACL.PublicRead : S3CannedACL.Private
};
await transferUtility.UploadAsync(transferForFileRequest);
break;
// Klasör yüklemek için kullanılan alan
case "2":
var transferForFolderRequest = new TransferUtilityUploadDirectoryRequest {
Directory = filePath,
BucketName = bucketName,
CannedACL = (accessType == "y") ? S3CannedACL.PublicRead : S3CannedACL.Private
};
await transferUtility.UploadDirectoryAsync(transferForFolderRequest);
break;
}
#endregion
}
public static async Task UploadDirectory(string directory, string bucketName, string keyPrefix, bool recursive = false, Credentials credentials = null)
{
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = bucketName,
Directory = directory,
KeyPrefix = keyPrefix,
SearchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly
};
request.UploadDirectoryFileRequestEvent += (sender, args) =>
Console.WriteLine($"Uploading \"{args.UploadRequest.FilePath}\" to S3 bucket \"{bucketName}\"...");
using (var transferUtility = new TransferUtility(GetClient(credentials)))
{
await transferUtility.UploadDirectoryAsync(request);
}
}
public async Task UploadDirectoryWithTagsTest()
{
for (int i = 1; i < 4; i++)
{
UtilityMethods.GenerateFile(Path.Combine(basePath, "tempfile-" + i), MEG_SIZE / i);
}
var uploadRequest = new TransferUtilityUploadDirectoryRequest
{
BucketName = testBucketName,
Directory = basePath,
TagSet = new List <Tag>
{
new Tag
{
Key = "hello",
Value = "world"
}
}
};
using (var transferUtility = new TransferUtility(Client))
{
await transferUtility.UploadDirectoryAsync(uploadRequest);
}
var objects = Client.ListObjectsAsync(new ListObjectsRequest
{
BucketName = testBucketName
}).Result.S3Objects;
foreach (var obj in objects)
{
var tags = Client.GetObjectTaggingAsync(new GetObjectTaggingRequest
{
BucketName = testBucketName,
Key = obj.Key
}).Result.Tagging;
Assert.Equal(1, tags.Count);
Assert.Equal("hello", tags[0].Key);
Assert.Equal("world", tags[0].Value);
}
}
// s3 upload directory
private static async Task UploadDirAsync(IAmazonS3 s3Client, string localDirectory, string s3Path)
{
try
{
// create the directoryTransferUtility object
var directoryTransferUtility = new TransferUtility(s3Client);
// Upload a directory
//await directoryTransferUtility.UploadDirectoryAsync(localDirectory, s3Path, wildCard, SearchOption.AllDirectories);
await directoryTransferUtility.UploadDirectoryAsync(localDirectory, s3Path);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
public async Task UploadDirectory(string path, Action <float> progressCallback, string pattern = "*")
{
LastActionSuccessful = true;
await CarryOutAWSTask(async() =>
{
TransferUtility fileTransferUtility = new TransferUtility(Client);
TransferUtilityUploadDirectoryRequest uploadRequest = new TransferUtilityUploadDirectoryRequest
{
BucketName = S3BucketName,
Directory = path,
// Amazon-only: StorageClass = S3StorageClass.StandardInfrequentAccess,
CannedACL = S3CannedACL.PublicRead,
SearchPattern = pattern,
SearchOption = SearchOption.AllDirectories,
};
uploadRequest.UploadDirectoryProgressEvent += (sender, e) => { progressCallback((float)e.TransferredBytes / e.TotalBytes); };
await fileTransferUtility.UploadDirectoryAsync(uploadRequest);
progressCallback(1);
}, "storing directory");
}
public async Task UploadDirectory(string path, Action <float> progressCallback)
{
await CarryOutAWSTask(async() =>
{
var fileTransferUtility = new TransferUtility(Client);
var uploadRequest = new TransferUtilityUploadDirectoryRequest
{
BucketName = S3BucketName,
Directory = path,
// Amazon-only: StorageClass = S3StorageClass.StandardInfrequentAccess,
CannedACL = S3CannedACL.PublicRead,
SearchOption = SearchOption.AllDirectories,
};
uploadRequest.UploadDirectoryProgressEvent += new EventHandler <UploadDirectoryProgressArgs>((sender, e) =>
{
progressCallback((float)e.TransferredBytes / e.TotalBytes);
});
await fileTransferUtility.UploadDirectoryAsync(uploadRequest);
progressCallback(1);
}, "storing directory");
}
public async Task <bool> UploadIndexFileAndDirectory(string file, string directory, OVEAssetModel asset)
{
_logger.LogInformation($"about to upload index {file} and directory {directory}");
using (var fileTransferUtility = new TransferUtility(GetS3Client(_configuration))) {
// upload the index file
var assetRootFolder = Path.GetDirectoryName(asset.StorageLocation);
var filesKeyPrefix = assetRootFolder + "/" + new DirectoryInfo(directory).Name + "/"; // upload to the right folder
TransferUtilityUploadRequest req = new TransferUtilityUploadRequest {
BucketName = asset.Project,
Key = assetRootFolder + "/" + Path.GetFileName(file),
FilePath = file
};
await fileTransferUtility.UploadAsync(req);
// upload the tile files
TransferUtilityUploadDirectoryRequest request =
new TransferUtilityUploadDirectoryRequest()
{
KeyPrefix = filesKeyPrefix,
Directory = directory,
BucketName = asset.Project,
SearchOption = SearchOption.AllDirectories,
SearchPattern = "*.*"
};
await fileTransferUtility.UploadDirectoryAsync(request);
_logger.LogInformation($"finished upload for index {file} and directory {directory}");
return(true);
}
}
public async Task UploadObjects(string contentFolder)
{
var transfer = new TransferUtility(client);
await transfer.UploadDirectoryAsync(contentFolder, AWS_S3BucketName, "*", SearchOption.AllDirectories);
}
