protected override void ProcessRecord()
{
AmazonS3 client = base.GetClient();
Amazon.S3.Model.PutBucketRequest request = new Amazon.S3.Model.PutBucketRequest();
request.BucketName = this._BucketName;
Amazon.S3.Model.PutBucketResponse response = client.PutBucket(request);
}
public static void PutBucketToS3(string _bucketname)
{
if (clients3 == null)
clients3 = new AmazonS3Client(Amazon.RegionEndpoint.USWest2);
try
{
PutBucketRequest request = new PutBucketRequest()
{
BucketName = _bucketname,
BucketRegion = S3Region.USW2,
CannedACL = S3CannedACL.PublicRead
};
PutBucketResponse response = clients3.PutBucket(request);
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId")
||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Check the provided AWS Credentials.");
Console.WriteLine(
"For service sign up go to http://aws.amazon.com/s3");
}
else
{
Console.WriteLine(
"Error occurred. Message:'{0}' when writing an object"
, amazonS3Exception.Message);
}
}
}
public async Task <PutBucketResponse> CreateBucketAsync(string name,
CancellationToken cancellationToken = default)
{
this.Logger.LogDebug($"[{nameof(this.CreateBucketAsync)}]");
this.Logger.LogTrace(JsonConvert.SerializeObject(new { name }));
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
var request = new Amazon.S3.Model.PutBucketRequest
{
BucketName = name,
};
this.Logger.LogTrace(JsonConvert.SerializeObject(value: request));
var response = await this.Repository.PutBucketAsync(request : request,
cancellationToken : cancellationToken == default?this.CancellationToken.Token : cancellationToken);
this.Logger.LogTrace(JsonConvert.SerializeObject(value: response));
return(response);
}
public async Task<IEnumerable<string>> Post()
{
var result = new List<string>();
var watch = new Stopwatch();
var bucketRequest = new PutBucketRequest
{
BucketName = TestBucketName,
BucketRegion = S3Region.EUC1
};
await _client.PutBucketAsync(bucketRequest);
for (int i = 1; i < 11; i++)
{
watch.Restart();
var request = new PutObjectRequest
{
BucketName = TestBucketName,
Key = $"test{i}.txt",
ContentBody = "Testcontent" + i
};
await _client.PutObjectAsync(request);
watch.Stop();
result.Add($"S3 {i} try: {watch.ElapsedMilliseconds}");
}
return result;
}
public static bool Create_Bucket(string bucket_name)
{
PutBucketRequest create_request = new PutBucketRequest();
create_request.BucketName = bucket_name;
PutBucketResponse response = s3_client.PutBucket(create_request);
return true;
}
public IBucket CreateBucket(string name)
{
var request = new PutBucketRequest()
.WithBucketName(name);
var responce = _awsClient.PutBucket(request);
return new AwsBucket() {Name = name};
}
/// <summary>
/// Create a bucket with the specified name.
/// </summary>
/// <param name="bucketName">The name of the bucket.</param>
public void CreateBucket(string bucketName)
{
var request = new PutBucketRequest
{
BucketName = bucketName
};
_amazonS3Client.PutBucket(request);
}
static void CreateABucket(IAmazonS3 client, string bucketName)
{
PutBucketRequest putRequest1 = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse response1 = client.PutBucket(putRequest1);
}
public void AddBucket(string bucketName)
{
PutBucketRequest request = new PutBucketRequest();
request.BucketName = bucketName;
if (!string.IsNullOrEmpty(m_locationConstraint))
request.BucketRegionName = m_locationConstraint;
m_client.PutBucket(request);
}
public virtual void CreateBucket(AmazonS3Client s3Client, string bucketName)
{
// Create the request
var putBucketRequest = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
// Create the bucket
s3Client.PutBucket(putBucketRequest);
}
public void CreateNewBucket(String bucketName)
{
try
{
PutBucketRequest request = new PutBucketRequest {BucketName = bucketName};
_client.PutBucket(request);
}
catch (Exception exception)
{
MessageBox.Show(string.Format("Could not create bucket:\n{0}", exception.Message));
}
}
/// <summary>
/// Creates a new container if it doesn't already exist.
/// </summary>
/// <param name="name">Name of the container to create.</param>
/// <returns>The newly created container, or the existing container if it already exists.</returns>
public IBlobContainer Create(string name)
{
BlobContainerUtilities.EnsureValidContainerName(name);
try {
var request = new PutBucketRequest() { BucketName = name };
_client.PutBucket(request);
return Get(name);
}
catch (AmazonS3Exception ex) {
throw WrapException(ex);
}
}
public static void CreateBucket(string name)
{
using (var client = new AmazonS3Client(Settings.AccessKey, Settings.Secret))
{
var request = new PutBucketRequest
{
BucketName = name,
BucketRegionName = Settings.Region
};
client.PutBucket(request);
}
}
static void Main(string[] args)
{
var client = CreateClient();
// create a bucket to contain an object
string bucketName = Guid.NewGuid().ToString("N");
var putBucketRequest = new PutBucketRequest()
{
BucketName = bucketName
};
client.PutBucket(putBucketRequest).Dispose();
Console.WriteLine("Created a bucket named {0}.", putBucketRequest.BucketName);
// create an object in the bucket
var putObjectRequest = new PutObjectRequest()
{
BucketName = bucketName,
Key = "MyObject.txt",
ContentBody = "Hello World!"
};
client.PutObject(putObjectRequest).Dispose();
Console.WriteLine("Created an object named {0}.", putObjectRequest.Key);
// update the object in the bucket
var updateObjectRequest = new UpdateObjectRequest()
{
BucketName = bucketName,
Key = "MyObject.txt",
ContentBody = "Again",
};
updateObjectRequest.UpdateRange = new Amazon.S3.Model.Tuple<long, long?>(6, null);
client.UpdateObject(updateObjectRequest);
Console.WriteLine("Updated the object's content.");
// get the object content
var getObjectRequest = new GetObjectRequest()
{
BucketName = bucketName,
Key = "MyObject.txt"
};
using (var getObjectResponse = client.GetObject(getObjectRequest))
{
string contentBody = getObjectResponse.GetResponseContentBody();
Console.WriteLine("The object content is: {0}.", contentBody);
}
// delete the bucket
client.DeleteBucketRecursive(bucketName);
Console.WriteLine("Deleted the bucket.");
}
public static void CheckForBucket(string itemKey, AmazonS3 s3Client)
{
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
string userBucketName = String.Format(Settings.Default.BucketNameFormat, HttpContext.Current.User.Identity.Name, itemKey);
using (ListBucketsResponse listBucketsResponse = s3Client.ListBuckets())
{
S3Bucket bucket = listBucketsResponse.Buckets.FirstOrDefault(b => b.BucketName == userBucketName);
if (bucket == null)
{
PutBucketRequest putBucketRequest = new PutBucketRequest()
.WithBucketName(userBucketName);
PutBucketResponse putBucketResponse = s3Client.PutBucket(putBucketRequest);
putBucketResponse.Dispose();
}
}
}
}
/// <summary>Create the configured bucket</summary>
public void CreateBucket()
{
Project.Log(Level.Info, "Creating S3 bucket: {0}", BucketName);
using (Client)
{
try
{
var request = new PutBucketRequest
{
BucketName = BucketName,
BucketRegion = _region
};
Client.PutBucket(request);
}
catch (AmazonS3Exception ex)
{
ShowError(ex);
}
}
}
public bool CreateBucket(string userID)
{
bool retval = false;
using (client = Amazon.AWSClientFactory.CreateAmazonS3Client(RegionEndpoint.APSoutheast1))
{
try
{
//create bucket
PutBucketRequest request = new PutBucketRequest();
request.BucketName = userID;
request.BucketRegion = S3Region.APS1;
request.CannedACL = S3CannedACL.PublicRead;
PutBucketResponse res;
res = client.PutBucket(request);
retval = true;
}
catch (AmazonS3Exception amazonS3Exception)
{
throw amazonS3Exception;
}
}
return retval;
}
/// <summary>
/// Add Bucket
/// </summary>
/// <param name="client">Client</param>
/// <param name="bucket">Bucket</param>
public void AddBucket(AmazonS3 client, string bucket)
{
if (string.IsNullOrWhiteSpace(this.from))
{
this.from = bucket;
this.fromClient = client;
}
else
{
this.to = bucket;
this.toClient = client;
var request = new PutBucketRequest()
{
BucketName = bucket,
};
using (var response = client.PutBucket(request))
{
}
}
}
internal PutBucketResponse PutBucket(PutBucketRequest request)
{
var marshaller = new PutBucketRequestMarshaller();
var unmarshaller = PutBucketResponseUnmarshaller.Instance;
return Invoke<PutBucketRequest,PutBucketResponse>(request, marshaller, unmarshaller);
}
IAsyncResult invokePutBucket(PutBucketRequest putBucketRequest, AsyncCallback callback, object state, bool synchronized)
{
var marshaller = new PutBucketRequestMarshaller();
var unmarshaller = PutBucketResponseUnmarshaller.GetInstance();
var result = Invoke(putBucketRequest, callback, state, synchronized, marshaller, unmarshaller, this.signer);
return result;
}
/// <summary>
/// Initiates the asynchronous execution of the PutBucket operation.
/// <seealso cref="Amazon.S3.IAmazonS3.PutBucket"/>
/// </summary>
///
/// <param name="putBucketRequest">Container for the necessary parameters to execute the PutBucket operation on AmazonS3.</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>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutBucket
/// operation.</returns>
public IAsyncResult BeginPutBucket(PutBucketRequest putBucketRequest, AsyncCallback callback, object state)
{
return invokePutBucket(putBucketRequest, callback, state, false);
}
/// <summary>
/// Initiates the asynchronous execution of the PutBucket operation.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value for this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutBucket operation on AmazonS3Client.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">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>
public void PutBucketAsync(PutBucketRequest request, AmazonServiceCallback<PutBucketRequest, PutBucketResponse> callback, AsyncOptions options = null)
{
if (AWSConfigs.HttpClient == AWSConfigs.HttpClientOption.UnityWWW)
{
throw new InvalidOperationException("PutBucket is only allowed with AWSConfigs.HttpClientOption.UnityWebRequest API option");
}
options = options == null?new AsyncOptions():options;
var marshaller = new PutBucketRequestMarshaller();
var unmarshaller = PutBucketResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<PutBucketRequest,PutBucketResponse> responseObject
= new AmazonServiceResult<PutBucketRequest,PutBucketResponse>((PutBucketRequest)req, (PutBucketResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<PutBucketRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Initiates the asynchronous execution of the PutBucket operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutBucket operation on AmazonS3Client.</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>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutBucket
/// operation.</returns>
public IAsyncResult BeginPutBucket(PutBucketRequest request, AsyncCallback callback, object state)
{
var marshaller = new PutBucketRequestMarshaller();
var unmarshaller = PutBucketResponseUnmarshaller.Instance;
return BeginInvoke<PutBucketRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Creates a new bucket.
/// </summary>
/// <param name="bucketName">A property of PutBucketRequest used to execute the PutBucket service method.</param>
///
/// <returns>The response from the PutBucket service method, as returned by S3.</returns>
public PutBucketResponse PutBucket(string bucketName)
{
var request = new PutBucketRequest();
request.BucketName = bucketName;
return PutBucket(request);
}
/// <summary>
/// Creates a new bucket.
/// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW
/// </summary>
/// <param name="bucketName">A property of PutBucketRequest used to execute the PutBucket service method.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// 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>
///
/// <returns>The response from the PutBucket service method, as returned by S3.</returns>
public void PutBucketAsync(string bucketName, AmazonServiceCallback<PutBucketRequest, PutBucketResponse> callback, AsyncOptions options = null)
{
var request = new PutBucketRequest();
request.BucketName = bucketName;
PutBucketAsync(request, callback, options);
}
private Amazon.S3.Model.PutBucketResponse CallAWSServiceOperation(IAmazonS3 client, Amazon.S3.Model.PutBucketRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon S3", "PutBucket");
try
{
#if DESKTOP
return(client.PutBucket(request));
#elif CORECLR
return(client.PutBucketAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
public override void CreateBin(string bin)
{
PutBucketRequest pbr = new PutBucketRequest();
pbr.BucketName = bin;
PutBucketResponse response = client.PutBucket(pbr);
}
/// <summary>
/// Creates a new bucket.
/// </summary>
/// <param name="bucketName">A property of PutBucketRequest used to execute the PutBucket service method.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the PutBucket service method, as returned by S3.</returns>
public Task<PutBucketResponse> PutBucketAsync(string bucketName, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new PutBucketRequest();
request.BucketName = bucketName;
return PutBucketAsync(request, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the PutBucket operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutBucket operation.</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<PutBucketResponse> PutBucketAsync(PutBucketRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutBucketRequestMarshaller();
var unmarshaller = PutBucketResponseUnmarshaller.Instance;
return InvokeAsync<PutBucketRequest,PutBucketResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// <para>Creates a new bucket.</para>
/// </summary>
///
/// <param name="putBucketRequest">Container for the necessary parameters to execute the PutBucket service method on AmazonS3.</param>
///
/// <returns>The response from the PutBucket service method, as returned by AmazonS3.</returns>
///
public PutBucketResponse PutBucket(PutBucketRequest putBucketRequest)
{
IAsyncResult asyncResult = invokePutBucket(putBucketRequest, null, null, true);
return EndPutBucket(asyncResult);
}
static void CreateABucket()
{
try
{
PutBucketRequest request = new PutBucketRequest();
request.BucketName = bucketName;
client.PutBucket(request);
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null && (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") || amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Please check the provided AWS Credentials.");
Console.WriteLine("If you haven't signed up for Amazon S3, please visit http://aws.amazon.com/s3");
}
else
{
Console.WriteLine("An Error, number {0}, occurred when creating a bucket with the message '{1}", amazonS3Exception.ErrorCode, amazonS3Exception.Message);
}
}
}
public ActionResult Register(AccountInputModel model)
{
var account = Mapper.Map<AccountInputModel, Account>(model);
account.BucketName = string.Format("mdp.{0}", Guid.NewGuid());
account = _writeOnlyRepository.Create(account);
//Create a bucket for the new user on AWS S3
var client = AWSClientFactory.CreateAmazonS3Client();
var newBucket = new PutBucketRequest {BucketName = account.BucketName};
client.PutBucket(newBucket);
Success("El usuario "+account.Email + " se ha registrado.");
return RedirectToAction("LogIn");
}
