public string EnsureSecurityGroupExists(AwsRegionLocations region)
{
var regionEndpoint = region.ToAwsRegionEndpoint();
// Get an Ec2Client for the current region
var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, regionEndpoint));
// Find the VPC ID for this region
var vpcId = client.DescribeVpcs().Vpcs.Single().VpcId;
// Does the security group with our preset name exist?
var matchingGroups = client.DescribeSecurityGroups().SecurityGroups.Where(x => x.GroupName == securityGroupName).ToList();
if (matchingGroups.Any())
{
// If it exists, assert that it has the same VPC ID as the one we found earlier
if (matchingGroups.Single().VpcId != vpcId)
{
throw new Exception("Security Group already exists with invalid VPC.");
}
return(matchingGroups.Single().GroupId);
}
else
{
// It does not exist, so create it.
return(CreateSecurityGroup(client, vpcId, securityGroupName));
}
}
public static void InvokeListInstances()
{
NameValueCollection appConfig = ConfigurationManager.AppSettings;
IAmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(RegionEndpoint.USWest2);
DescribeInstancesRequest request = new DescribeInstancesRequest();
try
{
DescribeInstancesResponse ec2Response = ec2.DescribeInstances(request);
int numInstances = 0;
numInstances = ec2Response.Reservations.Count;
Console.WriteLine("You have " + numInstances + " Amazon EC2 instance(s) running.");
}
catch (AmazonEC2Exception ex)
{
if (ex.ErrorCode.Equals("OptInRequired"))
{
Console.WriteLine("You are not signed for Amazon EC2.");
Console.WriteLine("You can sign up at http://aws.amazon.com/ec2.");
}
else
{
Console.WriteLine("Caught Exception: " + ex.Message);
Console.WriteLine("Response Status Code: " + ex.StatusCode);
Console.WriteLine("Error Code: " + ex.ErrorCode);
Console.WriteLine("Error Type: " + ex.ErrorType);
Console.WriteLine("Request ID: " + ex.RequestId);
}
}
Console.WriteLine();
}
public override bool Execute()
{
using (var ec2Client = AWSClientFactory.CreateAmazonEC2Client(
AwsAccessKey, AwsSecretKey, new AmazonEC2Config().WithServiceURL("https://eu-west-1.ec2.amazonaws.com")))
{
var runInstanceResponse = ec2Client.RunInstances(
new RunInstancesRequest()
.WithImageId(AmiId)
.WithMinCount(1)
.WithMaxCount(1)
.WithInstanceType(InstanceType)
.WithSecurityGroup(SecurityGroup)
.WithKeyName(KeyPair));
var instanceId = runInstanceResponse.RunInstancesResult.Reservation.RunningInstance[0].InstanceId;
while (IsInstancePending(ec2Client, instanceId))
{
Log.LogMessage("Instance starting up...");
Thread.Sleep(5000);
}
var instancePublicAddress = GetPublicDnsName(ec2Client, instanceId);
Log.LogMessage("{0} instance started!", instancePublicAddress);
InstancePublicDnsName = instancePublicAddress;
InstanceId = instanceId;
return(true);
}
}
public RegionDetails GetRegionData(AwsRegionLocations region)
{
var regionEndpoint = region.ToAwsRegionEndpoint();
// Get an Ec2Client for the current region
var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, regionEndpoint));
// Get instances within the region
// Start by creating the request
var request = new DescribeInstancesRequest();
// Add a filter to the request so that it only returns instances that are either in "Running" or "Pending" state.
request.Filters.Add(new Filter("instance-state-code", new List <string>()
{
((ushort)InstanceStatuses.Running).ToString(),
((ushort)InstanceStatuses.Pending).ToString()
}));
// Send the request to Amazon
var reservations = client.DescribeInstances(request).Reservations;
return(new RegionDetails()
{
Name = regionEndpoint.SystemName,
Region = region,
Instances = reservations.SelectMany(x => x.Instances).Select(x => x.ToInstanceInfo()).ToList()
});
}
public static bool CheckConnection()
{
try
{
AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(
App.Settings.AWSAccessKey,
App.Settings.AWSSecretKey,
new AmazonEC2Config {
ServiceURL = App.Settings.ServiceUrl
}
);
ec2.DescribeInstances(new DescribeInstancesRequest());
return(true);
}
catch (AmazonEC2Exception ex)
{
string message = ex.Message + "\r\n" +
"Response Status Code: " + ex.StatusCode + "\r\n" +
"Error Code: " + ex.ErrorCode + "\r\n" +
"Error Type: " + ex.ErrorType + "\r\n" +
"Request ID: " + ex.RequestId;
ExceptionDialog.Show(new AmazonEC2Exception(message, ex));
return(false);
}
catch (Exception ex)
{
ExceptionDialog.Show(ex);
return(false);
}
}
public static void Main(string[] args)
{
if (args.Length == 0)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ControlGUI());
}
else
{
//stop all instances if run by command line
List <string> allInstances = new List <string>();
Configuration configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
string key = configuration.AppSettings.Settings["AWSAccessKey"].Value;
string secret = configuration.AppSettings.Settings["AWSSecretKey"].Value;
IAmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(key, secret);
DescribeInstancesRequest req = new DescribeInstancesRequest();
var result = ec2.DescribeInstances(req);
foreach (var reservation in result.Reservations)
{
foreach (var ns in reservation.Instances)
{
allInstances.Add(ns.InstanceId);
}
}
var deleteRequest = new TerminateInstancesRequest()
{
InstanceIds = allInstances
};
var deleteResponse = ec2.TerminateInstances(deleteRequest);
}
}
private string FindNewestInstanceId(AwsRegionLocations region)
{
var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, region.ToAwsRegionEndpoint()));
// Get instances within the region
// Start by creating the request
var request = new DescribeInstancesRequest();
// Add a filter to the request so that it only returns instances that are either in "Running" state.
request.Filters.Add(new Filter("instance-state-code", new List <string>()
{
((ushort)InstanceStatuses.Running).ToString(),
}));
// Send the request to Amazon
var reservations = client.DescribeInstances(request).Reservations;
var instances = reservations.SelectMany(x => x.Instances);
if (instances.Any())
{
var newestInstance = instances.OrderByDescending(i => i.LaunchTime).First();
return(newestInstance.InstanceId);
}
return(null);
}
public void SetUp()
{
AWSCredentials credentials = AmbientCredentials.GetCredentials();
Ec2Client = AWSClientFactory.CreateAmazonEC2Client(credentials);
Service = new SecurityGroupService(Ec2Client);
}
private void CreateAndLaunchInstance(AwsRegionLocations region)
{
// Get an Ec2Client for the current region
var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, region.ToAwsRegionEndpoint()));
var securityGroupId = EnsureSecurityGroupExists(region);
var availableSubnets = client.DescribeSubnets().Subnets.OrderByDescending(x => x.AvailableIpAddressCount);
var networkSpecification = new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = availableSubnets.First().SubnetId,
Groups = new List <string>()
{
securityGroupId
},
AssociatePublicIpAddress = true
};
var networkSpecifications = new List <InstanceNetworkInterfaceSpecification>()
{
networkSpecification
};
var launchRequest = new RunInstancesRequest()
{
ImageId = GetAmiId(client, amiName),
InstanceType = "t2.micro",
MinCount = 1,
MaxCount = 1,
KeyName = keyPairName,
NetworkInterfaces = networkSpecifications
};
client.RunInstances(launchRequest);
}
/// <summary>
/// Get list of running instances in region for
/// web service URL in application config
/// </summary>
/// <returns></returns>
static private List <RunningInstance> GetRunningInstances()
{
AppConfig.Refresh();
AmazonEC2Config config = new AmazonEC2Config();
config.ServiceURL = AppConfig.AWSServiceURL;
AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(
AppConfig.AWSAccessKey,
AppConfig.AWSSecretKey,
config
);
//list of running instances
List <RunningInstance> runningInstancesList = new List <RunningInstance>();
DescribeInstancesResult serviceResult;
if (!string.IsNullOrEmpty(AppConfig.FilterByTag))
{
RunningInstance currentInstance = GetCurrentInstance(ec2);
String currentInstancegroupvalue = GetCurrentInstanceGroupValue(currentInstance);
// ask service for descriptions
serviceResult =
ec2.DescribeInstances(new DescribeInstancesRequest().WithFilter(new Filter().WithName("tag:" + AppConfig.FilterByTag).WithValue(currentInstancegroupvalue))).DescribeInstancesResult;
}
else
{
serviceResult =
ec2.DescribeInstances(new DescribeInstancesRequest()).DescribeInstancesResult;
}
if (serviceResult.IsSetReservation())
{
//reservation is a group of instances launched from the same console
List <Reservation> reservationList = serviceResult.Reservation;
foreach (Reservation reservation in reservationList)
{
if (reservation.IsSetRunningInstance())
{
//with all instances in reservation
//This list contains not only running instances
List <RunningInstance> instancesList = reservation.RunningInstance;
foreach (RunningInstance instance in instancesList)
{ //include in result only really running ones
if (RUNNING_STATE == instance.InstanceState.Code)
{
runningInstancesList.Add(instance);
}
}
}
}
}
return(runningInstancesList);
}
/// <summary>
/// Return the EC2 client
/// </summary>
/// <returns></returns>
public static AmazonEC2 CreateClient()
{
AmazonEC2Config config = new AmazonEC2Config();
config.ServiceURL = "https://ec2." + Program.options.Region + ".amazonaws.com";
AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(Program.options.AccessKey, Program.options.SecretKey, config);
return(ec2);
}
/// <summary>
/// Prevent inheritance of the method. Bind required parameters.
/// </summary>
protected sealed override void InternalExecute()
{
// Setup the WCF channel to the EC2 computing environment
if (this.EC2Client == null)
{
this.EC2Client = AWSClientFactory.CreateAmazonEC2Client(this.AccessKey.Get(this.ActivityContext), this.SecretKey.Get(this.ActivityContext));
}
this.AmazonExecute();
}
public void SetUp()
{
AWSCredentials credentials = AmbientCredentials.GetCredentials();
Ec2Client = AWSClientFactory.CreateAmazonEC2Client(credentials);
SecurityGroupService = new SecurityGroupService(Ec2Client);
Creator = new DefaultSecurityGroupCreator(SecurityGroupService)
{
SecurityGroupName = _testSecurityGroupName
};
}
public AwsClient(AWSCredentials credentials, IStackItConfiguration configuration)
{
_credentials = credentials;
_cloudFormationClient = new Lazy <IAmazonCloudFormation>(() => AWSClientFactory.CreateAmazonCloudFormationClient(_credentials));
_ec2Client = new Lazy <IAmazonEC2>(() => AWSClientFactory.CreateAmazonEC2Client(_credentials));
_route53Client = new Lazy <IAmazonRoute53>(() => AWSClientFactory.CreateAmazonRoute53Client(_credentials));
_s3Client = new Lazy <IAmazonS3>(() => AWSClientFactory.CreateAmazonS3Client(_credentials));
_iamClient = new Lazy <IAmazonIdentityManagementService>(() => AWSClientFactory.CreateAmazonIdentityManagementServiceClient(_credentials));
_configuration = configuration;
}
void worker_DoWork(object sender, DoWorkEventArgs e)
{
//validate args
if (String.IsNullOrEmpty(AWSAccessKey) || String.IsNullOrEmpty(AWSSecretKey))
{
e.Result = null;
return;
}
//ec2 client
var ec2 = AWSClientFactory.CreateAmazonEC2Client(AWSAccessKey,
AWSSecretKey,
new AmazonEC2Config().WithServiceURL(RegionHelper.EC2EndpointForRegion(EC2Region))
);
//get instances
IEnumerable <RunningInstance> instances;
try
{
var response = ec2.DescribeInstances(new Amazon.EC2.Model.DescribeInstancesRequest());
//handle no data
if (!response.IsSetDescribeInstancesResult())
{
e.Result = null;
return;
}
instances = response.DescribeInstancesResult.Reservation.SelectMany(res => res.RunningInstance);
}
catch (Exception ex)
{
//handle error retreiving data
e.Result = null;
//TODO: log exception
return;
}
//parse data
e.Result = instances.Select(instance => new Connection
{
Host = instance.PublicDnsName,
Id = instance.InstanceId,
Name = GetInstanceFriendlyName(instance),
Protocol = String.Equals(instance.Platform, "windows", StringComparison.InvariantCultureIgnoreCase) ? ConnectionProtocol.RDP : ConnectionProtocol.SSH,
HexIp = instance.InstanceState.Name != "running" ? "" : GetHexIPAddress(instance.PrivateIpAddress),
KeyName = instance.KeyName,
AvailabilityZone = instance.Placement.AvailabilityZone
}).ToList();
}
public Ec2Factory(string AWSAccessKey, string AWSSecretKey, string serviceUrl, ChaosLogger logger)
{
this.logger = logger;
if (!serviceUrl.Contains("http://"))
{
serviceUrl = "http://" + serviceUrl;
}
amazonEc2 = AWSClientFactory.CreateAmazonEC2Client(
AWSAccessKey,
AWSSecretKey,
new AmazonEC2Config().WithServiceURL(serviceUrl));
}
public override bool Execute()
{
using (var ec2Client = AWSClientFactory.CreateAmazonEC2Client(
AwsAccessKey, AwsSecretKey, new AmazonEC2Config().WithServiceURL("https://eu-west-1.ec2.amazonaws.com")))
{
var createImageResponse = ec2Client.CreateImage(new CreateImageRequest()
.WithInstanceId(InstanceId)
.WithName(InstanceName)
.WithNoReboot(false));
AmiId = createImageResponse.CreateImageResult.ImageId;
}
return(true);
}
private List <AmazonBermudaNode> GetActiveClusterBermudaNodes()
{
AmazonEC2 ec2;
ec2 = AWSClientFactory.CreateAmazonEC2Client();
var resp = ec2.DescribeInstances(new DescribeInstancesRequest());
var addresses = resp.DescribeInstancesResult.Reservation;
var currentIP = CurrentIPAddress.ToString();
var allAmazonBermudaNodes = new List <AmazonBermudaNode>();
foreach (var a in addresses)
{
foreach (var ri in a.RunningInstance.Where(i => !string.IsNullOrWhiteSpace(i.PrivateIpAddress)))
{
var newNode = new AmazonBermudaNode();
bool hasNodeId = false;
bool hasClusterName = false;
foreach (var tag in ri.Tag)
{
if (tag.Key == BERMUDA_NODE_ID_KEY)
{
newNode.AmazonInstance = ri;
newNode.IsCurrentInstance = ri.PrivateIpAddress == currentIP;
newNode.NodeId = Int32.Parse(tag.Value);
var pi = new PeerInfo();
pi.Id = ri.InstanceId;
pi.EndPoint = new IPEndPoint(IPAddress.Parse(ri.PrivateIpAddress), INTERNAL_PORT);
newNode.PeerInfo = pi;
hasNodeId = true;
}
else if (tag.Key == BERMUDA_CLUSTER_NAME_KEY)
{
newNode.ClusterName = tag.Value;
hasClusterName = true;
}
}
if (hasNodeId && hasClusterName)
{
allAmazonBermudaNodes.Add(newNode);
}
}
}
var activeClusterName = allAmazonBermudaNodes.Single(abn => abn.IsCurrentInstance).ClusterName;
var activeClusterBermudaNodes = allAmazonBermudaNodes.Where(abn => abn.ClusterName == activeClusterName);
return(activeClusterBermudaNodes.ToList());
}
public static List <Instance> GetInstances()
{
try
{
var result = new List <Instance>();
AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(
App.Settings.AWSAccessKey,
App.Settings.AWSSecretKey,
new AmazonEC2Config {
ServiceURL = App.Settings.ServiceUrl
}
);
var ec2Response = ec2.DescribeInstances(new DescribeInstancesRequest());
foreach (var image in ec2Response.DescribeInstancesResult.Reservation.SelectMany(a => a.RunningInstance))
{
var nameTag = image.Tag.Where(t => t.Key == "Name").FirstOrDefault();
var name = nameTag != null ? nameTag.Value : image.InstanceId;
var instance = new Instance()
{
Id = image.InstanceId,
Name = name,
StateName = image.InstanceState.Name,
State = (InstatnceStates)image.InstanceState.Code,
PublicIp = image.IpAddress,
PrivateIp = image.PrivateIpAddress,
InstanceType = image.InstanceType,
PublicDnsName = image.PublicDnsName,
PrivateDnsName = image.PrivateDnsName
};
if (!Enum.IsDefined(typeof(InstatnceStates), instance.State))
{
instance.State = InstatnceStates.Unknown;
}
result.Add(instance);
}
return(result.OrderBy(a => a.Name).ToList());
}
catch (AmazonEC2Exception ex)
{
string message = ex.Message + "\r\n" +
"Response Status Code: " + ex.StatusCode + "\r\n" +
"Error Code: " + ex.ErrorCode + "\r\n" +
"Error Type: " + ex.ErrorType + "\r\n" +
"Request ID: " + ex.RequestId;
throw new AmazonEC2Exception(message, ex);
}
}
private void TerminateInstance(AwsRegionLocations region, string instanceId)
{
var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, region.ToAwsRegionEndpoint()));
var deleteRequest = new TerminateInstancesRequest()
{
InstanceIds = new List <string>()
{
instanceId
}
};
client.TerminateInstances(deleteRequest);
}
public EnvService()
{
_amazonEC2Config = new AmazonEC2Config()
{
RegionEndpoint = RegionEndpoint.USWest2
};
_ids = new List <string>()
{
"i-10f40d1e"
};
_ec2 = AWSClientFactory.CreateAmazonEC2Client(_amazonEC2Config);
}
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);
}
private void Initialize(RegionEndpoint regionEndpoint, string AWSAcessKey, string AWSSecretKey)
{
// Set configuration info
AmazonEC2Config config = new AmazonEC2Config();
config.Timeout = new TimeSpan(1, 0, 0);
config.ReadWriteTimeout = new TimeSpan(1, 0, 0);
config.RegionEndpoint = regionEndpoint;
// Create EC2 client
EC2client = AWSClientFactory.CreateAmazonEC2Client(
AWSAcessKey,
AWSSecretKey,
config);
}
public override bool Execute()
{
using (var ec2Client = AWSClientFactory.CreateAmazonEC2Client(
AwsAccessKey, AwsSecretKey, new AmazonEC2Config().WithServiceURL("https://eu-west-1.ec2.amazonaws.com")))
{
ec2Client.TerminateInstances(new TerminateInstancesRequest().WithInstanceId(InstanceId));
if (WaitForMachineToTerminate)
{
while (IsInstanceShuttingDown(ec2Client, InstanceId))
{
;
}
}
return(true);
}
}
private static void StopInstance()
{
try
{
AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(_awsKey, _awsSecretKey);
StopInstancesRequest request = new StopInstancesRequest();
request.WithInstanceId(new string[] { _instanceId });
ec2.StopInstances(request);
Mail(string.Format("Successfully stopped EC2 instance {0}", _instanceId));
}
catch (Exception e)
{
MailError("Error stopping instance", e);
}
}
public static void GetTopology()
{
IAmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client();
IAmazonAutoScaling asg = AWSClientFactory.CreateAmazonAutoScalingClient();
IAmazonElasticLoadBalancing elb = AWSClientFactory.CreateAmazonElasticLoadBalancingClient();
DescribeVpcsResponse vpcResponse = ec2.DescribeVpcs();
WriteFile("vpcs.csv", vpcResponse.Vpcs);
DescribeInstancesResponse instanceResponse = ec2.DescribeInstances();
var reservationIndex = 0;
foreach (var reservation in instanceResponse.Reservations)
{
if (reservationIndex == 0)
{
WriteFile("instances.csv", reservation.Instances);
}
else
{
AppendFile("instances.csv", reservation.Instances);
}
reservationIndex++;
}
DescribeNetworkAclsResponse naclResponse = ec2.DescribeNetworkAcls();
WriteFile("nacls.csv", naclResponse.NetworkAcls);
Amazon.EC2.Model.DescribeTagsResponse tagsResponse = ec2.DescribeTags();
WriteFile("tags.csv", tagsResponse.Tags);
DescribeVolumesResponse volumesResponse = ec2.DescribeVolumes();
WriteFile("volumes.csv", volumesResponse.Volumes);
DescribeLoadBalancersResponse elbResponse = elb.DescribeLoadBalancers();
WriteFile("elbs.csv", elbResponse.LoadBalancerDescriptions);
DescribeInternetGatewaysResponse igResponse = ec2.DescribeInternetGateways();
WriteFile("igs.csv", igResponse.InternetGateways);
}
public ControlGUI()
{
InitializeComponent();
//get config and start a client
this.EC2 = AWSClientFactory.CreateAmazonEC2Client();
this.GetStatus(true);
Configuration configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
bool shouldWatch = Boolean.Parse(configuration.AppSettings.Settings["ShouldWeMonitor"].Value);
if (shouldWatch)
{
System.Timers.Timer watcher = new System.Timers.Timer(600000);
watcher.Elapsed += new System.Timers.ElapsedEventHandler(WatchTheServer);
watcher.Interval = 1000;
watcher.Enabled = true;
}
}
static void GetInstances(AWSCredentials credentials)
{
IAmazonEC2 client = AWSClientFactory.CreateAmazonEC2Client(credentials, RegionEndpoint.USEast1);
DescribeInstancesRequest request = new DescribeInstancesRequest();
request.Filters.Add(new Filter("instance-state-code", new List <string>()
{
"0", "16"
}));
DescribeInstancesResponse describeInstancesResponse = client.DescribeInstances();
List <Reservation> reservations = describeInstancesResponse.Reservations;
foreach (Instance instance in reservations.SelectMany(x => x.Instances))
{
Console.WriteLine("Instance with ID {0} is currently {1}", instance.InstanceId, instance.State.Name);
}
}
void worker_DoWork(object sender, DoWorkEventArgs e)
{
//validate args
if (String.IsNullOrEmpty(AWSAccessKey) || String.IsNullOrEmpty(AWSSecretKey))
{
e.Result = null;
return;
}
//ec2 client
var ec2 = AWSClientFactory.CreateAmazonEC2Client(AWSAccessKey,
AWSSecretKey,
new AmazonEC2Config().WithServiceURL(RegionHelper.EC2EndpointForRegion(EC2Region))
);
var elbClient = AWSClientFactory.CreateAmazonElasticLoadBalancingClient(AWSAccessKey,
AWSSecretKey,
new AmazonElasticLoadBalancingConfig()
{
ServiceURL = RegionHelper.ELBEndpointForRegion(EC2Region).Replace("http:", "https:")
});
DescribeLoadBalancersResponse loadBalancers = null;
try
{
loadBalancers = elbClient.DescribeLoadBalancers();
}
catch (WebException wex)
{
var response = wex.Response as HttpWebResponse;
var responsveBody = new StreamReader(response.GetResponseStream()).ReadToEnd();
int a = 5;
}
e.Result = loadBalancers.DescribeLoadBalancersResult.LoadBalancerDescriptions.
Select(lb => new AWSLoadBalancerServersRetreiverCompleteEventArgs.LoadBalancer {
LoadBalancerName = lb.LoadBalancerName,
InstanceNames = lb.Instances.Select(instance => instance.InstanceId).ToList()
}).
ToList();
}
private static Volume GetInstanceVolumes(AWSEnvironment environment, RegionEndpoint region, InstanceBlockDeviceMapping blockDevice)
{
try
{
var ec2Client = AWSClientFactory.CreateAmazonEC2Client(environment.AccessKeyID, environment.SecretAccessKey, region);
var regionVolumes = ec2Client.DescribeVolumes();
foreach (var ec2Volume in regionVolumes.Volumes)
{
if (ec2Volume.State == VolumeState.InUse && ec2Volume.VolumeId == blockDevice.Ebs.VolumeId)
{
return(ec2Volume);
}
}
}
catch (AmazonEC2Exception aex)
{
Logger.Log(LogLevel.Error, aex, $"AmazonEC2Exception in GetInstanceVolumes() : {aex.Message}");
}
return(null);
}
