public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonEC2Config config = new AmazonEC2Config();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonEC2Client client = new AmazonEC2Client(creds, config);
DescribeSecurityGroupsResponse resp = new DescribeSecurityGroupsResponse();
do
{
DescribeSecurityGroupsRequest req = new DescribeSecurityGroupsRequest
{
NextToken = resp.NextToken
,
MaxResults = maxItems
};
resp = client.DescribeSecurityGroups(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.SecurityGroups)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.NextToken));
}
public List <string> descrbibeSecurityGroups()
{
List <string> secGroups = new List <string>();
try
{
DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest();
DescribeSecurityGroupsResponse response = _service.DescribeSecurityGroups(request);
if (response.IsSetDescribeSecurityGroupsResult())
{
DescribeSecurityGroupsResult describeSecurityGroupsResult = response.DescribeSecurityGroupsResult;
List <SecurityGroup> securityGroupList = describeSecurityGroupsResult.SecurityGroup;
foreach (SecurityGroup securityGroup in securityGroupList)
{
if (securityGroup.IsSetGroupName())
{
secGroups.Add(securityGroup.GroupName);
}
}
}
}
catch (AmazonEC2Exception ex)
{
throw new Exception("Caught Exception: " + ex.XML);
}
return(secGroups);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
DescribeSecurityGroupsResponse response = new DescribeSecurityGroupsResponse();
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth = 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("securityGroupInfo/item", targetDepth))
{
var unmarshaller = SecurityGroupUnmarshaller.Instance;
var item = unmarshaller.Unmarshall(context);
response.SecurityGroups.Add(item);
continue;
}
}
}
return(response);
}
public async Task <SecurityGroup[]> DescribeSecurityGroupsAsync(List <string> groupIds = null, List <string> groupNames = null, Dictionary <string, List <string> > filters = null, CancellationToken cancellationToken = default(CancellationToken))
{
var filterList = filters?.Select(x => new Filter(x.Key, x.Value)).ToList();
DescribeSecurityGroupsResponse response = null;
var results = new List <SecurityGroup>();
while ((response = await _client.DescribeSecurityGroupsAsync(new DescribeSecurityGroupsRequest()
{
NextToken = response?.NextToken,
Filters = filterList,
MaxResults = 1000,
GroupIds = groupIds,
GroupNames = groupNames
}, cancellationToken).EnsureSuccessAsync()) != null)
{
if (!response.SecurityGroups.IsNullOrEmpty())
{
results.AddRange(response.SecurityGroups);
}
if (response.NextToken.IsNullOrEmpty())
{
break;
}
await Task.Delay(100);
}
return(results.ToArray());
}
private DescribeSecurityGroupsResponse GetSecurityGroups()
{
DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest();
DescribeSecurityGroupsResponse resp = ec2.DescribeSecurityGroups(request);
return(resp);
}
// #############################################################################################
SecurityGroup CreateSecurityGroup(IAmazonEC2 ec2, string secGroupName, string vpc)
{
SecurityGroup MySG;
Amazon.EC2.Model.Filter nameFilter = new Amazon.EC2.Model.Filter();
nameFilter.Name = "group-name";
nameFilter.Values = new List <string>()
{
secGroupName
};
var describeRequest = new DescribeSecurityGroupsRequest();
describeRequest.Filters.Add(nameFilter);
var describeResponse = new DescribeSecurityGroupsResponse();
describeResponse = ec2.DescribeSecurityGroups(describeRequest);
if (describeResponse.SecurityGroups.Count > 0)
{
//return describeResponse.SecurityGroups[0];
MySG = describeResponse.SecurityGroups[0];
MySG = AddSGIPrermissions(ec2, MySG);
return(MySG);
}
var createRequest = new CreateSecurityGroupRequest();
createRequest.GroupName = secGroupName;
createRequest.VpcId = vpc;
createRequest.Description = "My sample security group for EC2-Classic";
var createResponse = new CreateSecurityGroupResponse();
//createResponse = CreateSecurityGroupResponse(createRequest);
var Groups = new List <string>()
{
createResponse.GroupId
};
createResponse = ec2.CreateSecurityGroup(createRequest);
MySG = new SecurityGroup();
MySG.GroupId = createResponse.GroupId;
MySG.VpcId = vpc;
MySG = AddSGIPrermissions(ec2, MySG);
return(MySG);
// ec2.des
}
public List <SecurityGroup> GetSecurityGroups(IEnumerable <string> groupIds)
{
List <string> groupIdsList = groupIds.AsList();
var request = new DescribeSecurityGroupsRequest {
GroupIds = groupIdsList.Distinct().ToList()
};
DescribeSecurityGroupsResponse response = _ec2Client.DescribeSecurityGroups(request);
Dictionary <string, SecurityGroup> groupsBySgId = response.SecurityGroups.ToDictionary(sg => sg.GroupId);
return(groupIdsList.Where(groupsBySgId.ContainsKey).Select(x => groupsBySgId[x]).ToList());
}
static DescribeSecurityGroupsResponse GetSecurityGroup(AmazonEC2Client ec2Client, DescribeSecurityGroupsRequest request)
{
DescribeSecurityGroupsResponse sg = null;
try
{
sg = ec2Client.DescribeSecurityGroups(request);
}
catch (Exception)
{
}
return(sg);
}
public List <DescribeSecurityGroupModel> MapForDescribe(DescribeSecurityGroupsResponse describeSecurityGroupsResponse)
{
var model = new List <DescribeSecurityGroupModel>();
foreach (var securityGroup in describeSecurityGroupsResponse.SecurityGroups)
{
model.Add(new DescribeSecurityGroupModel()
{
SecurityGroupId = securityGroup.GroupId
});
}
return(model);
}
public async Task <List <SecurityGroup> > DescribeSecurityGroups()
{
DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest();
DescribeSecurityGroupsResponse response = await _ec2Client.DescribeSecurityGroupsAsync();
List <SecurityGroup> securityGroups = new List <SecurityGroup>();
foreach (var securityGroup in response.SecurityGroups)
{
securityGroups.Add(new SecurityGroup(securityGroup.GroupName, securityGroup.GroupId, securityGroup.Description, securityGroup.OwnerId, securityGroup.VpcId));
}
return(securityGroups);
}
public static DescribeSecurityGroupsResponse Unmarshall(UnmarshallerContext _ctx)
{
DescribeSecurityGroupsResponse describeSecurityGroupsResponse = new DescribeSecurityGroupsResponse();
describeSecurityGroupsResponse.HttpResponse = _ctx.HttpResponse;
describeSecurityGroupsResponse.RequestId = _ctx.StringValue("DescribeSecurityGroups.RequestId");
List <string> describeSecurityGroupsResponse_securityGroupIds = new List <string>();
for (int i = 0; i < _ctx.Length("DescribeSecurityGroups.SecurityGroupIds.Length"); i++)
{
describeSecurityGroupsResponse_securityGroupIds.Add(_ctx.StringValue("DescribeSecurityGroups.SecurityGroupIds[" + i + "]"));
}
describeSecurityGroupsResponse.SecurityGroupIds = describeSecurityGroupsResponse_securityGroupIds;
return(describeSecurityGroupsResponse);
}
public static DescribeSecurityGroupsResponse Unmarshall(UnmarshallerContext _ctx)
{
DescribeSecurityGroupsResponse describeSecurityGroupsResponse = new DescribeSecurityGroupsResponse();
describeSecurityGroupsResponse.HttpResponse = _ctx.HttpResponse;
describeSecurityGroupsResponse.RequestId = _ctx.StringValue("DescribeSecurityGroups.RequestId");
describeSecurityGroupsResponse.RegionId = _ctx.StringValue("DescribeSecurityGroups.RegionId");
describeSecurityGroupsResponse.TotalCount = _ctx.IntegerValue("DescribeSecurityGroups.TotalCount");
describeSecurityGroupsResponse.PageNumber = _ctx.IntegerValue("DescribeSecurityGroups.PageNumber");
describeSecurityGroupsResponse.PageSize = _ctx.IntegerValue("DescribeSecurityGroups.PageSize");
List <DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup> describeSecurityGroupsResponse_securityGroups = new List <DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup>();
for (int i = 0; i < _ctx.Length("DescribeSecurityGroups.SecurityGroups.Length"); i++)
{
DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup securityGroup = new DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup();
securityGroup.SecurityGroupId = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].SecurityGroupId");
securityGroup.Description = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].Description");
securityGroup.SecurityGroupName = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].SecurityGroupName");
securityGroup.VpcId = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].VpcId");
securityGroup.CreationTime = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].CreationTime");
securityGroup.SecurityGroupType = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].SecurityGroupType");
securityGroup.AvailableInstanceAmount = _ctx.IntegerValue("DescribeSecurityGroups.SecurityGroups[" + i + "].AvailableInstanceAmount");
securityGroup.EcsCount = _ctx.IntegerValue("DescribeSecurityGroups.SecurityGroups[" + i + "].EcsCount");
securityGroup.ResourceGroupId = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].ResourceGroupId");
securityGroup.ServiceID = _ctx.LongValue("DescribeSecurityGroups.SecurityGroups[" + i + "].ServiceID");
securityGroup.ServiceManaged = _ctx.BooleanValue("DescribeSecurityGroups.SecurityGroups[" + i + "].ServiceManaged");
List <DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup.DescribeSecurityGroups_Tag> securityGroup_tags = new List <DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup.DescribeSecurityGroups_Tag>();
for (int j = 0; j < _ctx.Length("DescribeSecurityGroups.SecurityGroups[" + i + "].Tags.Length"); j++)
{
DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup.DescribeSecurityGroups_Tag tag = new DescribeSecurityGroupsResponse.DescribeSecurityGroups_SecurityGroup.DescribeSecurityGroups_Tag();
tag.TagKey = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].Tags[" + j + "].TagKey");
tag.TagValue = _ctx.StringValue("DescribeSecurityGroups.SecurityGroups[" + i + "].Tags[" + j + "].TagValue");
securityGroup_tags.Add(tag);
}
securityGroup.Tags = securityGroup_tags;
describeSecurityGroupsResponse_securityGroups.Add(securityGroup);
}
describeSecurityGroupsResponse.SecurityGroups = describeSecurityGroupsResponse_securityGroups;
return(describeSecurityGroupsResponse);
}
public SecurityGroup GetSecurityGroup(string groupName, string vpcId)
{
/* Do not try to initialize GroupNames in the describe request and expect AWS to do server side filtering.
*
* If you do, and the security group doesn't exist, the SDK throws an AmazonEC2Exception with the message
* "the security group {groupName} does not exist." or something similar.
*
* If you do, and the security group *does* exist, the SDK throws an AmazonEC2Exception with the message
* "GroupName is not allowed in this operation. Use the GroupId instead." or something similar.
*
* It stinks, but that's why the filtering is done on the client side. If you try to fix this and fail,
* increment this counter: 1
*/
var request = new DescribeSecurityGroupsRequest();
DescribeSecurityGroupsResponse response = _ec2Client.DescribeSecurityGroups(request);
return(response.SecurityGroups.SingleOrDefault(x => x.VpcId == vpcId && x.GroupName == groupName));
}
//private ListStackResourcesResponse ListStackResources(string stackName, AmazonCloudFormationClient cfClient, string nextToken = null)
//{
// ListStackResourcesRequest lr = new ListStackResourcesRequest();
// lr.StackName = stackName;
// lr.NextToken = nextToken;
// ListStackResourcesResponse liveStackResources = cfClient.ListStackResources(lr);
// return liveStackResources;
//}
private void ProcessLiveStack(string stackName, AmazonCloudFormationClient cfClient, AmazonEC2Client ec2Client, RichTextBox rtb, CFStack stack)
{
Dictionary <string, string> secGroupMap = new Dictionary <string, string>();
DescribeSecurityGroupsRequest secGroupRequestAll = new DescribeSecurityGroupsRequest();
//Get all security group Id's and cf logicalId's (if any)
DescribeSecurityGroupsResponse secGroupResponseAll = ec2Client.DescribeSecurityGroups(secGroupRequestAll);
foreach (SecurityGroup sg in secGroupResponseAll.SecurityGroups)
{
string value = "none";
foreach (Amazon.EC2.Model.Tag tag in sg.Tags)
{
if (tag.Key.Contains("aws:cloudformation:logical-id"))
{
value = tag.Value;
}
}
secGroupMap.Add(sg.GroupId, value);
}
//Get Live Stack
DescribeStacksRequest cfRequest = new DescribeStacksRequest();
cfRequest.StackName = stackName;
DescribeStacksResponse liveStack = cfClient.DescribeStacks(cfRequest);
stack.Description = liveStack.Stacks[0].Description;
//Get Stack Resouces
//Need to use ListStackResourcesRequest to be able to get stacks with more than 100 resources
ListStackResourcesRequest lr = new ListStackResourcesRequest();
lr.StackName = stackName;
ListStackResourcesResponse liveStackResources = cfClient.ListStackResources(lr);
ProcessLiveStackResourcess(liveStackResources, stack, ec2Client, secGroupMap, stackName, cfClient);
stack.Resources.Sort((a, b) => a.LogicalId.CompareTo(b.LogicalId));
WriteOutput(stack, rtb, source1_CB.Text, templateOrStack1_TB.Text);
}
public static DescribeSecurityGroupsResponse Unmarshall(UnmarshallerContext context)
{
DescribeSecurityGroupsResponse describeSecurityGroupsResponse = new DescribeSecurityGroupsResponse()
{
HttpResponse = context.HttpResponse,
RequestId = context.StringValue("DescribeSecurityGroups.RequestId"),
RegionId = context.StringValue("DescribeSecurityGroups.RegionId"),
TotalCount = context.IntegerValue("DescribeSecurityGroups.TotalCount"),
PageNumber = context.IntegerValue("DescribeSecurityGroups.PageNumber"),
PageSize = context.IntegerValue("DescribeSecurityGroups.PageSize")
};
List <DescribeSecurityGroupsResponse.SecurityGroup> securityGroups = new List <DescribeSecurityGroupsResponse.SecurityGroup>();
for (int i = 0; i < context.Length("DescribeSecurityGroups.SecurityGroups.Length"); i++)
{
DescribeSecurityGroupsResponse.SecurityGroup securityGroup = new DescribeSecurityGroupsResponse.SecurityGroup()
{
SecurityGroupId = context.StringValue($"DescribeSecurityGroups.SecurityGroups[{i}].SecurityGroupId"),
Description = context.StringValue($"DescribeSecurityGroups.SecurityGroups[{i}].Description"),
SecurityGroupName = context.StringValue($"DescribeSecurityGroups.SecurityGroups[{i}].SecurityGroupName"),
VpcId = context.StringValue($"DescribeSecurityGroups.SecurityGroups[{i}].VpcId"),
CreationTime = context.StringValue($"DescribeSecurityGroups.SecurityGroups[{i}].CreationTime"),
EcsCount = context.IntegerValue($"DescribeSecurityGroups.SecurityGroups[{i}].EcsCount")
};
List <DescribeSecurityGroupsResponse.SecurityGroup.Tag> tags = new List <DescribeSecurityGroupsResponse.SecurityGroup.Tag>();
for (int j = 0; j < context.Length($"DescribeSecurityGroups.SecurityGroups[{i}].Tags.Length"); j++)
{
DescribeSecurityGroupsResponse.SecurityGroup.Tag tag = new DescribeSecurityGroupsResponse.SecurityGroup.Tag()
{
TagKey = context.StringValue($"DescribeSecurityGroups.SecurityGroups[{i}].Tags[{j}].TagKey"),
TagValue = context.StringValue($"DescribeSecurityGroups.SecurityGroups[{i}].Tags[{j}].TagValue")
};
tags.Add(tag);
}
securityGroup.Tags = tags;
securityGroups.Add(securityGroup);
}
describeSecurityGroupsResponse.SecurityGroups = securityGroups;
return(describeSecurityGroupsResponse);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
DescribeSecurityGroupsResponse response = new DescribeSecurityGroupsResponse();
int targetDepth = 2;
while (context.Read())
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("securityGroupInfo/item", targetDepth))
{
response.SecurityGroups.Add(SecurityGroupUnmarshaller.GetInstance().Unmarshall(context));
continue;
}
}
}
return(response);
}
internal void LaunchServer(ref bool actionSucceeded, ref string actionMessage)
{
try
{
string keyPairPath = string.Empty;
LaunchRequest.KeyPairName = $"KeyPair-{Guid.NewGuid().ToString()}";
while (!CreateKeyPair(LaunchRequest.KeyPairName, ref keyPairPath))
{
LaunchRequest.KeyPairName = Guid.NewGuid().ToString();
}
DescribeVpcsRequest vpcRequest = new DescribeVpcsRequest();
DescribeVpcsResponse vpcResponse = Ec2Client.DescribeVpcsAsync(vpcRequest).GetAwaiter().GetResult();
Vpc defaultVPC = vpcResponse.Vpcs.Find(x => x.IsDefault); //get the default vpc
List <Filter> subnetFilter = new List <Filter>()
{
new Filter()
{
Name = "availability-zone", Values = new List <string>()
{
LaunchRequest.AvailabilityZone
}
},
new Filter()
{
Name = "vpc-id", Values = new List <string>()
{
defaultVPC.VpcId
}
}
};
DescribeSubnetsRequest subnetRequest = new DescribeSubnetsRequest();
subnetRequest.Filters = subnetFilter;
DescribeSubnetsResponse subnetResponse = Ec2Client.DescribeSubnetsAsync(subnetRequest).GetAwaiter().GetResult();
Subnet defaultSubnet = subnetResponse.Subnets.FirstOrDefault();
Filter SGFilter = new Filter
{
Name = "vpc-id",
Values = new List <string>()
{
defaultVPC.VpcId
}
};
DescribeSecurityGroupsRequest SGrequest = new DescribeSecurityGroupsRequest();
SGrequest.Filters.Add(SGFilter);
DescribeSecurityGroupsResponse SGresponse = Ec2Client.DescribeSecurityGroupsAsync(SGrequest).GetAwaiter().GetResult();
SecurityGroup defaultSG = SGresponse.SecurityGroups.FirstOrDefault();
InstanceNetworkInterfaceSpecification defaultENI = new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = defaultSubnet.SubnetId,
Groups = new List <string>()
{
defaultSG.GroupId
},
AssociatePublicIpAddress = true
};
List <InstanceNetworkInterfaceSpecification> enis = new List <InstanceNetworkInterfaceSpecification>()
{
defaultENI
};
EbsBlockDevice ebsBlockDevice = new EbsBlockDevice
{
VolumeSize = 10,
VolumeType = GetActualStorageType(LaunchRequest.StorageType)
};
BlockDeviceMapping blockDeviceMapping = new BlockDeviceMapping
{
DeviceName = "/dev/xvda"
};
blockDeviceMapping.Ebs = ebsBlockDevice;
var launchRequest = new RunInstancesRequest()
{
ImageId = GetImageID(LaunchRequest.AMIType),
InstanceType = GetActualInstanceType(LaunchRequest.InstanceType),
MinCount = LaunchRequest.NumOfInstances,
MaxCount = LaunchRequest.NumOfInstances,
KeyName = LaunchRequest.KeyPairName,
Placement = new Placement(LaunchRequest.AvailabilityZone),
NetworkInterfaces = enis,
BlockDeviceMappings = new List <BlockDeviceMapping>()
{
blockDeviceMapping
}
};
RunInstancesResponse launchResponse = Ec2Client.RunInstancesAsync(launchRequest).GetAwaiter().GetResult();
List <String> instanceIds = new List <string>();
foreach (Instance instance in launchResponse.Reservation.Instances)
{
Console.WriteLine(instance.InstanceId);
instanceIds.Add(instance.InstanceId);
}
actionSucceeded = true;
actionMessage = $"The instance(s) are being launched. Please check the AWS Console to verify. {keyPairPath}";
}
catch (Exception ex)
{
context.Logger.LogLine($"ServerOperationsHelper::LaunchServer {ex.Message}");
context.Logger.LogLine($"ServerOperationsHelper::LaunchServer {ex.StackTrace}");
actionSucceeded = false;
actionMessage = $"Could not launch the server . Please contact your administrator.";
}
}
public static void ProcessEC2SecurityGroupFromAWS(StackResourceSummary resource, CFStack stack, AmazonEC2Client ec2Client, Dictionary <string, string> secGroupMap, string stackName)
{
DescribeSecurityGroupsRequest secGroupRequest = new DescribeSecurityGroupsRequest();
//Set request to use Phisical Id
secGroupRequest.GroupIds = new List <string> {
resource.PhysicalResourceId
};
//Attempt to get security group using physical Id
DescribeSecurityGroupsResponse response = GetSecurityGroup(ec2Client, secGroupRequest);
if (response == null)
{
//Set request to use Logical Id and Stack Name Tags
secGroupRequest.GroupIds.Clear();
List <Filter> f = new List <Filter>();
f.Add(new Filter {
Name = "tag:aws:cloudformation:logical-id", Values = new List <string>()
{
resource.LogicalResourceId
}
});
f.Add(new Filter {
Name = "tag:aws:cloudformation:stack-name", Values = new List <string>()
{
stackName
}
});
secGroupRequest.Filters = f;
//Attempt to get security group using logical Id
response = GetSecurityGroup(ec2Client, secGroupRequest);
}
if (response == null | response.SecurityGroups.Count == 0)
{
return;
}
foreach (SecurityGroup group in response.SecurityGroups)
{
EC2SecurityGroup sg = new EC2SecurityGroup();
sg.LogicalId = resource.LogicalResourceId;
if (log)
{
Utils.WriteToFile(logFile, "AWS SG: " + sg.LogicalId.ToString(), true);
}
sg.Type = "AWS::EC2::SecurityGroup";
sg.Properties.GroupDescription = group.Description;
sg.Properties.VpcId = group.VpcId;
foreach (IpPermission perms in group.IpPermissions)
{
for (int i = 0; i < perms.IpRanges.Count; i++)
{
EC2SecurityGroupIngress sgi = new EC2SecurityGroupIngress();
//FormatProtocol - Protocol could be a number or text (e.g. 6 or tcp)
sgi.IpProtocol = FormatProtocol(perms.IpProtocol);
//--------------------------------------------------------------------
//FormatPortRange - Port range could be 0-0 -1-1 0-65535
string from = "";
string to = "";
FormatPortRange(perms.FromPort.ToString(), perms.ToPort.ToString(), out from, out to);
sgi.FromPort = from;
sgi.ToPort = to;
//------------------------------------------------------
sgi.CidrIp = perms.IpRanges[i];
sg.Properties.SecurityGroupIngress.Add(sgi);
if (log)
{
Utils.WriteToFile(logFile, " Protocol: " + perms.IpProtocol + " | From: " + perms.FromPort.ToString() + " To: " + perms.ToPort.ToString(), true);
}
}
for (int i = 0; i < perms.UserIdGroupPairs.Count; i++)
{
EC2SecurityGroupIngress sgi = new EC2SecurityGroupIngress();
//FormatProtocol - Protocol could be a number or text (e.g. 6 or tcp)
sgi.IpProtocol = FormatProtocol(perms.IpProtocol);
//--------------------------------------------------------------------
//FormatPortRange - Port range could be 0-0 -1-1 0-65535
string from = "";
string to = "";
FormatPortRange(perms.FromPort.ToString(), perms.ToPort.ToString(), out from, out to);
sgi.FromPort = from;
sgi.ToPort = to;
//-------------------------------------------------------
sg.Properties.SecurityGroupIngress.Add(sgi);
string groupName;
if (secGroupMap.TryGetValue(perms.UserIdGroupPairs[i].GroupId, out groupName))
{
sgi.SourceSecurityGroupId = groupName;
}
else
{
sgi.SourceSecurityGroupId = perms.UserIdGroupPairs[i].GroupId;
}
if (log)
{
Utils.WriteToFile(logFile, " Protocol: " + perms.IpProtocol + " | From: " + perms.FromPort.ToString() + " To: " + perms.ToPort.ToString(), true);
}
}
}
stack.Resources.Add(sg);
}
}
void MonitorFunction()
{
Thread.CurrentThread.Name = "MonitorThread";
Program.TraceLine("Monitoring thread started...");
Program.MonitorMessage = "Monitor starting...";
while (true)
{
try
{
//TEST ZONE
{
}
//Now continues normally
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeInstancesResponse respEc2 = GetRunningInstances();
UpdateClassOfObjects(currentStatusEc2, respEc2.DescribeInstancesResult.Reservation);
Program.MonitorMessage = "Updated EC2s...";
foreach (ZAwsEc2 ec2Instance in CurrentEc2s)
{
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
ec2Instance.UpdateInfo();
Program.MonitorMessage = "Updated EC2 " + ec2Instance.Name;
}
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeAddressesResponse respElasitIp = GetElasticIps();
UpdateClassOfObjects(currentStatusElIps, respElasitIp.DescribeAddressesResult.Address);
Program.MonitorMessage = "Updated elastic IPs";
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
ListHostedZonesResponse route53Zones = GetHostedZones();
UpdateClassOfObjects(currentHostedZones, route53Zones.ListHostedZonesResult.HostedZones);
Program.MonitorMessage = "Updated hosted zones...";
foreach (ZAwsHostedZone zone in CurrentHostedZones)
{
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
zone.UpdateInfo();
Program.MonitorMessage = "Updated zone " + zone.Name;
}
/*
* We will not be checking S3 service, because that actually costs money!
* lock (Ec2Lock) { if (!RunMonitoring) { return; } }
* ListBucketsResponse s3Buckects = GetBuckets();
* UpdateClassOfObjects(currentS3Buckets, s3Buckects.Buckets);
* Program.MonitorMessage = "Updated S3 Buckets...";
* */
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeSnapshotsResponse respEc2Snapshots = GetSnapshots();
UpdateClassOfObjects(currentSnapshots, respEc2Snapshots.DescribeSnapshotsResult.Snapshot);
Program.MonitorMessage = "Updated EC2 Snapshots...";
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeKeyPairsResponse respKeyPairs = GetKeyPairs();
UpdateClassOfObjects(currentKeyPairs, respKeyPairs.DescribeKeyPairsResult.KeyPair);
Program.MonitorMessage = "Updated KeyPairs...";
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeSecurityGroupsResponse respSecGroups = GetSecurityGroups();
UpdateClassOfObjects(currentSecGroups, respSecGroups.DescribeSecurityGroupsResult.SecurityGroup);
Program.MonitorMessage = "Updated Sec Groups...";
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeImagesResponse respAmis = GetAmis();
UpdateClassOfObjects(currentAmis, respAmis.DescribeImagesResult.Image);
Program.MonitorMessage = "Updated AMIs...";
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeVolumesResponse respEbsVolumes = GetEbsVolumes();
UpdateClassOfObjects(currentEbsVolumes, respEbsVolumes.DescribeVolumesResult.Volume);
Program.MonitorMessage = "Updated EBS volumes...";
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
DescribeSpotInstanceRequestsResponse respSpotRequests = GetSpotRequests();
UpdateClassOfObjects(currentSpotRequests, respSpotRequests.DescribeSpotInstanceRequestsResult.SpotInstanceRequest);
Program.MonitorMessage = "Updated spot requests...";
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
if (ThreadInRecovery)
{
Program.TraceLine("Monitoring working fine again...");
ThreadInRecovery = false;
}
}
catch (Exception ex)
{
Program.TraceLine("Monitoring thread encountered an error. Will restart in {0}...", ex, ThreadInRecovery ? "1 minute" : "5 seconds");
Program.MonitorMessage = "Monitor paused...";
for (int i = 0; i < (ThreadInRecovery ? 600 : 50); i++)
{
lock (Ec2Lock) { if (!RunMonitoring)
{
return;
}
}
Thread.Sleep(100);
}
Program.TraceLine("Monitoring thread trying to recover...");
Program.MonitorMessage = "Monitor restarting...";
ThreadInRecovery = true;
}
finally
{
if (!RunMonitoring)
{
Program.MonitorMessage = "Monitor stopped.";
}
}
}
}
