public static IList<SecurityGroupRecord> GetAllSecurityGroups(bool force = false)
{
if (m_SecurityGroups == null || force)
{
var ec2 = Ec2ConnectionProvider.GetEc2Connection();
DescribeSecurityGroupsRequest req = new DescribeSecurityGroupsRequest();
DescribeSecurityGroupsResponse res = ec2.DescribeSecurityGroups(req);
m_SecurityGroups = new List<SecurityGroupRecord>();
res.DescribeSecurityGroupsResult.SecurityGroups.ForEach(
securityGroup => m_SecurityGroups.Add(
new SecurityGroupRecord()
{
Description = securityGroup.Description,
Id = securityGroup.GroupId,
Name = securityGroup.GroupName,
Vpc = securityGroup.VpcId,
Incomming = IpPermissionsToSecurityGroup(securityGroup.IpPermissions),
Outgoing = IpPermissionsToSecurityGroup(securityGroup.IpPermissionsEgress)
}
)
);
}
return m_SecurityGroups;
}
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 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;
}
public void CreateDefaultSecurityGroup_Ok()
{
// Arrange
string vpcId = Ec2Client.DescribeVpcs(new DescribeVpcsRequest())
.Vpcs.First(vpc => vpc.Tags.First(tag => tag.Key == "Name").Value == "Infrastructure Dev")
.VpcId;
// .. Verify that the security group doesn't already exist since this test relies on it not existing
var describeSgs = new DescribeSecurityGroupsRequest {GroupNames = new List<string> {_testSecurityGroupName}};
try
{
Ec2Client.DescribeSecurityGroups(describeSgs);
}
catch (AmazonEC2Exception e)
{
if (e.Message == "The security group 'Test_SeeMe_DeleteMe' does not exist")
{
// This is what we want to happen so let's keep going
}
else
{
throw;
}
}
// Act
Assert.AreEqual(Creator.SecurityGroupName, _testSecurityGroupName);
string sgId = Creator.TryCreateDefaultSecurityGroup(vpcId);
// Assert
sgId.Should().NotBeNull();
}
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();
}
protected override void ProcessRecord()
{
AmazonEC2 client = base.GetClient();
Amazon.EC2.Model.DescribeSecurityGroupsRequest request = new Amazon.EC2.Model.DescribeSecurityGroupsRequest();
if (string.IsNullOrEmpty(this._GroupName))
{
request.GroupName.Add(this._GroupName);
}
Amazon.EC2.Model.DescribeSecurityGroupsResponse response = client.DescribeSecurityGroups(request);
base.WriteObject(response.DescribeSecurityGroupsResult.SecurityGroup, true);
}
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 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);
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
#pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute
var useParameterSelect = this.Select.StartsWith("^") || this.PassThru.IsPresent;
#pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
// create request and set iteration invariants
var request = new Amazon.EC2.Model.DescribeSecurityGroupsRequest();
if (cmdletContext.Filter != null)
{
request.Filters = cmdletContext.Filter;
}
if (cmdletContext.GroupId != null)
{
request.GroupIds = cmdletContext.GroupId;
}
if (cmdletContext.GroupName != null)
{
request.GroupNames = cmdletContext.GroupName;
}
if (cmdletContext.MaxResult != null)
{
request.MaxResults = AutoIterationHelpers.ConvertEmitLimitToServiceTypeInt32(cmdletContext.MaxResult.Value);
}
// Initialize loop variant and commence piping
var _nextToken = cmdletContext.NextToken;
var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.NextToken));
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
do
{
request.NextToken = _nextToken;
CmdletOutput output;
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
if (!useParameterSelect)
{
pipelineOutput = cmdletContext.Select(response, this);
}
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
_nextToken = response.NextToken;
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
ProcessOutput(output);
} while (!_userControllingPaging && AutoIterationHelpers.HasValue(_nextToken));
if (useParameterSelect)
{
WriteObject(cmdletContext.Select(null, this));
}
return(null);
}
/// <summary>
/// <para>Describes one or more of your security groups.</para> <para>A security group is for use with instances either in the EC2-Classic
/// platform or in a specific VPC. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Amazon EC2 Security Groups</a> in the <i>Amazon
/// Elastic Compute Cloud User Guide</i> and <a href="http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html">Security
/// Groups for Your VPC</a> in the <i>Amazon Virtual Private Cloud User Guide</i> .</para>
/// </summary>
///
/// <param name="describeSecurityGroupsRequest">Container for the necessary parameters to execute the DescribeSecurityGroups service method on
/// AmazonEC2.</param>
///
/// <returns>The response from the DescribeSecurityGroups service method, as returned by AmazonEC2.</returns>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<DescribeSecurityGroupsResponse> DescribeSecurityGroupsAsync(DescribeSecurityGroupsRequest describeSecurityGroupsRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DescribeSecurityGroupsRequestMarshaller();
var unmarshaller = DescribeSecurityGroupsResponseUnmarshaller.GetInstance();
return Invoke<IRequest, DescribeSecurityGroupsRequest, DescribeSecurityGroupsResponse>(describeSecurityGroupsRequest, marshaller, unmarshaller, signer, cancellationToken);
}
internal DescribeSecurityGroupsResponse DescribeSecurityGroups(DescribeSecurityGroupsRequest request)
{
var task = DescribeSecurityGroupsAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
internal DescribeSecurityGroupsPaginator(IAmazonEC2 client, DescribeSecurityGroupsRequest request)
{
this._client = client;
this._request = request;
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeSecurityGroups operation.
/// <seealso cref="Amazon.EC2.IAmazonEC2.DescribeSecurityGroups"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroups operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<DescribeSecurityGroupsResponse> DescribeSecurityGroupsAsync(DescribeSecurityGroupsRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DescribeSecurityGroupsRequestMarshaller();
var unmarshaller = DescribeSecurityGroupsResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, DescribeSecurityGroupsRequest, DescribeSecurityGroupsResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
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;
}
/// <summary>
/// Describes one or more of your security groups.
///
///
/// <para>
/// A security group is for use with instances either in the EC2-Classic platform or in
/// a specific VPC. For more information, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Amazon
/// EC2 Security Groups</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> and
/// <a href="http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html">Security
/// Groups for Your VPC</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroups service method.</param>
///
/// <returns>The response from the DescribeSecurityGroups service method, as returned by EC2.</returns>
public DescribeSecurityGroupsResponse DescribeSecurityGroups(DescribeSecurityGroupsRequest request)
{
var marshaller = new DescribeSecurityGroupsRequestMarshaller();
var unmarshaller = DescribeSecurityGroupsResponseUnmarshaller.Instance;
return Invoke<DescribeSecurityGroupsRequest,DescribeSecurityGroupsResponse>(request, marshaller, unmarshaller);
}
IAsyncResult invokeDescribeSecurityGroups(DescribeSecurityGroupsRequest describeSecurityGroupsRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new DescribeSecurityGroupsRequestMarshaller().Marshall(describeSecurityGroupsRequest);
var unmarshaller = DescribeSecurityGroupsResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// <para>Describes one or more of your security groups.</para> <para>A security group is for use with instances either in the EC2-Classic
/// platform or in a specific VPC. For more information, see <a
/// href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html" >Amazon EC2 Security Groups</a> in the <i>Amazon
/// Elastic Compute Cloud User Guide</i> and <a href="http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html" >Security
/// Groups for Your VPC</a> in the <i>Amazon Virtual Private Cloud User Guide</i> .</para>
/// </summary>
///
/// <param name="describeSecurityGroupsRequest">Container for the necessary parameters to execute the DescribeSecurityGroups service method on
/// AmazonEC2.</param>
///
/// <returns>The response from the DescribeSecurityGroups service method, as returned by AmazonEC2.</returns>
///
public DescribeSecurityGroupsResponse DescribeSecurityGroups(DescribeSecurityGroupsRequest describeSecurityGroupsRequest)
{
IAsyncResult asyncResult = invokeDescribeSecurityGroups(describeSecurityGroupsRequest, null, null, true);
return EndDescribeSecurityGroups(asyncResult);
}
/// <summary>
/// Load security groups to view model with AWS data based on region selected and EC2 classic/vpc
/// </summary>
private void LoadSecurityGroups(AmazonEC2Client ec2Client)
{
try
{
DescribeSecurityGroupsRequest sgreq = new DescribeSecurityGroupsRequest();
DescribeSecurityGroupsResponse sgresp = ec2Client.DescribeSecurityGroups(sgreq);
Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
{
vm.SecurityGroups.Clear();
}));
foreach (SecurityGroup sg in sgresp.DescribeSecurityGroupsResult.SecurityGroup)
{
if (vm.IsVpc)
{
if (sg.VpcId != null && vm.SelectedVpc != null)
{
if (sg.VpcId == vm.SelectedVpc.VPC.VpcId)
{
Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
{
vm.SecurityGroups.Add(new Models.ConsoleSG() { SecurityGroup = sg, DisplayName = string.Concat(sg.GroupName, " ( VPC: ", sg.VpcId, " )") });
}));
}
}
}
else
{
if (!(sg.VpcId != null && sg.VpcId != string.Empty && !vm.IsVpc))
{
//vm.SecurityGroups.Add(new Models.LcSecurityGroup() { SecurityGroup = sg, DisplayName = sg.GroupName });
Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
{
vm.SecurityGroups.Add(new Models.ConsoleSG() { SecurityGroup = sg, DisplayName = sg.GroupName });
}));
}
}
}
}
catch (Exception ex)
{
LogManager.LogEntry(ex.Message);
LogManager.LogEntry(ex.StackTrace);
throw new DataLoadingException("Error occurred loading security groups for region and environment type");
}
}
private bool SecurityGroupExist(string secGroupName)
{
var existingGroupRequest = new DescribeSecurityGroupsRequest();
existingGroupRequest.Filters.Add(new Filter { Name = "group-name", Values = new[] { secGroupName }.ToList() });
var existingGroup = _client.DescribeSecurityGroups(existingGroupRequest);
return existingGroup.SecurityGroups.Count > 0;
}
/// <summary>
/// The DescribeSecurityGroups operation returns information about security groups
/// that you own.
/// If you specify security group names, information about those security group is
/// returned. Otherwise, information for all security group is returned. If you
/// specify a group that does not exist, a fault is returned.
///
/// </summary>
/// <param name="service">Instance of AmazonEC2 service</param>
/// <param name="request">DescribeSecurityGroupsRequest request</param>
public static void InvokeDescribeSecurityGroups(AmazonEC2 service, DescribeSecurityGroupsRequest request)
{
try
{
DescribeSecurityGroupsResponse response = service.DescribeSecurityGroups(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" DescribeSecurityGroupsResponse");
if (response.IsSetResponseMetadata())
{
Console.WriteLine(" ResponseMetadata");
ResponseMetadata responseMetadata = response.ResponseMetadata;
if (responseMetadata.IsSetRequestId())
{
Console.WriteLine(" RequestId");
Console.WriteLine(" {0}", responseMetadata.RequestId);
}
}
if (response.IsSetDescribeSecurityGroupsResult())
{
Console.WriteLine(" DescribeSecurityGroupsResult");
DescribeSecurityGroupsResult describeSecurityGroupsResult = response.DescribeSecurityGroupsResult;
List<SecurityGroup> securityGroupList = describeSecurityGroupsResult.SecurityGroup;
foreach (SecurityGroup securityGroup in securityGroupList)
{
Console.WriteLine(" SecurityGroup");
if (securityGroup.IsSetOwnerId())
{
Console.WriteLine(" OwnerId");
Console.WriteLine(" {0}", securityGroup.OwnerId);
}
if (securityGroup.IsSetGroupName())
{
Console.WriteLine(" GroupName");
Console.WriteLine(" {0}", securityGroup.GroupName);
}
if (securityGroup.IsSetGroupDescription())
{
Console.WriteLine(" GroupDescription");
Console.WriteLine(" {0}", securityGroup.GroupDescription);
}
List<IpPermission> ipPermissionList = securityGroup.IpPermission;
foreach (IpPermission ipPermission in ipPermissionList)
{
Console.WriteLine(" IpPermission");
if (ipPermission.IsSetIpProtocol())
{
Console.WriteLine(" IpProtocol");
Console.WriteLine(" {0}", ipPermission.IpProtocol);
}
if (ipPermission.IsSetFromPort())
{
Console.WriteLine(" FromPort");
Console.WriteLine(" {0}", ipPermission.FromPort);
}
if (ipPermission.IsSetToPort())
{
Console.WriteLine(" ToPort");
Console.WriteLine(" {0}", ipPermission.ToPort);
}
List<UserIdGroupPair> userIdGroupPairList = ipPermission.UserIdGroupPair;
foreach (UserIdGroupPair userIdGroupPair in userIdGroupPairList)
{
Console.WriteLine(" UserIdGroupPair");
if (userIdGroupPair.IsSetUserId())
{
Console.WriteLine(" UserId");
Console.WriteLine(" {0}", userIdGroupPair.UserId);
}
if (userIdGroupPair.IsSetGroupName())
{
Console.WriteLine(" GroupName");
Console.WriteLine(" {0}", userIdGroupPair.GroupName);
}
}
List<String> ipRangeList = ipPermission.IpRange;
foreach (String ipRange in ipRangeList)
{
Console.WriteLine(" IpRange");
Console.WriteLine(" {0}", ipRange);
}
}
}
}
}
catch (AmazonEC2Exception ex)
{
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("XML: " + ex.XML);
}
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeSecurityGroups operation.
/// <seealso cref="Amazon.EC2.IAmazonEC2.DescribeSecurityGroups"/>
/// </summary>
///
/// <param name="describeSecurityGroupsRequest">Container for the necessary parameters to execute the DescribeSecurityGroups operation on
/// AmazonEC2.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking
/// EndDescribeSecurityGroups operation.</returns>
public IAsyncResult BeginDescribeSecurityGroups(DescribeSecurityGroupsRequest describeSecurityGroupsRequest, AsyncCallback callback, object state)
{
return invokeDescribeSecurityGroups(describeSecurityGroupsRequest, callback, state, false);
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
var useParameterSelect = this.Select.StartsWith("^") || this.PassThru.IsPresent;
// create request and set iteration invariants
var request = new Amazon.EC2.Model.DescribeSecurityGroupsRequest();
if (cmdletContext.Filter != null)
{
request.Filters = cmdletContext.Filter;
}
if (cmdletContext.GroupId != null)
{
request.GroupIds = cmdletContext.GroupId;
}
if (cmdletContext.GroupName != null)
{
request.GroupNames = cmdletContext.GroupName;
}
// Initialize loop variants and commence piping
System.String _nextToken = null;
int? _emitLimit = null;
int _retrievedSoFar = 0;
if (AutoIterationHelpers.HasValue(cmdletContext.NextToken))
{
_nextToken = cmdletContext.NextToken;
}
if (cmdletContext.MaxResult.HasValue)
{
// The service has a maximum page size of 1000. If the user has
// asked for more items than page max, and there is no page size
// configured, we rely on the service ignoring the set maximum
// and giving us 1000 items back. If a page size is set, that will
// be used to configure the pagination.
// We'll make further calls to satisfy the user's request.
_emitLimit = cmdletContext.MaxResult;
}
var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.NextToken));
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
do
{
request.NextToken = _nextToken;
if (_emitLimit.HasValue)
{
int correctPageSize = Math.Min(1000, _emitLimit.Value);
request.MaxResults = AutoIterationHelpers.ConvertEmitLimitToInt32(correctPageSize);
}
CmdletOutput output;
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
if (!useParameterSelect)
{
pipelineOutput = cmdletContext.Select(response, this);
}
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
int _receivedThisCall = response.SecurityGroups.Count;
_nextToken = response.NextToken;
_retrievedSoFar += _receivedThisCall;
if (_emitLimit.HasValue)
{
_emitLimit -= _receivedThisCall;
}
}
catch (Exception e)
{
if (_retrievedSoFar == 0 || !_emitLimit.HasValue)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
else
{
break;
}
}
ProcessOutput(output);
} while (!_userControllingPaging && AutoIterationHelpers.HasValue(_nextToken) && (!_emitLimit.HasValue || _emitLimit.Value >= 5));
if (useParameterSelect)
{
WriteObject(cmdletContext.Select(null, this));
}
return(null);
}
/// <summary>
/// Paginator for DescribeSecurityGroups operation
///</summary>
public IDescribeSecurityGroupsPaginator DescribeSecurityGroups(DescribeSecurityGroupsRequest request)
{
return(new DescribeSecurityGroupsPaginator(this.client, request));
}
private Amazon.EC2.Model.DescribeSecurityGroupsResponse CallAWSServiceOperation(IAmazonEC2 client, Amazon.EC2.Model.DescribeSecurityGroupsRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Elastic Compute Cloud (EC2)", "DescribeSecurityGroups");
try
{
#if DESKTOP
return(client.DescribeSecurityGroups(request));
#elif CORECLR
return(client.DescribeSecurityGroupsAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeSecurityGroups operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroups operation on AmazonEC2Client.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSecurityGroups
/// operation.</returns>
public IAsyncResult BeginDescribeSecurityGroups(DescribeSecurityGroupsRequest request, AsyncCallback callback, object state)
{
var marshaller = new DescribeSecurityGroupsRequestMarshaller();
var unmarshaller = DescribeSecurityGroupsResponseUnmarshaller.Instance;
return BeginInvoke<DescribeSecurityGroupsRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// <para> The DescribeSecurityGroups operation returns information about security groups that you own. </para> <para> If you specify security
/// group names, information about those security group is returned. Otherwise, information for all security group is returned. If you specify a
/// group that does not exist, a fault is returned. </para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroups service method on
/// AmazonEC2.</param>
///
/// <returns>The response from the DescribeSecurityGroups service method, as returned by AmazonEC2.</returns>
public DescribeSecurityGroupsResponse DescribeSecurityGroups(DescribeSecurityGroupsRequest request)
{
var task = DescribeSecurityGroupsAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeSecurityGroups operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroups operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<DescribeSecurityGroupsResponse> DescribeSecurityGroupsAsync(DescribeSecurityGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DescribeSecurityGroupsRequestMarshaller();
var unmarshaller = DescribeSecurityGroupsResponseUnmarshaller.Instance;
return InvokeAsync<DescribeSecurityGroupsRequest,DescribeSecurityGroupsResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
private async Task<SecurityGroup> SecurityGroupExists()
{
var request = new DescribeSecurityGroupsRequest();
var response = await _client.DescribeSecurityGroupsAsync(request);
return response.SecurityGroups.FirstOrDefault(criteria => criteria.GroupName == _groupName);
}
