static void Main(string[] args)
{
var basePath = Path.Combine(Directory.GetCurrentDirectory(), "Realms");
Directory.CreateDirectory(basePath);
FullSyncConfiguration.Initialize(UserPersistenceMode.Disabled, basePath: basePath);
var credentials = new BasicAWSCredentials("access", "secret");
FileManager.Initialize(new FileManagerOptions
{
PersistenceLocation = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
RemoteManagerFactory = () => new S3FileManager(credentials, RegionEndpoint.EUNorth1)
});
AsyncContext.Run(MainAsync);
}
public static IAsyncOperation <string> GetFaceDetails(string base64, string AccessKey, string SecretKey)
{
return(Task.Run <string>(async() =>
{
byte[] imageBytes;
try
{
base64 = base64.Substring(base64.IndexOf(',') + 1).Trim('\0');
imageBytes = System.Convert.FromBase64String(base64);
}
catch (Exception e) {
return e.Message;
}
string sJSONResponse = "";
AWSCredentials credentials;
try
{
credentials = new BasicAWSCredentials(AccessKey, SecretKey);
}
catch (Exception e)
{
throw new AmazonClientException("Cannot load the credentials from the credential profiles file. "
+ "Please make sure that your credentials file is at the correct "
+ "location (/Users/<userid>/.aws/credentials), and is in a valid format.", e);
}
DetectFacesRequest request = new DetectFacesRequest {
Attributes = new List <string>(new string[] { "ALL" })
};
DetectFacesResponse result = null;
request.Image = new Image {
Bytes = new MemoryStream(imageBytes, 0, imageBytes.Length)
};
AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(credentials, RegionEndpoint.USWest2);
try
{
result = await rekognitionClient.DetectFacesAsync(request);
}
catch (AmazonRekognitionException e)
{
throw e;
}
// Return server status as unhealthy with appropriate status code
sJSONResponse = JsonConvert.SerializeObject(result.FaceDetails);
return sJSONResponse;
}).AsAsyncOperation());
}
private string UploadImageToS3(Stream memoryStream, string filePrefix = "img")
{
string bucketName = _appSettingService.GetAppSettingData("gallery_s3_bucket_name");
string keyName = $"{filePrefix}_{CommonUtility.GetNewID()}.png";
RegionEndpoint bucketRegion = RegionEndpoint.APSouth1;
string _accessKey = _appSettingService.GetAppSettingData("aws_s3_access_key");
string _secretKey = _appSettingService.GetAppSettingData("aws_s3_secret_key");
IAmazonS3 s3Client;
_logger.Debug($"{bucketName}:::{_accessKey}:::{_secretKey}");
try
{
var credentials = new BasicAWSCredentials(_accessKey, _secretKey);
s3Client = new AmazonS3Client(credentials, bucketRegion);
S3CannedACL permissions = S3CannedACL.NoACL;
var putObject = new PutObjectRequest
{
BucketName = bucketName,
Key = keyName,
InputStream = memoryStream,
ContentType = "image/png",
CannedACL = permissions
};
//setting content length for streamed input
putObject.Metadata.Add("Content-Length", memoryStream.Length.ToString());
var putResponse = s3Client.PutObjectAsync(putObject).GetAwaiter().GetResult();
if (putResponse.HttpStatusCode == HttpStatusCode.OK)
{
return($"/{keyName}");
}
else
{
throw new Exception($"Error while upload image to s3 HttpStatusCode: {putResponse.HttpStatusCode }");
}
}
catch (AmazonS3Exception e)
{
_logger.Error($"AmazonS3Exception : {e.Message}", e);
throw;
}
}
private static async Task Get()
{
var creds = new BasicAWSCredentials(AccessKey, SecretKey);
var client = new AmazonDynamoDBClient(creds, Region);
var table = Table.LoadTable(client, "Image");
var config = new GetItemOperationConfig
{
AttributesToGet = new List <string> {
"Hash", "testing"
},
ConsistentRead = true
};
var image = await table.GetItemAsync("2a8d7291-78fe-44f6-9f4d-33178bad00d0", config);
}
public AwsBlobs(IConfiguration configuration)
{
Ensure.Argument.IsNotNull(configuration, nameof(configuration));
// Create the credentials for our AWS account.
var awsCredentials = new BasicAWSCredentials(
configuration.AwsAccessKey,
configuration.AwsAccessSecret);
// Create the underlying S3 client.
var region = RegionEndpoint.GetBySystemName(configuration.AwsBlobsRegion);
var client = new AmazonS3Client(awsCredentials, region);
// Create our blob containers.
this.PostVersions = new AwsBlobContainer(client, "postversions", string.Empty);
this.Attachments = new AwsBlobContainer(client, "attachments", string.Empty);
}
public DogService(IConfiguration cfg, KrustanDbContext ctx)
{
this._context = ctx;
Configuration = cfg;
var credentials = new BasicAWSCredentials(Configuration["s3:AccessKey"].Trim(), Configuration["s3:SecretAccessKey"].Trim());
client = new AmazonS3Client(credentials, Amazon.RegionEndpoint.USEast1);
if (dogs.Count == 0)
{
dogs.Add(new Dog
{
Name = "Cosmo",
Weight = 1.2f,
Height = 3.2f,
Description = "Jugueton, amigable",
Age = 2,
DogPicture = @"https://images.dog.ceo/breeds/deerhound-scottish/n02092002_1339.jpg",
Sex = "male",
OwnerId = "123456789"
});
dogs.Add(new Dog
{
Name = "Locria",
Weight = 4,
Height = 6,
Description = "fuerte, amigable",
Age = 3,
DogPicture = @"https://images.dog.ceo/breeds/appenzeller/n02107908_3190.jpg",
Sex = "male",
OwnerId = "123456789"
});
dogs.Add(new Dog
{
Name = "Karma",
Weight = 4.1f,
Height = 12.5f,
Description = "juguetona, amigable, fuerte, coqueta...",
Age = 4,
DogPicture = @"https://images.dog.ceo/breeds/samoyed/n02111889_5463.jpg",
Sex = "female",
OwnerId = "123456789"
});
}
}
public static void Initialize(TestContext testContext)
{
BasicAWSCredentials creds = new BasicAWSCredentials(ConfigurationManager.AppSettings["S3_ACCESS_KEY_ID"], ConfigurationManager.AppSettings["S3_SECRET_KEY"]);
AmazonS3Config cc = new AmazonS3Config()
{
ForcePathStyle = true,
ServiceURL = ConfigurationManager.AppSettings["S3_ENDPOINT"],
SignatureVersion = ConfigurationManager.AppSettings["SIGNATURE_VERSION"],
SignatureMethod = SigningAlgorithm.HmacSHA1,
UseHttp = false,
};
client = new ECSS3Client(creds, cc);
PutBucketRequestECS request = new PutBucketRequestECS()
{
BucketName = temp_bucket,
};
// Set the indexable search keys on the bucket.
request.SetMetadataSearchKeys(bucketMetadataSearchKeys);
string vpool_id = ConfigurationManager.AppSettings["VPOOL_ID"];
if (!string.IsNullOrWhiteSpace(vpool_id))
{
request.VirtualPoolId = vpool_id;
}
client.PutBucket(request);
for (int i = 0; i < 5; i++)
{
PutObjectRequest object_request = new PutObjectRequest()
{
BucketName = temp_bucket,
Key = string.Format("obj-{0}", i),
ContentBody = string.Format("This is sample content for object {0}", i)
};
object_request.Metadata.Add("x-amz-meta-decimalvalue", Convert.ToString(i * 2));
object_request.Metadata.Add("x-amz-meta-stringvalue", string.Format("sample-{0}", Convert.ToString(i)));
client.PutObject(object_request);
}
}
private void CreateTable()
{
var credentials = new BasicAWSCredentials(accessKey, secretKey);
client = new AmazonDynamoDBClient(credentials, RegionEndpoint.USWest1);
var tableResponse = client.ListTables();
if (!tableResponse.TableNames.Contains(tableName))
{
MessageBox.Show("Table not found, creating table => " + tableName);
client.CreateTable(new CreateTableRequest
{
TableName = tableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 3,
WriteCapacityUnits = 1
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = hashKey,
KeyType = KeyType.HASH
}
},
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition {
AttributeName = hashKey, AttributeType = ScalarAttributeType.S
}
}
});
bool isTableAvailable = false;
while (!isTableAvailable)
{
Console.WriteLine("Waiting for table to be active...");
Thread.Sleep(5000);
var tableStatus = client.DescribeTable(tableName);
isTableAvailable = tableStatus.Table.TableStatus == "ACTIVE";
}
MessageBox.Show("DynamoDB Table Created Successfully!");
}
}
public static String SendSMS(String recipientPhoneNumber, String message)
{
BasicAWSCredentials awsCredentials =
new BasicAWSCredentials("", "");
AmazonSimpleNotificationServiceClient snsClient =
new AmazonSimpleNotificationServiceClient(awsCredentials, Amazon.RegionEndpoint.USEast1);
PublishRequest pubRequest = new PublishRequest();
pubRequest.PhoneNumber = recipientPhoneNumber;
pubRequest.Message = message;
PublishResponse pubResponse = snsClient.Publish(pubRequest);
return(pubResponse.MessageId);
}
private void RunPreInvoke(AmazonWebServiceRequest request)
{
var credentials = new BasicAWSCredentials(accessKey, secretKey);
var handler = new PreSignedUrlRequestHandler(credentials);
var requestContext = new RequestContext(false, new NullSigner());
var responseContext = new ResponseContext();
var executionContext = new ExecutionContext(requestContext, responseContext);
var marshaller = new CopyDBClusterSnapshotRequestMarshaller();
var clientConfig = new AmazonDocDBConfig();
clientConfig.RegionEndpoint = clientRegion;
requestContext.OriginalRequest = request;
requestContext.Marshaller = marshaller;
requestContext.ClientConfig = clientConfig;
ReflectionHelpers.Invoke(handler, "PreInvoke", executionContext);
}
public DynamoDbTestHelper()
{
var credentials = new BasicAWSCredentials("FakeAccessKey", "FakeSecretKey");
var clientConfig = new AmazonDynamoDBConfig
{
ServiceURL = "http://localhost:8000"
};
Client = new AmazonDynamoDBClient(credentials, clientConfig);
var tableName = $"test_{Guid.NewGuid()}";
DynamoDbContext = new DynamoDBContext(Client);
DynamoDbCommandStoreTestConfiguration = new DynamoDbCommandStoreConfiguration($"command_{tableName}", true, "CommandId", "ContextKey");
DynamoDbMessageStoreTestConfiguration = new DynamoDbMessageStoreConfiguration($"message_{tableName}", true, "MessageId");
}
private static async Task Run()
{
var credentials = new BasicAWSCredentials("accessKey", "secretKey");
using (var snsClient = new AmazonSimpleNotificationServiceClient(credentials))
{
var publisher = new Publisher(snsClient, "topicName");
while (true)
{
Console.WriteLine("Type a message to send:");
var message = Console.ReadLine();
await publisher.PublishAsync(message);
}
}
}
public ExternalProviderS3(GXService providerService)
{
string keyId = CryptoImpl.Decrypt(providerService.Properties.Get(ACCESS_KEY_ID));
string keySecret = CryptoImpl.Decrypt(providerService.Properties.Get(SECRET_ACCESS_KEY));
AWSCredentials credentials = null;
if (!string.IsNullOrEmpty(keyId) && !string.IsNullOrEmpty(keySecret))
{
credentials = new BasicAWSCredentials(keyId, keySecret);
}
var region = Amazon.RegionEndpoint.GetBySystemName(providerService.Properties.Get(REGION));
Endpoint = providerService.Properties.Get(ENDPOINT);
AmazonS3Config config = new AmazonS3Config()
{
ServiceURL = Endpoint,
RegionEndpoint = region
};
#if NETCORE
if (credentials != null)
{
Client = new AmazonS3ClientExtended(credentials, config);
}
else
{
Client = new AmazonS3ClientExtended(config);
}
#else
if (credentials != null)
{
Client = new AmazonS3Client(credentials, config);
}
else
{
Client = new AmazonS3Client(config);
}
#endif
Bucket = CryptoImpl.Decrypt(providerService.Properties.Get(BUCKET));
Folder = providerService.Properties.Get(FOLDER);
CreateBucket();
CreateFolder(Folder);
}
public static async Task AWSUploadAudioVideo(string filePath, string requiredFileName, string mediatype)
{
try
{
// CommonConstants.
AWSCredentials creds = new BasicAWSCredentials(CommonHelper.GetAWS_ACCESS_KEY(),
CommonHelper.GetAWS_SECRET_KEY());
// TransferUtilityConfig config = new TransferUtilityConfig () { ConcurrentServiceRequests = 5 };
var client = new AmazonS3Client(creds, RegionEndpoint.USWest2);
// TransferUtility trans = new TransferUtility (client, config);
var po = new PutObjectRequest();
po.CannedACL = S3CannedACL.PublicReadWrite;
po.FilePath = filePath;
if (mediatype == "Audio")
{
po.BucketName = "chatcloud-audio";
}
if (mediatype == "Video")
{
po.BucketName = "inpower-video";
}
po.Key = requiredFileName;
await client.PutObjectAsync(po);
// var go = new GetObjectRequest ();
// go.BucketName = "bitmob-videos";
// go.Key = "abcdefhij.jpg";
// var res = await client.GetObjectAsync (go);
Console.WriteLine("Upload completed");
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId")
||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
throw new Exception("Check the provided AWS Credentials.");
}
else
{
throw new Exception("Error occurred: " + amazonS3Exception.Message);
}
}
}
/// <summary>
/// Get the key that we want to use in the encryption from KMS
/// </summary>
/// <param name="alias">The "key name"</param>
/// <returns>The key id</returns>
private static string GetKeyByAlias(string alias)
{
try
{
var credentials =
new BasicAWSCredentials("acessKey", "secretKey");
var kmsClient = new AwsKeyManagementServiceClient(Region, credentials);
var key = kmsClient.GetKeyAsync(alias);
return(key.Result);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// Activates logging to AWS CloudWatch
/// </summary>
/// <remarks>This overload is intended to be used via AppSettings integration.</remarks>
/// <param name="loggerConfiguration">The LoggerSinkConfiguration to register this sink with.</param>
/// <param name="logGroupName">The log group name to be used in AWS CloudWatch.</param>
/// <param name="logStreamNameProvider">The log stream name provider.</param>
/// <param name="accessKey">The access key to use to access AWS CloudWatch.</param>
/// <param name="secretAccessKey">The secret access key to use to access AWS CloudWatch.</param>
/// <param name="regionName">The system name of the region to which to write.</param>
/// <param name="logEventRenderer">A renderer to render Serilog's LogEvent.</param>
/// <param name="minimumLogEventLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="batchSizeLimit">The batch size to be used when uploading logs to AWS CloudWatch.</param>
/// <param name="period">The period to be used when a batch upload should be triggered.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"><paramref name="logGroupName"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="accessKey"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="secretAccessKey"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="logStreamNameProvider"/> is <see langword="null"/>.</exception>
public static LoggerConfiguration AmazonCloudWatch(
this LoggerSinkConfiguration loggerConfiguration,
string logGroupName,
ILogStreamNameProvider logStreamNameProvider,
string accessKey,
string secretAccessKey,
string regionName = null,
ILogEventRenderer logEventRenderer = null,
LogEventLevel minimumLogEventLevel = CloudWatchSinkOptions.DefaultMinimumLogEventLevel,
int batchSizeLimit = CloudWatchSinkOptions.DefaultBatchSizeLimit,
TimeSpan?period = null,
bool createLogGroup = CloudWatchSinkOptions.DefaultCreateLogGroup)
{
if (logGroupName == null)
{
throw new ArgumentNullException(nameof(logGroupName));
}
if (logStreamNameProvider == null)
{
throw new ArgumentNullException(nameof(logStreamNameProvider));
}
if (accessKey == null)
{
throw new ArgumentNullException(nameof(accessKey));
}
if (secretAccessKey == null)
{
throw new ArgumentNullException(nameof(secretAccessKey));
}
var options = new CloudWatchSinkOptions
{
LogGroupName = logGroupName,
MinimumLogEventLevel = minimumLogEventLevel,
BatchSizeLimit = batchSizeLimit,
Period = period ?? CloudWatchSinkOptions.DefaultPeriod,
LogStreamNameProvider = logStreamNameProvider,
LogEventRenderer = logEventRenderer,
CreateLogGroup = createLogGroup
};
var credentials = new BasicAWSCredentials(accessKey, secretAccessKey);
var client = CreateClient(credentials, regionName);
return(loggerConfiguration.AmazonCloudWatch(options, client));
}
/// <summary>
/// The method opens the queue
/// </summary>
public bool OpenQueue(string queuename, int maxnumberofmessages, String AWSAccessKey, String AWSSecretKey)
{
ClearErrorInfo();
IsValid = false;
if (!string.IsNullOrWhiteSpace(queuename))
{
// Checking for the need to use provided credentials instead of reading from app.Config
if (!String.IsNullOrWhiteSpace(AWSSecretKey) && !String.IsNullOrWhiteSpace(AWSSecretKey))
{
AWSCredentials awsCredentials = new BasicAWSCredentials(AWSAccessKey, AWSSecretKey);
queue = AWSClientFactory.CreateAmazonSQSClient(awsCredentials, RegionEndpoint.USEast1);
}
else
{
queue = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.USEast1);
}
try
{
// Get queue url
GetQueueUrlRequest sqsRequest = new GetQueueUrlRequest();
sqsRequest.QueueName = queuename;
queueurl = queue.GetQueueUrl(sqsRequest);
// Format receive messages request
rcvMessageRequest = new ReceiveMessageRequest();
rcvMessageRequest.QueueUrl = queueurl.QueueUrl;
rcvMessageRequest.MaxNumberOfMessages = maxnumberofmessages;
// Format the delete messages request
delMessageRequest = new DeleteMessageRequest();
delMessageRequest.QueueUrl = queueurl.QueueUrl;
IsValid = true;
}
catch (Exception ex)
{
ErrorCode = e_Exception;
ErrorMessage = ex.Message;
}
}
return(IsValid);
}
/// <summary>
/// Uploads a file to S3.
/// </summary>
/// <param name="file">The full filename and path of the file to upload.</param>
/// <param name="targetName">The file name that should be used for the upload</param>
public void Upload(string file, String targetName)
{
IFormatProvider formatProvider = TinyIoCContainer.Current.Resolve <IFormatProvider>();
try
{
var credentials = new BasicAWSCredentials(_appSettings.Get(AppSettingKeys.AwsAccessKey), _appSettings.Get(AppSettingKeys.AwsSecretKey));
var region = RegionEndpoint.GetBySystemName(_appSettings.Get(AppSettingKeys.AwsRegion));
using (var client = new AmazonS3Client(credentials, region))
{
var request = new PutObjectRequest
{
BucketName = _appSettings.Get(AppSettingKeys.S3Bucket),
Key = String.Join("/", new[] { _appSettings.Get(AppSettingKeys.S3Folder), targetName }),
FilePath = file
};
Console.Write(string.Format(formatProvider, Properties.Resources.StatusUploadingS3, targetName));
client.PutObject(request);
Console.WriteLine("\u221A");
}
}
catch (AmazonS3Exception e)
{
if (e.ErrorCode != null && ("InvalidAccessKeyId" == e.ErrorCode || "InvalidSecurity" == e.ErrorCode))
{
_errorHandler.HandleError(e, (int)Enums.ExitCode.AwsCredentials, Properties.Resources.ConfigurationS3Credentials);
}
else
{
_errorHandler.HandleError(e, (int)Enums.ExitCode.AwsS3Error, string.Format(formatProvider, Properties.Resources.StatusS3UploadFailed, e.Message));
}
}
finally
{
try
{
if (File.Exists(file))
{
File.Delete(file);
}
} catch (Exception ex)
{
_errorHandler.HandleError(ex, (int)Enums.ExitCode.AwsS3Error, string.Format(formatProvider, Properties.Resources.StatusUnknownError, ex.Message));
}
}
}
public AmazonSqsService(IOptions <SuperDumpSettings> settings, SuperDumpRepository superDumpRepo, LinkGenerator linkGenerator, ILoggerFactory loggerFactory)
{
this.amazonSqsSettings = settings.Value.AmazonSqsSettings;
this.superDumpRepo = superDumpRepo;
this.linkGenerator = linkGenerator;
this.logger = loggerFactory.CreateLogger <AmazonSqsService>();
var credentials = new BasicAWSCredentials(amazonSqsSettings.AccessKey, amazonSqsSettings.SecretKey);
var config = new AmazonSQSConfig {
RegionEndpoint = RegionEndpoint.GetBySystemName(amazonSqsSettings.Region)
};
this.sqsClient = new AmazonSQSClient(credentials, config);
this.baseUri = new Uri(amazonSqsSettings.SuperDumpBaseUrl);
}
public PersistentService()
{
_settings = Settings.Default;
var credentials = new BasicAWSCredentials(_settings.AWSAccessKey, _settings.AWSSecretKey);
var region = RegionEndpoint.GetBySystemName(_settings.AWSRegion);
_s3Client = new AmazonS3Client(credentials, region);
_config = new TransferUtilityConfig
{
// Use 5 concurrent requests.
ConcurrentServiceRequests = 5,
// Use multipart upload for file size greater 20 MB.
MinSizeBeforePartUpload = 20 * MB_SIZE,
};
}
public AwsSesSender(
IOptions <AwsSesMailingSettings> settingsOptions,
ILogger <AwsSesSender> logger)
{
_logger = logger.GuardIsNotNull(nameof(logger));
var settings = settingsOptions?.Value.GuardIsNotNull(nameof(settingsOptions));
var credentials = new BasicAWSCredentials(
settings.AccessKeyId,
settings.AccessKeySecret);
var regionEndpoint = settings.RegionEndpoint.IsNullOrWhiteSpace()
? RegionEndpoint.USEast1
: RegionEndpoint.GetBySystemName(settings.RegionEndpoint);
_client = new AmazonSimpleEmailServiceClient(credentials, regionEndpoint);
}
public AWSDynamoDBStream(BasicAWSCredentials basicAWSCredentials, RegionEndpoint regionEndpoint, string tableName, AWSDynamoDBIteratorType type)
{
this.TableName = tableName;
this.AmazonDynamoDBStreamsClient = new AmazonDynamoDBStreamsClient(basicAWSCredentials, regionEndpoint);
this.AWSDynamoDBIteratorType = type;
var listStreams = AmazonDynamoDBStreamsClient.ListStreams(new ListStreamsRequest()
{
TableName = this.TableName
});
this.StreamArn = listStreams.Streams.First().StreamArn;
DescribeStreamRequest describeStreamRequest = new DescribeStreamRequest()
{
StreamArn = this.StreamArn
};
var describeStreamResponse = this.AmazonDynamoDBStreamsClient.DescribeStream(describeStreamRequest);
var shards = describeStreamResponse.StreamDescription.Shards;
GetShardIteratorRequest getShardIteratorRequest = null;
if (this.AWSDynamoDBIteratorType == AWSDynamoDBIteratorType.TRIM_HORIZON)
{
getShardIteratorRequest = new GetShardIteratorRequest()
{
StreamArn = this.StreamArn,
ShardIteratorType = ShardIteratorType.TRIM_HORIZON,
ShardId = shards.First().ShardId,
};
}
if (this.AWSDynamoDBIteratorType == AWSDynamoDBIteratorType.LATEST)
{
getShardIteratorRequest = new GetShardIteratorRequest()
{
StreamArn = this.StreamArn,
ShardIteratorType = ShardIteratorType.LATEST,
ShardId = shards.Last().ShardId,
//SequenceNumber = shards.First().SequenceNumberRange.StartingSequenceNumber
};
}
var shardIteratorResponse = this.AmazonDynamoDBStreamsClient.GetShardIterator(getShardIteratorRequest);
this.LatestShardID = shardIteratorResponse.ShardIterator;
}
private void CreateClient()
{
if (service.StartsWith("http://", StringComparison.InvariantCultureIgnoreCase) ||
service.StartsWith("https://", StringComparison.InvariantCultureIgnoreCase))
{
ddbClient = new AmazonDynamoDBClient(new AmazonDynamoDBConfig {
ServiceURL = service
});
}
else
{
var credentials = new BasicAWSCredentials(accessKey, secretKey);
ddbClient = new AmazonDynamoDBClient(credentials, new AmazonDynamoDBConfig {
ServiceURL = service, RegionEndpoint = AWSUtils.GetRegionEndpoint(service)
});
}
}
private static AmazonS3Client CreateClient(AmazonS3Config config = null)
{
if (config == null)
{
config = new AmazonS3Config();
}
// load the ViPR S3 endpoint information and credentials from app.config
Uri endpoint = new Uri(ConfigurationManager.AppSettings["AWSServiceURI"]);
AWSCredentials creds = new BasicAWSCredentials(
ConfigurationManager.AppSettings["AWSAccessKey"],
ConfigurationManager.AppSettings["AWSSecretKey"]);
// establish the configuration, for either a host-based endpoint or an IP-based endpoint
if (endpoint.HostNameType == UriHostNameType.IPv4 || endpoint.HostNameType == UriHostNameType.IPv6)
{
// By default, the AWS .NET SDK does not support
// path-style buckets and nonstandard ports in the service
// URL. Therefore, we need to configure the ViPR endpoint
// as a proxy instead of the ServiceURL since most test
// configurations will use IP addresses and the internal
// 9020/9021 ports.
config.ProxyHost = endpoint.Host;
config.ProxyPort = endpoint.Port;
if (endpoint.Scheme == "https")
{
throw new ArgumentException("ViPR S3 via HTTPS is not supported through .NET with the AWS SDK: " + endpoint);
}
else
{
config.CommunicationProtocol = Protocol.HTTP;
}
}
else
{
config.CommunicationProtocol =
string.Equals("http", endpoint.Scheme, StringComparison.InvariantCultureIgnoreCase) ?
Protocol.HTTP : Protocol.HTTPS;
config.ServiceURL = endpoint.GetComponents(UriComponents.HostAndPort, UriFormat.UriEscaped);
}
var client = new AmazonS3Client(creds, config);
return(client);
}
public async Task <IActionResult> Upload(PolicyRequest policy, string policyRef)
{
try
{
string guid = Guid.NewGuid().ToString();
var credentials = new BasicAWSCredentials(accessKey, secretKey);
var config = new AmazonS3Config
{
RegionEndpoint = Amazon.RegionEndpoint.EUWest2
};
using var client = new AmazonS3Client(credentials, config);
await using var memoryStream = new MemoryStream(Convert.FromBase64String(policy.PolicyPDF));
var uploadRequest = new TransferUtilityUploadRequest
{
InputStream = memoryStream,
Key = guid,
BucketName = "karl",
CannedACL = S3CannedACL.PublicRead,
ContentType = "application/pdf"
};
// https://docs.aws.amazon.com/sdkfornet1/latest/apidocs/html/M_Amazon_S3_AmazonS3Client_GetPreSignedURL.htm //
GetPreSignedUrlRequest request = new GetPreSignedUrlRequest
{
BucketName = "karl",
Key = guid,
Expires = DateTime.Now.AddMinutes(5)
};
string path = client.GetPreSignedURL(request);
// --------------------------------------------------------------------------------------------------------- //
var fileTransferUtility = new TransferUtility(client);
await fileTransferUtility.UploadAsync(uploadRequest);
}
catch (Exception ex)
{
Console.WriteLine("An error occurred: " + ex.Message);
}
return(Ok());
}
public async Task <bool> SendDistributionListEmail(MimeMessage message)
{
var stream = new MemoryStream();
message.WriteTo(stream);
var request = new SendRawEmailRequest()
{
RawMessage = new RawMessage()
{
Data = stream
}
};
// Choose the AWS region of the Amazon SES endpoint you want to connect to. Note that your sandbox
// status, sending limits, and Amazon SES identity-related settings are specific to a given
// AWS region, so be sure to select an AWS region in which you set up Amazon SES. Here, we are using
// the US West (Oregon) region. Examples of other regions that Amazon SES supports are USEast1
// and EUWest1. For a complete list, see http://docs.aws.amazon.com/ses/latest/DeveloperGuide/regions.html
Amazon.RegionEndpoint REGION = Amazon.RegionEndpoint.USWest2;
var credentials = new BasicAWSCredentials(Config.OutboundEmailServerConfig.AwsAccessKey, Config.OutboundEmailServerConfig.AwsSecretKey);
// Instantiate an Amazon SES client, which will make the service call.
AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(credentials, REGION);
// Send the email.
try
{
//TODO: Might not be right -SJ
var result = await client.SendRawEmailAsync(request);
if (!String.IsNullOrWhiteSpace(result.MessageId))
{
return(true);
}
return(false);
}
catch (Exception ex)
{
var exc = ex.ToString();
}
return(false);
}
public static void Main(string[] args)
{
LabVariables labVariables = null;
var program = new Program();
try
{
// Start the "prep" mode operations to make sure that the resources are all in the expected state.
Console.WriteLine("Starting up in \"prep\" mode.");
labVariables = program.PrepMode_Run();
Console.WriteLine("\nPrep complete. Transitioning to \"app\" mode.");
program.AppMode_Run(labVariables);
}
catch (Exception ex)
{
LabUtility.DumpError(ex);
}
finally
{
try
{
if (labVariables != null)
{
Console.Write("\nLab run completed. Cleaning up buckets.");
AWSCredentials credentials =
new BasicAWSCredentials(ConfigurationManager.AppSettings["prepModeAWSAccessKey"],
ConfigurationManager.AppSettings["prepModeAWSSecretKey"]);
var s3Client = new AmazonS3Client(credentials, RegionEndpoint);
OptionalLabCode.RemoveLabBuckets(s3Client, labVariables.BucketNames);
Console.WriteLine(" Done.");
}
}
catch (Exception ex)
{
Console.WriteLine("\nAttempt to clean up buckets failed. {0}", ex.Message);
}
Console.WriteLine("\nPress <enter> to end.");
Console.ReadLine();
}
}
public static async Task <string> DeployRestApi(this ICakeContext context, DeployApiGatewayConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
config.EnsureValid();
context.Log.Write(
Cake.Core.Diagnostics.Verbosity.Normal,
Cake.Core.Diagnostics.LogLevel.Information,
$"Deploying api {config.RestApiId} on {config.StageName} stage"
);
var credentials = new BasicAWSCredentials(config.AccessKey, config.SecretKey);
using (var client = new Amazon.APIGateway.AmazonAPIGatewayClient(credentials, config))
{
var response = await client.CreateDeploymentAsync(new Amazon.APIGateway.Model.CreateDeploymentRequest()
{
RestApiId = config.RestApiId,
StageName = config.StageName,
});
var meta = string.Join(" | ", response.ResponseMetadata.Metadata.Select(q => $"{q.Key}={q.Value}"));
if ((int)response.HttpStatusCode < 300)
{
context.Log.Write(
Cake.Core.Diagnostics.Verbosity.Normal,
Cake.Core.Diagnostics.LogLevel.Information,
$"Deployment for api {config.RestApiId} succeeded on stage {config.StageName} with http code {response.HttpStatusCode}; {meta}"
);
return(response.Id);
}
else
{
var message = $"Deployment for api {config.RestApiId} failed on stage {config.StageName} with http code {response.HttpStatusCode}; {meta}";
throw new Exception(message);
}
}
}
public async Task <ActionResult <string> > Signin([FromBody] User user)
{
var validation = user != default(User) &&
!string.IsNullOrEmpty(user.UserName) &&
!string.IsNullOrEmpty(user.Password);
if (!validation)
{
return(BadRequest());
}
var token = string.Empty;
var clientId = "20jo0qhegstp7ovimab8nln5pg";
var userPoolId = @"ap-southeast-1_TarRBIFR7";
var awsCredentials = new BasicAWSCredentials(
accessKey: "AKIAJLCJTGLJZ67AAAZA",
secretKey: "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");
try
{
var authenticationRequest = new AdminInitiateAuthRequest
{
UserPoolId = userPoolId,
ClientId = clientId,
AuthFlow = AuthFlowType.ADMIN_NO_SRP_AUTH
};
authenticationRequest.AuthParameters.Add("USERNAME", user.UserName);
authenticationRequest.AuthParameters.Add("PASSWORD", user.Password);
using (var client =
new AmazonCognitoIdentityProviderClient(awsCredentials, RegionEndpoint.APSouth1))
{
var response = await client.AdminInitiateAuthAsync(authenticationRequest);
token = response.AuthenticationResult.IdToken;
}
}
catch (Exception exceptionObject)
{
throw exceptionObject;
}
return(Ok(token));
}
public ICustomActivityResult Execute()
{
var credentials = new BasicAWSCredentials(AccessKey, SecretKey);
ListBucketsResponse response = new AmazonS3Client(credentials, RegionEndpoint.USEast1).ListBuckets();
var dataTable = new DataTable("List bucket", "AWSS3");
dataTable.Columns.Add("Id");
dataTable.Columns.Add("BucketName");
dataTable.Columns.Add("Created date");
int id = 0;
foreach (S3Bucket bucket in response.Buckets)
{
id++;
dataTable.Rows.Add(id, bucket.BucketName, bucket.CreationDate);
}
return(this.GenerateActivityResult(dataTable));
}
