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); }