static void GetPreSigUrl()
{
String fileKey = "test-txt.log";
Amazon.Runtime.BasicAWSCredentials cred = new Amazon.Runtime.BasicAWSCredentials("61140DEQBD8L2QSRATPS", "1oZedqSsM2DLjer2VvZ74ACpn998TamNbz4LEURN");
Amazon.RegionEndpoint endpoint = Amazon.RegionEndpoint.APNortheast1;
//首先创建一个s3的客户端操作对象（需要amazon提供的密钥）
AmazonS3Client s3 = new AmazonS3Client(cred, endpoint);
try
{
// 验证名称为bucketName的bucket是否存在，不存在则创建
Amazon.S3.Model.GetPreSignedUrlRequest urlRequest = new Amazon.S3.Model.GetPreSignedUrlRequest();
urlRequest.BucketName = bucketName;
urlRequest.Key = fileKey;
urlRequest.Protocol = Protocol.HTTP;
urlRequest.Verb = HttpVerb.GET;
urlRequest.Expires = DateTime.Now.AddHours(12); // ;.Now + dtSpan; //new TimeSpan(12,0,0); //12小时有效期
String strSinnedURL = s3.GetPreSignedURL(urlRequest);
Console.WriteLine(strSinnedURL);
}
catch (Amazon.S3.AmazonS3Exception e)
{
Console.WriteLine("GenerateFileSignURL AmazonS3Exception:" + e.ToString());
}
catch (Exception e)
{
Console.WriteLine("GenerateFileSignURL Exception:" + e.ToString());
}
}
public AmazonS3Region(RegionEndpoint region)
{
Name = region.DisplayName;
Identifier = region.SystemName;
AmazonRegion = region;
Hostname = region.GetEndpointForService("s3").Hostname;
}
private DynamoDBConnection(RegionEndpoint endpoint = null)
{
if (endpoint == null) {
endpoint = RegionEndpoint.USEast1;
}
client = new AmazonDynamoDBClient(endpoint);
}
public static void init()
{
String identityPoolId = "YOUR_IDENTITY_POOL_ID"; //Set your Identity Pool here
Amazon.RegionEndpoint region = Amazon.RegionEndpoint.USEast1;
if (String.IsNullOrEmpty(identityPoolId))
{
throw new Exception("You need to set up an identity pool in CognitoSyncClientManager.cs");
}
// CognitoAWSCredentials is recommended in the place of Developer credentials{accessKey,secretKey} for reasons of security best practices
// CognitoAWSCredentials uses the CognitoIdentityProvider & provides temporary scoped AWS credentials from AssumeRoleWithWebIdentity
// ref: http://mobile.awsblog.com/post/TxR1UCU80YEJJZ/Using-the-Amazon-Cognito-Credentials-Provider
#if DEVELOPER_AUTHENTICATED_IDENTITIES
// or to use developer authenticated identities
CognitoAWSCredentials _credentials = new CognitoAWSCredentials(new ExampleIdentityProvider());
#else
// Ref: http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#create-an-identity-pool
// for setting up Cognito Identity Pools, can you use the sample code for .NET SDK
_credentials = new CognitoAWSCredentials(identityPoolId, region);
#endif
// DefaultCognitoSyncManager is a high level CognitoSync Client which handles all Sync operations at a Dataset level.
// Additionally, it also provides local storage of the Datasets which can be later Synchronized with the cloud(CognitoSync service)
// This feature allows the user to continue working w/o internet access and sync with CognitoSync whenever possible
_syncManager = new DefaultCognitoSyncManager(_credentials, new AmazonCognitoSyncConfig {
RegionEndpoint = region
});
}
/// <summary>
/// Constructs the transport with the specified settings
/// </summary>
public AmazonSqsTransport(string inputQueueAddress, string accessKeyId, string secretAccessKey, RegionEndpoint regionEndpoint, IRebusLoggerFactory rebusLoggerFactory)
{
if (accessKeyId == null) throw new ArgumentNullException("accessKeyId");
if (secretAccessKey == null) throw new ArgumentNullException("secretAccessKey");
if (regionEndpoint == null) throw new ArgumentNullException("regionEndpoint");
if (rebusLoggerFactory == null) throw new ArgumentNullException("rebusLoggerFactory");
_inputQueueAddress = inputQueueAddress;
_log = rebusLoggerFactory.GetCurrentClassLogger();
if (_inputQueueAddress != null)
{
if (_inputQueueAddress.Contains("/") && !Uri.IsWellFormedUriString(_inputQueueAddress, UriKind.Absolute))
{
throw new ArgumentException(
"You could either have a simple queue name without slash (eg. \"inputqueue\") - or a complete URL for the queue endpoint. (eg. \"https://sqs.eu-central-1.amazonaws.com/234234234234234/somqueue\")",
"inputQueueAddress");
}
}
_accessKeyId = accessKeyId;
_secretAccessKey = secretAccessKey;
_regionEndpoint = regionEndpoint;
_rebusLoggerFactory = rebusLoggerFactory;
}
public static void DeleteStack(RegionEndpoint awsEndpoint, string stackName)
{
var codeDeployClient = new AmazonCodeDeployClient(awsEndpoint);
var apps = codeDeployClient.ListApplications().Applications.Where(name => name.StartsWith("HelloWorld"));
foreach (var app in apps) {
codeDeployClient.DeleteApplication(new DeleteApplicationRequest {ApplicationName = app});
}
var cloudFormationClient = new AmazonCloudFormationClient(awsEndpoint);
try
{
cloudFormationClient.DeleteStack(new DeleteStackRequest { StackName = stackName });
var testStackStatus = StackStatus.DELETE_IN_PROGRESS;
while (testStackStatus == StackStatus.DELETE_IN_PROGRESS)
{
Thread.Sleep(TimeSpan.FromSeconds(10));
var stacksStatus =
cloudFormationClient.DescribeStacks(new DescribeStacksRequest { StackName = stackName });
testStackStatus = stacksStatus.Stacks.First(s => s.StackName == stackName).StackStatus;
}
}
catch (AmazonCloudFormationException)
{
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AmazonGlacierService"/>.
/// </summary>
/// <param name="endpoint">Region address.</param>
/// <param name="vaultName">Storage name.</param>
/// <param name="accessKey">Key.</param>
/// <param name="secretKey">Secret.</param>
public AmazonGlacierService(RegionEndpoint endpoint, string vaultName, string accessKey, string secretKey)
{
if (vaultName.IsEmpty())
throw new ArgumentNullException("vaultName");
_client = new AmazonS3Client(new BasicAWSCredentials(accessKey, secretKey), endpoint);
_vaultName = vaultName;
}
private const int _bufferSize = 1024 * 1024 * 10; // 10mb
/// <summary>
/// Initializes a new instance of the <see cref="AmazonS3Service"/>.
/// </summary>
/// <param name="endpoint">Region address.</param>
/// <param name="bucket">Storage name.</param>
/// <param name="accessKey">Key.</param>
/// <param name="secretKey">Secret.</param>
public AmazonS3Service(RegionEndpoint endpoint, string bucket, string accessKey, string secretKey)
{
if (bucket.IsEmpty())
throw new ArgumentNullException(nameof(bucket));
_client = new AmazonS3Client(new BasicAWSCredentials(accessKey, secretKey), endpoint);
_bucket = bucket;
}
public FastEmail(Amazon.RegionEndpoint region)
{
if (region != null)
{
endpoint = region;
}
Console.WriteLine($"endpoint: {endpoint}");
init();
}
public static AmazonEC2Client CreateClient(RegionEndpoint region)
{
var key = ConfigurationManager.AppSettings["AWSAccessKey"];
var secretkey = ConfigurationManager.AppSettings["AWSSecretKey"];
if (!string.IsNullOrEmpty(key))
return new AmazonEC2Client(key, secretkey, region);
else
return new AmazonEC2Client();
}
//public CloudAuthService(string appPoolID, string awsRegion):
// this(appPoolID, Amazon.RegionEndpoint.GetBySystemName(awsRegion)){ }
public CloudAuthService(IOptions <AWSOptions> awsOptions)
{
_awsOptions = awsOptions.Value;
_awsRegion = Amazon.RegionEndpoint.GetBySystemName(
_awsOptions.Region);
if (!InitService())
{
throw new AmazonCognitoIdentityException("Couldn't connect to Cognito Service", new Exception("InitService - CognitoClient"));
}
}
/// <summary>
/// Specifies the endpoints available to AWS clients.
/// </summary>
/// <param name="settings">The CloudFront settings.</param>
/// <param name="region">The endpoints available to AWS clients.</param>
/// <returns>The same <see cref="CloudFrontSettings"/> instance so that multiple calls can be chained.</returns>
public static CloudFrontSettings SetRegion(this CloudFrontSettings settings, RegionEndpoint region)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
settings.Region = region;
return settings;
}
/// <summary>
/// Specifies the endpoints available to AWS clients.
/// </summary>
/// <param name="settings">The LoadBalancing settings.</param>
/// <param name="region">The endpoints available to AWS clients.</param>
/// <returns>The same <see cref="LoadBalancingSettings"/> instance so that multiple calls can be chained.</returns>
public static LoadBalancingSettings SetRegion(this LoadBalancingSettings settings, RegionEndpoint region)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
settings.Region = region;
return settings;
}
/// <summary>
/// Configures Rebus to use Amazon Simple Queue Service as the message transport
/// </summary>
public static void UseAmazonSqsAsOneWayClient(this StandardConfigurer<ITransport> configurer, string accessKeyId, string secretAccessKey, RegionEndpoint regionEndpoint)
{
configurer.Register(c =>
{
var rebusLoggerFactory = c.Get<IRebusLoggerFactory>();
var asyncTaskFactory = c.Get<IAsyncTaskFactory>();
return new AmazonSqsTransport(null, accessKeyId, secretAccessKey, regionEndpoint, rebusLoggerFactory, asyncTaskFactory);
});
OneWayClientBackdoor.ConfigureOneWayClient(configurer);
}
/// <summary>
/// This function creates a set of instances into EC2 Classic. It returns the Ids of the created instances if successful, or
/// sets the error code and message otherwise
/// </summary>
/// <param name="regionEndpoint">Region where instances should be created</param>
/// <param name="AMI_ID">Id of the AMI that will be used as a base for the instances</param>
/// <param name="SecurityGroupId">The name of the security group to be assigned to the instance(s)</param>
/// <param name="KeyPairName">The name of the keypair to be assigned to the instance(s)</param>
/// <param name="InstanceType">The type of the instance(s)</param>
/// <param name="InstanceCount">The number of instances to be launched</param>
/// <param name="UserData">The user-data script that will be run as the instance(s) is(are) initialized</param>
/// <returns>The list of Instance Ids if successful</returns>
public List<string> CreateClassicInstances(RegionEndpoint regionEndpoint, string AMI_ID, string SecurityGroupId, string KeyPairName, string InstanceType, int InstanceCount = 1, string UserData = "")
{
List<string> InstanceIds = new List<string> ();
// Initialize error values
ErrorCode = 0;
ErrorMessage = "";
// Create the request object
List<string> groups = new List<string> () { SecurityGroupId };
var launchRequest = new RunInstancesRequest ()
{
ImageId = AMI_ID,
InstanceType = InstanceType,
MinCount = InstanceCount,
MaxCount = InstanceCount,
KeyName = KeyPairName,
SecurityGroupIds = groups,
UserData = Gadgets.Base64Encode (UserData)
};
// Launch the instances
try
{
var launchResponse = EC2client.RunInstances (launchRequest);
// Check response for errors
if (launchResponse.HttpStatusCode != HttpStatusCode.OK)
{
ErrorCode = Convert.ToInt32 (launchResponse.HttpStatusCode);
ErrorMessage = "Http Error [" + launchResponse.HttpStatusCode.ToString () + "]";
}
else
{
List<Instance> createdInstances = launchResponse.Reservation.Instances;
foreach (Instance instance in createdInstances)
{
InstanceIds.Add (instance.InstanceId);
}
}
}
catch (Exception ex)
{
ErrorCode = -1;
ErrorMessage = ex.Message + "::" + ex.InnerException;
}
return InstanceIds;
}
public IAmazonSimpleNotificationService GetSnsClient(RegionEndpoint region)
{
var innerClient = CreateMeABus.DefaultClientFactory().GetSnsClient(region);
var client = Substitute.For<IAmazonSimpleNotificationService>();
client.CreateTopic(Arg.Any<CreateTopicRequest>())
.ReturnsForAnyArgs(r => innerClient.CreateTopic(r.Arg<CreateTopicRequest>()))
.AndDoes(r => Increment("CreateTopic", r.Arg<CreateTopicRequest>().Name, r.Arg<CreateTopicRequest>()));
client.FindTopic(Arg.Any<string>())
.ReturnsForAnyArgs(r => innerClient.FindTopic(r.Arg<string>()))
.AndDoes(r => Increment("FindTopic", r.Arg<string>(), r.Arg<string>()));
return client;
}
public static AmazonS3Client GetApi(AWSCredentials credentials, RegionEndpoint region)
{
if (credentials == null) throw new ArgumentNullException("credentials");
if (region == null) throw new ArgumentNullException("region");
var config = new AmazonS3Config
{
RegionEndpoint = region,
};
ApplyProxy(config);
var api = new AmazonS3Client(credentials, config);
return api;
}
public static List<SecurityGroup> GetAllSecurityGroups(AWSEnvironment environment, RegionEndpoint region)
{
try
{
var ec2Client = AWSClientFactory.CreateAmazonEC2Client(environment.AccessKeyID, environment.SecretAccessKey, region);
var regionSecurityGroups = ec2Client.DescribeSecurityGroups();
return regionSecurityGroups.SecurityGroups;
}
catch (AmazonEC2Exception aex)
{
Logger.Log(LogLevel.Error, aex, $"AmazonEC2Exception in GetAllSecurityGroups() : {aex.Message}");
}
return null;
}
protected override void Given()
{
_topicName = "message";
_queueName = "queue" + DateTime.Now.Ticks;
_regionEndpoint = RegionEndpoint.SAEast1;
EnableMockedBus();
Configuration = new MessagingConfig();
TestEndpoint = _regionEndpoint;
DeleteQueueIfItAlreadyExists(_regionEndpoint, _queueName);
DeleteTopicIfItAlreadyExists(_regionEndpoint, _topicName);
}
private SnsTopicByName EnsureTopicExists(RegionEndpoint region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig)
{
var snsclient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(region);
var eventTopic = _topicCache.TryGetFromCache(region.SystemName, queueConfig.PublishEndpoint);
if (eventTopic != null)
return eventTopic;
eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister);
_topicCache.AddToCache(region.SystemName, queueConfig.PublishEndpoint, eventTopic);
if (!eventTopic.Exists())
eventTopic.Create();
return eventTopic;
}
public static List<AWSInstance> GetAllRDSInstances(AWSEnvironment environment, RegionEndpoint region)
{
var dbInstances = new List<AWSInstance>();
try
{
var rdsClient = AWSClientFactory.CreateAmazonRDSClient(environment.AccessKeyID, environment.SecretAccessKey, region);
var rdsInstances = rdsClient.DescribeDBInstances();
foreach (var dbInstance in rdsInstances.DBInstances)
{
var rdsInstance = new AWSInstance
{
Role = dbInstance.Engine.ToUpper(),
Name = dbInstance.DBInstanceIdentifier,
InstanceType = dbInstance.DBInstanceClass,
PubliclyAccessible = dbInstance.PubliclyAccessible,
Encrypted = dbInstance.StorageEncrypted,
Platform = Platforms.Linux,
State = States.Running,
IsRDS = true
};
if (rdsInstance.Role == "MSSQL")
{
rdsInstance.Platform = Platforms.Windows;
}
foreach (var subnet in dbInstance.DBSubnetGroup.Subnets)
{
rdsInstance.SubnetIDs.Add(subnet.SubnetIdentifier);
}
foreach (var vpcSecurityGroup in dbInstance.VpcSecurityGroups)
{
rdsInstance.SecurityGroupIDs.Add(vpcSecurityGroup.VpcSecurityGroupId);
}
dbInstances.Add(rdsInstance);
}
}
catch (AmazonEC2Exception aex)
{
Logger.Log(LogLevel.Error, aex, $"AmazonEC2Exception in GetAllRDSInstances() : {aex.Message}");
}
return dbInstances;
}
// Called when Start game button is clicked
void StartGame()
{
if (!this.gameStartRequested)
{
this.startGameButton.gameObject.SetActive(false);
this.gameStartRequested = true;
FindObjectOfType <UIManager>().SetTextBox("Setting up Client..");
// Get the Region enum from the string value
this.region = Amazon.RegionEndpoint.GetBySystemName(regionString);
Debug.Log("My Region endpoint: " + this.region);
// Check if we have stored an identity and request credentials for that existing identity
Client.cognitoID = PlayerPrefs.GetString("CognitoID", null);
if (Client.cognitoID != null && Client.cognitoID != "")
{
Debug.Log("Requesting credentials for existing identity: " + Client.cognitoID);
var response = Task.Run(() => GetCredentialsForExistingIdentity(Client.cognitoID));
response.Wait(5000);
Client.cognitoID = response.Result.IdentityId;
Client.cognitoCredentials = new Amazon.Runtime.ImmutableCredentials(response.Result.Credentials.AccessKeyId, response.Result.Credentials.SecretKey, response.Result.Credentials.SessionToken);
}
// Else get a new identity
else
{
Debug.Log("Requesting a new playeridentity as none stored yet.");
CognitoAWSCredentials credentials = new CognitoAWSCredentials(
this.identityPoolID,
this.region);
Client.cognitoCredentials = credentials.GetCredentials();
Client.cognitoID = credentials.GetIdentityId();
Debug.Log("Got Cognito ID: " + credentials.GetIdentityId());
// Store to player prefs and save for future games
PlayerPrefs.SetString("CognitoID", Client.cognitoID);
PlayerPrefs.Save();
}
// Get latencies to regions
this.MeasureLatencies();
// Connect to the server now that we have our identity, credendtials and latencies
StartCoroutine(ConnectToServer());
}
}
public AWSS3Helper(RegionEndpoint regionendpoint, String AWSAccessKey, String AWSSecretKey)
{
// Set configuration info
AmazonS3Config config = new AmazonS3Config ();
config.Timeout = new TimeSpan (1, 0, 0);
config.ReadWriteTimeout = new TimeSpan (1, 0, 0);
config.RegionEndpoint = regionendpoint;
// Create S3 client
S3client = Amazon.AWSClientFactory.CreateAmazonS3Client
(Gadgets.LoadConfigurationSetting ("AWSAccessKey", AWSAccessKey),
Gadgets.LoadConfigurationSetting ("AWSSecretKey", AWSSecretKey),
config);
// Create the file transfer utility class
fileTransferUtility = new TransferUtility (S3client);
}
public FDGlacier(FDUserSettings settings, FDOperationLog oplog, string optype)
{
this.vaultName = settings.AWSGlacierVaultName;
log = oplog;
switch (settings.AWSRegion) {
case FDUserSettings.AWSRegionIndex.USWest1:
region = RegionEndpoint.USWest1;
break;
case FDUserSettings.AWSRegionIndex.USWest2:
region = RegionEndpoint.USWest2;
break;
case FDUserSettings.AWSRegionIndex.USEast1:
region = RegionEndpoint.USEast1;
break;
case FDUserSettings.AWSRegionIndex.EUWest1:
region = RegionEndpoint.EUWest1;
break;
case FDUserSettings.AWSRegionIndex.APNortheast1:
region = RegionEndpoint.APNortheast1;
break;
default:
region = RegionEndpoint.USEast1;
break;
}
//Instantiate the glacier config with our settins (for future move to AmazonGlacierClient)
glacierConfig = new AmazonGlacierConfig();
glacierConfig.RegionEndpoint = region;
//Instantiate AWS Credentials
awsCredentials = new BasicAWSCredentials(settings.AWSAccessKey, settings.AWSSecretKey);
//Instantiate the transfer manager with our settings
//TODO: Switch to glacier client so we can abort this damn thing
//glacierClient = new AmazonGlacierClient(appConfig["AWSAccessKey"], appConfig["AWSSecretKey"], region);
transferManager = new ArchiveTransferManager(awsCredentials, region);
upOptions = new UploadOptions();
downOptions = new DownloadOptions();
progress = 0;
upOptions.StreamTransferProgress = downOptions.StreamTransferProgress = this.onProgress;
OperationType = optype;
}
public static List<AWSSubnet> GetAllAWSSubnets(AWSEnvironment environment, RegionEndpoint region)
{
var subnets = new List<AWSSubnet>();
try
{
var ec2Client = AWSClientFactory.CreateAmazonEC2Client(environment.AccessKeyID, environment.SecretAccessKey, region);
var regionSubnets = ec2Client.DescribeSubnets();
foreach (var subnet in regionSubnets.Subnets)
{
subnets.Add(new AWSSubnet(subnet) { Public = IsSubnetPublic(ec2Client, subnet.SubnetId) });
}
}
catch (AmazonEC2Exception aex)
{
Logger.Log(LogLevel.Error, aex, $"AmazonEC2Exception in GetAllAWSSubnets() : {aex.Message}");
}
return subnets;
}
public PvcS3(
string accessKey = null,
string secretKey = null,
string bucketName = null,
Amazon.RegionEndpoint regionEndpoint = null)
{
this.accessKey = accessKey != null ? accessKey : PvcS3.AccessKey;
this.secretKey = secretKey != null ? secretKey : PvcS3.SecretKey;
this.bucketName = bucketName != null ? bucketName : PvcS3.BucketName;
this.regionEndpoint = regionEndpoint != null ? regionEndpoint : PvcS3.RegionEndpoint;
// Set up the API client for S3.
AWSCredentials creds = new BasicAWSCredentials(this.accessKey, this.secretKey);
this.s3client = new AmazonS3Client(creds, this.regionEndpoint);
// Initialize some private stuff that we use to track md5 sums
this.keyEtags = new Dictionary<string, string>();
this.keyMD5Sums = new Dictionary<string, string>();
}
public PvcS3(
string accessKey = null,
string secretKey = null,
string bucketName = null,
Amazon.RegionEndpoint regionEndpoint = null)
{
this.accessKey = accessKey != null ? accessKey : PvcS3.AccessKey;
this.secretKey = secretKey != null ? secretKey : PvcS3.SecretKey;
this.bucketName = bucketName != null ? bucketName : PvcS3.BucketName;
this.regionEndpoint = regionEndpoint != null ? regionEndpoint : PvcS3.RegionEndpoint;
// Set up the API client for S3.
AWSCredentials creds = new BasicAWSCredentials(this.accessKey, this.secretKey);
this.s3client = new AmazonS3Client(creds, this.regionEndpoint);
// Initialize some private stuff that we use to track md5 sums
this.keyEtags = new Dictionary <string, string>();
this.keyMD5Sums = new Dictionary <string, string>();
}
public S3FileSystem(string virtualRoot, string awsAccessKey, string awsSecretKey, string awsBucketName, string awsSaveMediaToS3, string awsRegion)
{
if (virtualRoot == null)
{
throw new ArgumentNullException(nameof(virtualRoot));
}
if (!virtualRoot.StartsWith("~/"))
{
throw new ArgumentException("The virtualRoot argument must be a virtual path and start with '~/'");
}
RootPath = IOHelper.MapPath(virtualRoot);
_rootUrl = IOHelper.ResolveUrl(virtualRoot);
AwsAccessKey = awsAccessKey;
AwsSecretKey = awsSecretKey;
AwsBucketName = awsBucketName;
AwsSaveMediaToS3 = bool.Parse(awsSaveMediaToS3);
// [ML] - This isnt ideal, but is the best way i an think of making this paramaterized in the IFileSystemProviderManager
FieldInfo field = null;
if (!string.IsNullOrWhiteSpace(awsRegion))
{
field = typeof(RegionEndpoint).GetField(awsRegion, BindingFlags.Static | BindingFlags.Public);
if (field == null)
{
throw new ArgumentException($"No Field found on '{typeof(RegionEndpoint).Name}' with the name '{awsRegion}'");
}
}
AwsRegion = field?.GetValue(null) as RegionEndpoint ?? RegionEndpoint.USWest1;
if (AwsIsValid)
{
_amazonS3FileSystem = new AmazonS3FileSystem(AwsAccessKey, AwsSecretKey, AwsBucketName, AwsRegion);
}
}
public void To_Config(
string configStr,
string expectedBucketName,RegionEndpoint expectedRegion, string expectedkeyPrefix, string expectedDelimiter,
Expression<Action<IAWSCredentialsFactory>> verify
) {
var configToken = JToken.Parse(configStr);
var config = this.converter.ToConfig(configToken);
Assert.NotNull(config);
var s3Config = config as AmazonS3CabinetConfig;
Assert.NotNull(s3Config);
Assert.Equal(expectedBucketName, s3Config.BucketName);
Assert.Equal(expectedRegion, s3Config.AmazonS3Config.RegionEndpoint);
Assert.Equal(expectedkeyPrefix, s3Config.KeyPrefix);
Assert.Equal(expectedDelimiter, s3Config.Delimiter);
this.mockCredentialsFactory.Verify(verify, Times.Once);
}
/// <summary>
/// Configures Rebus to use Amazon Simple Queue Service as the message transport
/// </summary>
public static void UseAmazonSqs(this StandardConfigurer<ITransport> configurer, string accessKeyId, string secretAccessKey, RegionEndpoint regionEndpoint, string inputQueueAddress)
{
configurer.Register(c =>
{
var rebusLoggerFactory = c.Get<IRebusLoggerFactory>();
var asyncTaskFactory = c.Get<IAsyncTaskFactory>();
return new AmazonSqsTransport(inputQueueAddress, accessKeyId, secretAccessKey, regionEndpoint, rebusLoggerFactory, asyncTaskFactory);
});
configurer
.OtherService<IPipeline>()
.Decorate(p =>
{
var pipeline = p.Get<IPipeline>();
return new PipelineStepRemover(pipeline)
.RemoveIncomingStep(s => s.GetType() == typeof (HandleDeferredMessagesStep));
});
configurer.OtherService<ITimeoutManager>().Register(c => new DisabledTimeoutManager(), description: SqsTimeoutManagerText);
}
public IAmazonSQS GetSqsClient(RegionEndpoint region)
{
var innerClient = CreateMeABus.DefaultClientFactory().GetSqsClient(region);
var client = Substitute.For<IAmazonSQS>();
client.ListQueues(Arg.Any<ListQueuesRequest>())
.ReturnsForAnyArgs(r => innerClient.ListQueues(r.Arg<ListQueuesRequest>()))
.AndDoes(r => Increment("ListQueues", r.Arg<ListQueuesRequest>().QueueNamePrefix, r.Arg<ListQueuesRequest>()));
client.CreateQueue(Arg.Any<CreateQueueRequest>())
.ReturnsForAnyArgs(r => innerClient.CreateQueue(r.Arg<CreateQueueRequest>()))
.AndDoes(r => Increment("CreateQueue", r.Arg<CreateQueueRequest>().QueueName, r.Arg<CreateQueueRequest>()));
client.GetQueueAttributes(Arg.Any<GetQueueAttributesRequest>())
.ReturnsForAnyArgs(r => innerClient.GetQueueAttributes(r.Arg<GetQueueAttributesRequest>()))
.AndDoes(r => Increment("GetQueueAttributes", r.Arg<GetQueueAttributesRequest>().QueueUrl, r.Arg<GetQueueAttributesRequest>()));
client.ReceiveMessageAsync(Arg.Any<ReceiveMessageRequest>())
.ReturnsForAnyArgs(r => innerClient.ReceiveMessageAsync(r.Arg<ReceiveMessageRequest>()))
.AndDoes(r => Increment("ReceiveMessageAsync", r.Arg<ReceiveMessageRequest>().QueueUrl, r.Arg<ReceiveMessageRequest>()));
return client;
}
private void Init()
{
// Input check
if (String.IsNullOrEmpty(ConfigurationManager.AppSettings["AccessKey"]))
{
throw new ConfigurationException("Illegal configuration file - missing AWS AccessKey");
}
if (String.IsNullOrEmpty(ConfigurationManager.AppSettings["SecretKey"]))
{
throw new ConfigurationException("Illegal configuration file - missing AWS SecretKey");
}
if (String.IsNullOrEmpty(ConfigurationManager.AppSettings["BucketName"]))
{
throw new ConfigurationException("Illegal configuration file - missing bucket name");
}
_accessKeyID = ConfigurationManager.AppSettings["AccessKey"];
_secretAccessKey = ConfigurationManager.AppSettings["SecretKey"];
_bucketName = ConfigurationManager.AppSettings["BucketName"];
_regionEndpoint = Amazon.RegionEndpoint.EUWest1;
_client = new AmazonS3Client(_accessKeyID, _secretAccessKey, _regionEndpoint);
}
public SqsQueueByUrl(RegionEndpoint region, string queueUrl, IAmazonSQS client)
: base(region, client)
{
Url = queueUrl;
}
/// <summary>
/// Create a client for the Amazon AutoScaling Service with the specified region
/// </summary>
/// <param name="awsAccessKey">The AWS Access Key associated with the account</param>
/// <param name="awsSecretAccessKey">The AWS Secret Access Key associated with the account</param>
/// <param name="region">The region to connect to.</param>
/// <returns>An Amazon AutoScaling client</returns>
/// <remarks>
/// </remarks>
public static IAmazonAutoScaling CreateAmazonAutoScalingClient(
string awsAccessKey,
string awsSecretAccessKey, RegionEndpoint region
)
{
return new AmazonAutoScalingClient(awsAccessKey, awsSecretAccessKey, region);
}
/// <summary>
/// Create a client for the Amazon SimpleEmailService Service with AWSCredentials and region.
/// </summary>
/// <param name="credentials">AWS Credentials</param>
/// <param name="region">The region to connect to.</param>
/// <returns>An Amazon SimpleEmailService client</returns>
/// <remarks>
/// </remarks>
public static IAmazonSimpleEmailService CreateAmazonSimpleEmailServiceClient(AWSCredentials credentials, RegionEndpoint region)
{
return new AmazonSimpleEmailServiceClient(credentials, region);
}
/// <summary>
/// Create a client for the Amazon SimpleEmailService Service with the specified region
/// </summary>
/// <param name="awsAccessKey">The AWS Access Key associated with the account</param>
/// <param name="awsSecretAccessKey">The AWS Secret Access Key associated with the account</param>
/// <param name="region">The region to connect to.</param>
/// <returns>An Amazon SimpleEmailService client</returns>
/// <remarks>
/// </remarks>
public static IAmazonSimpleEmailService CreateAmazonSimpleEmailServiceClient(
string awsAccessKey,
string awsSecretAccessKey, RegionEndpoint region
)
{
return new AmazonSimpleEmailServiceClient(awsAccessKey, awsSecretAccessKey, region);
}
/// <summary>
/// Create a client for the Amazon SecurityTokenService Service with AWSCredentials and region.
/// </summary>
/// <param name="credentials">AWS Credentials</param>
/// <param name="region">The region to connect to.</param>
/// <returns>An Amazon SecurityTokenService client</returns>
/// <remarks>
/// </remarks>
public static IAmazonSecurityTokenService CreateAmazonSecurityTokenServiceClient(AWSCredentials credentials, RegionEndpoint region)
{
return new AmazonSecurityTokenServiceClient(credentials, region);
}
/// <summary>
///
/// </summary>
/// <param name="credentials"></param>
/// <param name="region"></param>
public AWSLambdaClient(AWSCredentials credentials, Amazon.RegionEndpoint region)
{
_client = new AmazonLambdaClient(credentials, region);
}
/// <summary>
/// Bind the S3Region and S3Bucket
/// </summary>
/// <param name="s3Region"></param>
/// <param name="s3BucketName"></param>
public FileRepository(Amazon.RegionEndpoint s3Region, string s3BucketName)
{
_s3Region = s3Region;
_s3BucketName = s3BucketName;
}
/// <summary>
/// 生成签名（带自定义查询字符串）
/// @wHaibo
/// </summary>
/// <param name="bucketName"></param>
/// <param name="fileKey"></param>
/// <param name="qs"></param>
/// <param name="expires"></param>
/// <returns></returns>
static string SignURL(string bucketName, string fileKey, NameValueCollection qs, TimeSpan expires)
{
Amazon.Runtime.BasicAWSCredentials cred = new Amazon.Runtime.BasicAWSCredentials(strAccessKey, strSecretKey);
Amazon.RegionEndpoint endpoint = Amazon.RegionEndpoint.CNNorth1;
//Amazon.RegionEndpoint endpoint = Amazon.RegionEndpoint.APNortheast1;
string host = endpoint.GetEndpointForService(bucketName + ".s3").Hostname;
string method = "GET";
string fk = fileKey.Replace("/", "_XXXX_");
string uri = "/" + System.Uri.EscapeDataString(fk);
uri = uri.Replace("_XXXX_", "/");
Console.WriteLine(uri);
DateTime dt = DateTime.Now.ToUniversalTime();
string algorithm = "AWS4-HMAC-SHA256";
string amz_date = dt.ToString("yyyyMMddTHHmmss") + "Z";
string datestamp = dt.ToString("yyyyMMdd");
string credential_scope = datestamp + "/" + endpoint.SystemName + "/s3/" + "aws4_request";
NameValueCollection queryString = new NameValueCollection();
if (qs != null && qs.Count > 0)
{
queryString.Add(qs);
}
queryString.Add("X-Amz-Algorithm", algorithm);
queryString.Add("X-Amz-Credential", String.Format("{0}/{1}",
strAccessKey, credential_scope));
queryString.Add("X-Amz-Date", amz_date);
queryString.Add("X-Amz-Expires", Math.Round(expires.TotalSeconds, 0).ToString());
queryString.Add("X-Amz-SignedHeaders", "host");
List <String> kl = queryString.AllKeys.OrderBy(x => new StringAsciiCompare(WebUtility.UrlEncode(x))).ToList();
StringBuilder sb = new StringBuilder();
foreach (string k in kl)
{
if (sb.Length > 0)
{
sb.Append("&");
}
sb.Append(WebUtility.UrlEncode(k)).Append("=");
if (!String.IsNullOrEmpty(queryString[k]))
{
sb.Append(WebUtility.UrlEncode(queryString[k]));
}
}
string canonical_headers = "host:" + host + '\n';
string signed_headers = "host";
string canonical_request = method + '\n' + uri + '\n' + sb.ToString() + '\n' + canonical_headers + '\n' + signed_headers + '\n' + "UNSIGNED-PAYLOAD";
Console.WriteLine(canonical_request);
string string_to_sign = algorithm + '\n' + amz_date + '\n' + credential_scope + '\n' + sha256(canonical_request);
byte[] signing_key = getSignatureKey(strSecretKey, datestamp, endpoint.SystemName, "s3");
string signature = BitConverter.ToString(HmacSHA256(string_to_sign, signing_key)).Replace("-", "").ToLower();
string url = "http://" + host + uri + "?" + sb.ToString() + "&X-Amz-Signature=" + signature;
return(url);
}
