public void SendDirectory(string directory, string bucket, string destinationPath)
{
try
{
var transferUtility = new TransferUtility(amazonS3Client);
if (!transferUtility.S3Client.DoesS3BucketExist(bucket))
transferUtility.S3Client.PutBucket(new PutBucketRequest { BucketName = bucket });
var request = new TransferUtilityUploadDirectoryRequest()
{
BucketName = bucket,
Directory = directory,
KeyPrefix = destinationPath
};
request.UploadDirectoryProgressEvent += uploadDirectoryProgressCallback;
transferUtility.UploadDirectory(request);
transferUtility.Dispose();
}
catch (Exception ex)
{
throw new Exception("Error send directory to S3. " + ex.Message);
}
}
/// <summary>
/// Initiates the asynchronous execution of the UploadDirectory operation.
/// <seealso cref="M:Amazon.S3.Transfer.TransferUtility.UploadDirectory"/>
/// </summary>
/// <param name="directory">
/// The source directory, that is, the directory containing the files to upload.
/// </param>
/// <param name="bucketName">
/// The target Amazon S3 bucket, that is, the name of the bucket to upload the files to.
/// </param>
/// <param name="searchPattern">
/// A pattern used to identify the files from the source directory to upload.
/// </param>
/// <param name="searchOption">
/// A search option that specifies whether to recursively search for files to upload
/// in subdirectories.
/// </param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback procedure using the AsyncState property.</param>
/// <exception cref="T:System.ArgumentNullException"></exception>
/// <exception cref="T:System.Net.WebException"></exception>
/// <exception cref="T:Amazon.S3.AmazonS3Exception"></exception>
/// <returns>An IAsyncResult that can be used to poll, or wait for results, or both.
/// This value is also needed when invoking EndUploadDirectory.</returns>
public IAsyncResult BeginUploadDirectory(string directory, string bucketName, string searchPattern, SearchOption searchOption, AsyncCallback callback, object state)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
{
BucketName = bucketName,
Directory = directory,
SearchPattern = searchPattern,
SearchOption = searchOption
};
return BeginUploadDirectory(request, callback, state);
}
/// <summary>
/// Uploads files from a specified directory.
/// The object key is derived from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <param name="directory">
/// The source directory, that is, the directory containing the files to upload.
/// </param>
/// <param name="bucketName">
/// The target Amazon S3 bucket, that is, the name of the bucket to upload the files to.
/// </param>
public void UploadDirectory(string directory, string bucketName)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest
{
BucketName = bucketName,
Directory = directory
};
UploadDirectory(request);
}
/// <summary>
/// This method is called in background thread so as not to block the UI as the upload is
/// going.
/// </summary>
/// <param name="state">unused</param>
private void threadedUploadDirectory(object state)
{
try
{
// Make sure the bucket exists
this._transferUtility.S3Client.PutBucket(new PutBucketRequest() { BucketName = this.Bucket });
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
{
BucketName = this.Bucket,
Directory = this.UploadDirectory,
SearchOption = SearchOption.AllDirectories
};
request.UploadDirectoryProgressEvent += this.uploadDirectoryProgressCallback;
this._transferUtility.UploadDirectory(request);
displayMessageBox("Completed directory upload!", "Success", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
updateIsEnabled(this._ctlUploadDirectory, true);
}
}
/// <summary>
/// This method is called in background thread so as not to block the UI as the upload is
/// going.
/// </summary>
/// <param name="state">unused</param>
private void threadedUploadDirectory(object state)
{
try
{
// Make sure the bucket exists
this._transferUtility.S3Client.PutBucket(new PutBucketRequest().WithBucketName(this.Bucket));
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
.WithBucketName(this.Bucket)
.WithDirectory(this.UploadDirectory)
.WithSearchOption(SearchOption.AllDirectories)
.WithTimeout(FIVE_MINUTES)
.WithSubscriber(this.uploadDirectoryProgressCallback); // Pass in a callback so upload progress can be tracked.
this._transferUtility.UploadDirectory(request);
displayMessageBox("Completed directory upload!", "Success", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
updateIsEnabled(this._ctlUploadDirectory, true);
}
}
/// <summary>
/// Uploads the files in directory. The object key is obtained from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <param name="request">
/// The request that contains all the parameters to upload a directory.
/// </param>
public void UploadDirectory(TransferUtilityUploadDirectoryRequest request)
{
validate(request);
UploadDirectoryCommand command = new UploadDirectoryCommand(this, request);
command.Execute();
}
/// <summary>
/// Uploads the files in directory. The object key is obtained from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <param name="directory">
/// The directory containing files to upload.
/// </param>
/// <param name="bucketName">
/// The name of the bucket to upload files to.
/// </param>
public void UploadDirectory(string directory, string bucketName)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
.WithBucketName(bucketName)
.WithDirectory(directory);
UploadDirectory(request);
}
/// <summary>
/// Initiates the asynchronous execution of the UploadDirectory operation.
/// <seealso cref="M:Amazon.S3.Transfer.TransferUtility.UploadDirectory"/>
/// </summary>
/// <param name="directory">
/// The directory containing files to upload.
/// </param>
/// <param name="bucketName">
/// The name of the bucket to upload files to.
/// </param>
/// <param name="searchPattern">
/// The pattern used to find files to upload in the directory.
/// </param>
/// <param name="searchOption">
/// The search option specifying whether or not to recursively search for files to upload
/// in subdirectories or not.
/// </param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback procedure using the AsyncState property.</param>
/// <exception cref="T:System.ArgumentNullException"></exception>
/// <exception cref="T:System.Net.WebException"></exception>
/// <exception cref="T:Amazon.S3.AmazonS3Exception"></exception>
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both;
/// this value is also needed when invoking EndUploadDirectory.</returns>
public IAsyncResult BeginUploadDirectory(string directory, string bucketName, string searchPattern, SearchOption searchOption, AsyncCallback callback, object state)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
.WithBucketName(bucketName)
.WithDirectory(directory)
.WithSearchPattern(searchPattern)
.WithSearchOption(searchOption);
return BeginUploadDirectory(request, callback, state);
}
private void UploadDirectoryHelper(TransferUtilityUploadDirectoryRequest request)
{
validate(request);
UploadDirectoryCommand command = new UploadDirectoryCommand(this, this._config, request);
command.Execute();
}
private void UploadDirectoryHelper(string directory, string bucketName, string searchPattern, SearchOption searchOption)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
{
BucketName = bucketName,
Directory = directory,
SearchPattern = searchPattern,
SearchOption = searchOption
};
UploadDirectoryHelper(request);
}
private void UploadDirectoryHelper(string directory, string bucketName)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
{
BucketName = bucketName,
Directory = directory
};
UploadDirectoryHelper(request);
}
/// <summary>
/// Initiates the asynchronous execution of the UploadDirectory operation.
/// <seealso cref="Amazon.S3.IAmazonS3.AbortMultipartUpload"/>
/// </summary>
/// <remarks>
/// <para>
/// If you are uploading large files, TransferUtility will use multipart upload to fulfill the request.
/// If a multipart upload is interrupted, TransferUtility will attempt to abort the multipart upload.
/// Under certain circumstances (network outage, power failure, etc.), TransferUtility will not be able
/// to abort the multipart upload. In this case, in order to stop getting charged for the storage of uploaded parts,
/// you should manually invoke TransferUtility.AbortMultipartUploads() to abort the incomplete multipart uploads.
/// </para>
/// </remarks>
/// <param name="request">
/// The request that contains all the parameters required to upload a directory.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task UploadDirectoryAsync(TransferUtilityUploadDirectoryRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
return(ExecuteAsync(() => UploadDirectoryHelper(request), cancellationToken));
}
/// <summary>
/// ディレクトリ丸ごとコピー
/// </summary>
/// <param name="directory"></param>
private void CopyDirectory( string directory )
{
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = this.Bucket,
Directory = directory,
KeyPrefix = procDirectoryName(directory)
};
if ( !OnlyCount ) transferUtility.UploadDirectory(request);
Console.WriteLine("[{0}]", directory);
}
/// <summary>
/// Uploads files from a specified directory.
/// The object key is derived from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <remarks>
/// <para>
/// If you are uploading large files, TransferUtility will use multipart upload to fulfill the request.
/// If a multipart upload is interrupted, TransferUtility will attempt to abort the multipart upload.
/// Under certain circumstances (network outage, power failure, etc.), TransferUtility will not be able
/// to abort the multipart upload. In this case, in order to stop getting charged for the storage of uploaded parts,
/// you should manually invoke TransferUtility.AbortMultipartUploads() to abort the incomplete multipart uploads.
/// </para>
/// </remarks>
/// <param name="request">
/// The request that contains all the parameters required to upload a directory.
/// </param>
public void UploadDirectory(TransferUtilityUploadDirectoryRequest request)
{
try
{
UploadDirectoryAsync(request).Wait();
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
}
}
/// <summary>
/// Uploads files from a specified directory.
/// The object key is derived from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <param name="request">
/// The request that contains all the parameters required to upload a directory.
/// </param>
public void UploadDirectory(TransferUtilityUploadDirectoryRequest request)
{
UploadDirectoryHelper(request);
}
/// <summary>
/// Initiates the asynchronous execution of the UploadDirectory operation.
/// <seealso cref="M:Amazon.S3.Transfer.TransferUtility.UploadDirectory"/>
/// </summary>
/// <param name="directory">
/// The directory containing files to upload.
/// </param>
/// <param name="bucketName">
/// The name of the bucket to upload files to.
/// </param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback procedure using the AsyncState property.</param>
/// <exception cref="T:System.ArgumentNullException"></exception>
/// <exception cref="T:System.Net.WebException"></exception>
/// <exception cref="T:Amazon.S3.AmazonS3Exception"></exception>
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both;
/// this value is also needed when invoking EndUploadDirectory.</returns>
public IAsyncResult BeginUploadDirectory(string directory, string bucketName, AsyncCallback callback, object state)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
.WithBucketName(bucketName)
.WithDirectory(directory);
return BeginUploadDirectory(request, callback, state);
}
public void UploadFolder(String folderPath)
{
MessageToUser m = new MessageToUser();
Thread startingThread = new Thread(m.UploadToS3);
startingThread.Start();
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
{
BucketName = _bucket,
Directory = folderPath,
SearchOption = SearchOption.AllDirectories,
SearchPattern = "*.zip",
KeyPrefix = "mods"
};
TransferUtility directorytTransferUtility = new TransferUtility(_client);
directorytTransferUtility.UploadDirectory(request);
MessageBox.Show("Done uploading files to s3");
}
/// <summary>
/// Initiates the asynchronous execution of the UploadDirectory operation.
/// <seealso cref="M:Amazon.S3.Transfer.TransferUtility.UploadDirectory"/>
/// </summary>
/// <param name="request">
/// The request that contains all the parameters to upload a directory.
/// </param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback procedure using the AsyncState property.</param>
/// <exception cref="T:System.ArgumentNullException"></exception>
/// <exception cref="T:System.Net.WebException"></exception>
/// <exception cref="T:Amazon.S3.AmazonS3Exception"></exception>
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both;
/// this value is also needed when invoking EndUploadDirectory.</returns>
public IAsyncResult BeginUploadDirectory(TransferUtilityUploadDirectoryRequest request, AsyncCallback callback, object state)
{
validate(request);
UploadDirectoryCommand command = new UploadDirectoryCommand(this, request);
return beginOperation(command, callback, state);
}
/// <summary>
/// Uploads files from a specified directory.
/// The object key is derived from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <remarks>
/// <para>
/// If you are uploading large files, TransferUtility will use multipart upload to fulfill the request.
/// If a multipart upload is interrupted, TransferUtility will attempt to abort the multipart upload.
/// Under certain circumstances (network outage, power failure, etc.), TransferUtility will not be able
/// to abort the multipart upload. In this case, in order to stop getting charged for the storage of uploaded parts,
/// you should manually invoke TransferUtility.AbortMultipartUploads() to abort the incomplete multipart uploads.
/// </para>
/// </remarks>
/// <param name="request">
/// The request that contains all the parameters required to upload a directory.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task UploadDirectoryAsync(TransferUtilityUploadDirectoryRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
validate(request);
UploadDirectoryCommand command = new UploadDirectoryCommand(this, this._config, request);
command.UploadFilesConcurrently = request.UploadFilesConcurrently;
return command.ExecuteAsync(cancellationToken);
}
/// <summary>
/// Uploads the files in directory. The object key is obtained from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <param name="directory">
/// The directory containing files to upload.
/// </param>
/// <param name="bucketName">
/// The name of the bucket to upload files to.
/// </param>
/// <param name="searchPattern">
/// The pattern used to find files to upload in the directory.
/// </param>
/// <param name="searchOption">
/// The search option specifying whether or not to recursively search for files to upload
/// in subdirectories or not.
/// </param>
public void UploadDirectory(string directory, string bucketName, string searchPattern, SearchOption searchOption)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest()
.WithBucketName(bucketName)
.WithDirectory(directory)
.WithSearchPattern(searchPattern)
.WithSearchOption(searchOption);
UploadDirectory(request);
}
/// <summary>
/// Uploads the files in directory. The object key is obtained from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <param name="request">
/// The request that contains all the parameters to upload a directory.
/// </param>
public void UploadDirectory(TransferUtilityUploadDirectoryRequest request)
{
if (!request.IsSetDirectory())
{
throw new ArgumentNullException("directory");
}
if (!request.IsSetBucketName())
{
throw new ArgumentNullException("bucketName");
}
if (!Directory.Exists(request.Directory))
{
throw new ArgumentException(string.Format("The directory {0} does not exists!", request.Directory), "directory");
}
UploadDirectoryCommand command = new UploadDirectoryCommand(this, request);
command.Execute();
}
void validate(TransferUtilityUploadDirectoryRequest request)
{
if (!request.IsSetDirectory())
{
throw new ArgumentNullException("directory");
}
if (!request.IsSetBucketName())
{
throw new ArgumentNullException("bucketName");
}
if (!Directory.Exists(request.Directory))
{
throw new ArgumentException(string.Format("The directory {0} does not exists!", request.Directory), "directory");
}
}
/// <summary>
/// Uploads files from a specified directory.
/// The object key is derived from the file names
/// inside the directory.
/// For large uploads, the file will be divided and uploaded in parts using
/// Amazon S3's multipart API. The parts will be reassembled as one object in
/// Amazon S3.
/// </summary>
/// <param name="directory">
/// The source directory, that is, the directory containing the files to upload.
/// </param>
/// <param name="bucketName">
/// The target Amazon S3 bucket, that is, the name of the bucket to upload the files to.
/// </param>
/// <param name="searchPattern">
/// A pattern used to identify the files from the source directory to upload.
/// </param>
/// <param name="searchOption">
/// A search option that specifies whether to recursively search for files to upload
/// in subdirectories.
/// </param>
public void UploadDirectory(string directory, string bucketName, string searchPattern, SearchOption searchOption)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest
{
BucketName = bucketName,
Directory = directory,
SearchPattern = searchPattern,
SearchOption = searchOption
};
UploadDirectory(request);
}
static void validate(TransferUtilityUploadDirectoryRequest request)
{
if (!request.IsSetDirectory())
{
throw new InvalidOperationException("Directory not specified");
}
if (!request.IsSetBucketName())
{
throw new InvalidOperationException("BucketName not specified");
}
if (!Directory.Exists(request.Directory))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The directory {0} does not exists!",
request.Directory));
}
}
/// <summary>
/// Initiates the asynchronous execution of the UploadDirectory operation.
/// <seealso cref="M:Amazon.S3.Transfer.TransferUtility.UploadDirectory"/>
/// </summary>
/// <param name="directory">
/// The source directory, that is, the directory containing the files to upload.
/// </param>
/// <param name="bucketName">
/// The target Amazon S3 bucket, that is, the name of the bucket to upload the files to.
/// </param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure.
/// Retrieve this object from within the callback procedure using the AsyncState property.
/// </param>
/// <exception cref="T:System.ArgumentNullException"></exception>
/// <exception cref="T:System.Net.WebException"></exception>
/// <exception cref="T:Amazon.S3.AmazonS3Exception"></exception>
/// <returns>An IAsyncResult that can be used to poll, or wait for results, or both.
/// This value is also needed when invoking EndUploadDirectory.</returns>
public IAsyncResult BeginUploadDirectory(string directory, string bucketName, AsyncCallback callback, object state)
{
TransferUtilityUploadDirectoryRequest request = new TransferUtilityUploadDirectoryRequest
{
BucketName = bucketName,
Directory = directory
};
return BeginUploadDirectory(request, callback, state);
}
