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);
}
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 void EnumerateSecurityGroups()
{
try
{
var sharedFile = new SharedCredentialsFile();
if (sharedFile.TryGetProfile("basic_profile", out basicProfile) &&
AWSCredentialsFactory.TryGetAWSCredentials(basicProfile, sharedFile, out awsCredentials))
{
AmazonEC2Client amazonEC2 = new AmazonEC2Client(awsCredentials, basicProfile.Region);
var request = new DescribeSecurityGroupsRequest();
var response = amazonEC2.DescribeSecurityGroups(request);
//Json.Write(response, writer);
var jsonResponse = JsonConvert.SerializeObject(response);
List <SecurityGroup> securityGroup = response.SecurityGroups;
List <SecurityGroup> outSecurityGroup = new List <SecurityGroup>();
foreach (var item in securityGroup)
{
outSecurityGroup.Add(item);
}
outSecurityGroup.RemoveRange(0, 2);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message + ex.StackTrace);
}
}
public SecurityGroup GetSecurityGroup()
{
var dsgRequest = new DescribeSecurityGroupsRequest();
var dsgResponse = EC2Client.DescribeSecurityGroups(dsgRequest);
return(dsgResponse.SecurityGroups.FirstOrDefault(sg => sg.GroupName == Configuration.SecurityGroupName)); //look up group by name
}
public async Task <DescribeSecurityGroupsResponse> DescribeSecurityGroupsAsync()
{
var request = new DescribeSecurityGroupsRequest();
var response = await _cloudComputeClient.DescribeSecurityGroupsAsync(request);
return(response);
}
private async Task <SecurityGroup> SecurityGroupExists()
{
var request = new DescribeSecurityGroupsRequest();
var response = await _client.DescribeSecurityGroupsAsync(request);
return(response.SecurityGroups.FirstOrDefault(criteria => criteria.GroupName == _groupName));
}
public async Task <SecurityGroup> CreateSecurityGroupAsync(string secGroupName)
{
try
{
var newSGrequest = new CreateSecurityGroupRequest
{
GroupName = secGroupName,
Description = "My sample security group for EC2-Classic"
};
var response = await amazonEC2Client.CreateSecurityGroupAsync(newSGrequest);
List <string> GroupId = new List <string>()
{
response.GroupId
};
DescribeSecurityGroupsRequest securityGroupsRequest = new DescribeSecurityGroupsRequest()
{
GroupIds = GroupId
};
var securityGroupsResponse = amazonEC2Client.DescribeSecurityGroupsAsync(securityGroupsRequest);
SecurityGroup securityGroup = securityGroupsResponse.Result.SecurityGroups[0];
return(securityGroup);
}
catch (Exception ex)
{
throw ex;
}
}
private DescribeSecurityGroupsResponse GetSecurityGroups()
{
DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest();
DescribeSecurityGroupsResponse resp = ec2.DescribeSecurityGroups(request);
return(resp);
}
private SecurityGroup GetSecurityGroup()
{
// Attempt to retrive the security group
var request = new DescribeSecurityGroupsRequest
{
Filters =
{
new Filter
{
Name = "group-name",
Values ={ securityGroupName }
},
new Filter
{
Name = "vpc-id",
Values ={ vpcId }
}
}
};
return(client
.DescribeSecurityGroups(request)
.SecurityGroups
.SingleOrDefault());
}
public List <SecurityGroup> SecurityGroupsAvaliable()
{
var request = new DescribeSecurityGroupsRequest();
var response = ec2Client.DescribeSecurityGroups(request);
List <SecurityGroup> mySGs = response.SecurityGroups;
return(mySGs);
}
public IEnumerable <SecurityGroup> GetSecurityGroups(Instance instance)
{
var securityGroupIds = instance.SecurityGroups.Select(x => x.GroupId);
var request = new DescribeSecurityGroupsRequest {
GroupIds = securityGroupIds.ToList()
};
var response = _ec2Client.DescribeSecurityGroups(request);
return(response.SecurityGroups);
}
// #############################################################################################
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
}
private static DescribeSecurityGroupsResponse DescribeSecurityGroups()
{
var describeSecurityGroupRequest = new DescribeSecurityGroupsRequest();
describeSecurityGroupRequest.GroupIds = new List <string> {
SECURITY_GROUP_ID
};
var describeSecurityGroupsResponse = Client.DescribeSecurityGroups(describeSecurityGroupRequest);
return(describeSecurityGroupsResponse);
}
private static DescribeSecurityGroupsResponse DescribeSecurityGroupById()
{
var describeSecurityGroupRequest = new DescribeSecurityGroupsRequest
{
GroupIds = new List <string> {
SECURITY_GROUP_ID
}
};
return(Client.DescribeSecurityGroups(describeSecurityGroupRequest));
}
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());
}
private async Task <List <String> > GetSecurityGroups()
{
var request = new DescribeSecurityGroupsRequest
{
GroupNames = { _cluster.Name }
};
var response = await _ec2client.DescribeSecurityGroupsAsync(request);
return(response.SecurityGroups
.Select(value => value.GroupId)
.ToList());
}
public static SecurityGroup GetSecurityGroup(string sgName, AmazonEC2Client client)
{
var request = new DescribeSecurityGroupsRequest();
var response = client.DescribeSecurityGroups(request);
List <SecurityGroup> mySGs = response.SecurityGroups;
var sg = mySGs.Find(x => x.GroupName.Equals(sgName));
//TODO: handle case where groupID not found. Find returns a default type (SecurityGroup) if not found.
Console.WriteLine("Found security group name equal to {0}. (ID: {1})", sg.GroupName, sg.GroupId);
return(sg);
}
public SecurityGroup CreateSecurityGroup()
{
//Setup a new security group
var newSGRequest = new CreateSecurityGroupRequest()
{
GroupName = Configuration.SecurityGroupName,
Description = Configuration.SecurityGroupDescription,
VpcId = Configuration.VpcId
};
var csgResponse = EC2Client.CreateSecurityGroup(newSGRequest);
Console.WriteLine("Created new security group: " + csgResponse.GroupId);
//Get the new security group
var newSgRequest = new DescribeSecurityGroupsRequest()
{
GroupIds = new[] { csgResponse.GroupId }.ToList()
};
var newSgResponse = EC2Client.DescribeSecurityGroups(newSgRequest);
var securityGroup = newSgResponse.SecurityGroups[0];
//Setup permissions for the security group
var ipRanges = Configuration.SecurityGroupIpRanges.Split(',').ToList();
var permissions = Configuration.SecurityGroupIpPermissions.Split(',');
var ipPermissions = permissions.Select(p =>
{
var protocol = p.Substring(0, 3);
var port = int.Parse(p.Substring(3));
return(new IpPermission()
{
IpProtocol = protocol,
FromPort = port,
ToPort = port,
IpRanges = ipRanges
});
});
//Set the permissions on the security group
var ingressRequest = new AuthorizeSecurityGroupIngressRequest();
ingressRequest.GroupId = securityGroup.GroupId;
ingressRequest.IpPermissions = ipPermissions.ToList();
var ingressResponse = EC2Client.AuthorizeSecurityGroupIngress(ingressRequest);
Console.WriteLine("Added permissions to security group: " + ingressResponse.HttpStatusCode);
return(securityGroup);
}
public async Task CopySecurityGroup(string sourceSgId, string targetSgName, string description)
{
var sReq = new DescribeSecurityGroupsRequest()
{
GroupIds = new List <string>()
{
sourceSgId
}
};
//client.va
var sResp = await client.DescribeSecurityGroupsAsync(sReq);
if (sResp.SecurityGroups.Count > 0)
{
var sSG = sResp.SecurityGroups[0];
SecurityGroup tSG;
var filters = new List <Filter>();
var filter = new Filter("group-name", new List <string> {
targetSgName
});
filters.Add(filter);
var tReq = new DescribeSecurityGroupsRequest()
{
Filters = filters
};
var tResp = await client.DescribeSecurityGroupsAsync(tReq);
if (tResp.SecurityGroups.Count > 0)
{
tSG = tResp.SecurityGroups[0];
tSG.IpPermissions = sSG.IpPermissions;
var uRequest = new UpdateSecurityGroupRuleDescriptionsIngressRequest()
{
GroupId = tSG.GroupId
};
await client.UpdateSecurityGroupRuleDescriptionsIngressAsync(uRequest);
}
else
{
var cReq = new CreateSecurityGroupRequest()
{
Description = description,
GroupName = targetSgName,
VpcId = sSG.VpcId
};
var cResp = await client.CreateSecurityGroupAsync(cReq);
AssignNameToResource(cResp.GroupId, targetSgName);
}
}
}
public SecurityGroup getSecurityGroup(string groupid)
{
_statusProvider.UpdateStatus("BUSY: Getting Security Group " + groupid + "...");
DescribeSecurityGroupsRequest req = new DescribeSecurityGroupsRequest();
req.Filters.Add(new Filter()
{
Name = "group-id",
Values = new List <string>()
{
groupid
}
}); return(_service.DescribeSecurityGroups(req).SecurityGroups[0]);
}
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);
}
private static DescribeSecurityGroupsResponse DescribeSecurityGroupsByTag()
{
var describeSecurityGroupRequest = new DescribeSecurityGroupsRequest
{
Filters = new List <Filter>
{
new Filter("tag-value", new List <string> {
DotNetTag.Value
}),
}
};
return(Client.DescribeSecurityGroups(describeSecurityGroupRequest));
}
static void EnumerateSecurityGroups(AmazonEC2Client ec2Client)
{
var request = new DescribeSecurityGroupsRequest();
var response = ec2Client.DescribeSecurityGroups(request);
List <SecurityGroup> mySGs = response.SecurityGroups;
foreach (SecurityGroup item in mySGs)
{
Console.WriteLine("Security group: " + item.GroupId);
Console.WriteLine("\tGroupId: " + item.GroupId);
Console.WriteLine("\tGroupName: " + item.GroupName);
Console.WriteLine("\tVpcId: " + item.VpcId);
Console.WriteLine();
}
}
private static string CreateSecurityGroup(IAmazonEC2 client, string vpcId, string groupName)
{
// Create a new empty group
var newSgRequest = new CreateSecurityGroupRequest()
{
GroupName = groupName,
Description = "Security group for AWS Talk",
VpcId = vpcId
};
// Get a handle to the newly created group
var newSgResponse = client.CreateSecurityGroup(newSgRequest);
var groups = new List <string>()
{
newSgResponse.GroupId
};
var createdSgRequest = new DescribeSecurityGroupsRequest()
{
GroupIds = groups
};
var createdSgResponse = client.DescribeSecurityGroups(createdSgRequest);
SecurityGroup theNewGroup = createdSgResponse.SecurityGroups[0];
// Add permissions to the group
var ingressRequest = new AuthorizeSecurityGroupIngressRequest();
ingressRequest.GroupId = theNewGroup.GroupId;
ingressRequest.IpPermissions.Add(new IpPermission()
{
IpProtocol = "tcp", FromPort = 3389, ToPort = 3389, IpRanges = new List <string>()
{
"0.0.0.0/0"
}
}); // RDP
ingressRequest.IpPermissions.Add(new IpPermission()
{
IpProtocol = "tcp", FromPort = 9999, ToPort = 9999, IpRanges = new List <string>()
{
"0.0.0.0/0"
}
}); // Worker API
client.AuthorizeSecurityGroupIngress(ingressRequest);
return(newSgResponse.GroupId);
}
public static List <SecurityGroup> ListSecurityGroupsForCurrentUser(AmazonEC2Client ec2Client)
{
var request = new DescribeSecurityGroupsRequest();
var response = ec2Client.DescribeSecurityGroups(request);
List <SecurityGroup> mySGs = response.SecurityGroups;
//foreach (SecurityGroup item in mySGs)
//{
// Console.WriteLine("Security group: " + item.GroupId);
// Console.WriteLine("\tGroupId: " + item.GroupId);
// Console.WriteLine("\tGroupName: " + item.GroupName);
// Console.WriteLine("\tVpcId: " + item.VpcId);
// Console.WriteLine();
//}
return(mySGs);
}
public async Task <bool> IsSecurityGroupsExistsAsync(string groupName)
{
DescribeSecurityGroupsRequest securityGroupsRequest = new DescribeSecurityGroupsRequest();
var sgResponse = await amazonEC2Client.DescribeSecurityGroupsAsync(securityGroupsRequest);
List <SecurityGroup> securityGroups = new List <SecurityGroup>();
securityGroups = sgResponse.SecurityGroups;
foreach (var item in securityGroups)
{
if (item.GroupName == groupName)
{
SecurityGroup securityGroup = item;
return(true);
}
}
return(false);
}
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);
}
async static Task <List <SecurityGroup> > GetSecurityGroups(IAmazonEC2 ec2Client, Filter[] filters)
{
var describeRequest = new DescribeSecurityGroupsRequest();
foreach (var filter in filters)
{
describeRequest.Filters.Add(filter);
}
var response = await ec2Client.DescribeSecurityGroupsAsync(describeRequest);
List <SecurityGroup> securityGroups = response.SecurityGroups;
foreach (var securityGroup in securityGroups)
{
LogSecurityGroup(securityGroup);
}
return(securityGroups);
}
public async Task <List <SA_SecurityGroup> > GetSecurityGroupList()
{
var saSecurityGroups = new List <SA_SecurityGroup>();
var request = new DescribeSecurityGroupsRequest();
var response = await client.DescribeSecurityGroupsAsync(request);
foreach (var securityGroup in response.SecurityGroups)
{
//Only Security group name follow naming convention and in current environment will be selected
if (securityGroup.Tags.Find(o => o.Key == "Name") == null)
{
continue;
}
if (securityGroup.Tags.Find(o => o.Key == "Name").Value.IndexOf(environment.ToString()) == 0)
{
saSecurityGroups.Add(ConvertSecurityGroup(securityGroup));
}
}
return(saSecurityGroups);
}
