public void Run() { var request = new TerminateInstancesRequest { InstanceIds = new List<string>() { instance.InstanceId } }; try { var responseTerminate = awsClient.Ec2Client.TerminateInstances(request); foreach (var item in responseTerminate.TerminatingInstances) { instance.CurrentStatus = item.CurrentState.Code.ToString(); instance.PreviousStatus = item.PreviousState.Code.ToString(); } if (instance.CurrentStatus == "32") FinishedSuccessfully = true; } catch (AmazonEC2Exception ex) { Error = "InvalidInstanceID.NotFound" == ex.ErrorCode ? "Instance does not exist." : ex.Message; } }
/// <summary> /// Terminate an active EC2 instance. /// </summary> protected override void AmazonExecute() { var request = new TerminateInstancesRequest { InstanceId = this.InstanceIds.Get(this.ActivityContext) }; try { var response = EC2Client.TerminateInstances(request); this.InstanceChanges.Set(this.ActivityContext, response.TerminateInstancesResult.TerminatingInstance); } catch (EndpointNotFoundException ex) { this.LogBuildMessage(ex.Message); } }
public void TerminateInstance(string instanceId) { try { AWSModel.TerminateInstancesRequest request = new AWSModel.TerminateInstancesRequest(); List <string> terminateList = new List <string>(); terminateList.Add(instanceId); request.InstanceId = terminateList; ec2.TerminateInstances(request); } catch (WebException e) { throw new MonoscapeEC2Exception(e.Message, e); } catch (AmazonEC2Exception e) { throw new MonoscapeEC2Exception(e.Message, e); } }
public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.EC2.Model.TerminateInstancesRequest(); if (cmdletContext.InstanceId != null) { request.InstanceIds = cmdletContext.InstanceId; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return(output); }
/// <summary> /// Initiates the asynchronous execution of the TerminateInstances operation. /// <seealso cref="Amazon.EC2.IAmazonEC2.TerminateInstances"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the TerminateInstances 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<TerminateInstancesResponse> TerminateInstancesAsync(TerminateInstancesRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new TerminateInstancesRequestMarshaller(); var unmarshaller = TerminateInstancesResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, TerminateInstancesRequest, TerminateInstancesResponse>(request, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// This function terminates an existing EC2 instance, regardless of location /// </summary> /// <param name="InstanceId">The id of the instance to be terminated</param> /// <returns>Success flag</returns> public bool TerminateInstance(string InstanceId) { bool result = false; // Initialize error values ErrorCode = 0; ErrorMessage = ""; // Create the request var deleteRequest = new TerminateInstancesRequest () { InstanceIds = new List<string> { InstanceId } }; try { // Run the operation var deleteResponse = EC2client.TerminateInstances (deleteRequest); // Check response for errors if (deleteResponse.HttpStatusCode != HttpStatusCode.OK) { ErrorCode = Convert.ToInt32 (deleteResponse.HttpStatusCode); ErrorMessage = "Http Error [" + deleteResponse.HttpStatusCode.ToString () + "]"; } else { result = true; } } catch (Exception ex) { ErrorCode = -1; ErrorMessage = ex.Message + "::" + ex.InnerException; } return result; }
public void TerminateInstance(string instanceId) { try { AWSModel.TerminateInstancesRequest request = new AWSModel.TerminateInstancesRequest(); List<string> terminateList = new List<string>(); terminateList.Add(instanceId); request.InstanceId = terminateList; ec2.TerminateInstances(request); } catch (WebException e) { throw new MonoscapeEC2Exception(e.Message, e); } catch (AmazonEC2Exception e) { throw new MonoscapeEC2Exception(e.Message, e); } }
/// <summary> /// <para> The TerminateInstances operation shuts down one or more instances. This operation is idempotent; if you terminate an instance more /// than once, each call will succeed. </para> <para> Terminated instances will remain visible after termination (approximately one hour). /// </para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the TerminateInstances service method on /// AmazonEC2.</param> /// /// <returns>The response from the TerminateInstances service method, as returned by AmazonEC2.</returns> public TerminateInstancesResponse TerminateInstances(TerminateInstancesRequest request) { var task = TerminateInstancesAsync(request); try { return task.Result; } catch(AggregateException e) { throw e.InnerException; } }
public void Terminate(string bootstrapId, string vpcId) { Logger.Info("Terminating instances"); var instanceRequest = new DescribeInstancesRequest { Filters = new[] { new Filter { Name = "tag:Name", Values = new[] {Ec2TagHandler.GetNameTag(bootstrapId)}.ToList() }, new Filter { Name = "instance-state-name", Values = new[] {"running", "pending", "stopping", "stopped"}.ToList() }, new Filter { Name = "vpc-id", Values = new[] {vpcId}.ToList() } }.ToList() }; var instances = _client.DescribeInstances(instanceRequest); var terminationRequest = new TerminateInstancesRequest(); var instanceIds = instances.Reservations.SelectMany(x => x.Instances.Select(y => y.InstanceId)).ToList(); terminationRequest.InstanceIds.AddRange(instanceIds); _client.TerminateInstances(terminationRequest); Logger.WithLogSection("Waiting for instances to terminate", () => WaitForInstancesToTerminate(instanceIds)); }
private Amazon.EC2.Model.TerminateInstancesResponse CallAWSServiceOperation(IAmazonEC2 client, Amazon.EC2.Model.TerminateInstancesRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Elastic Compute Cloud (EC2)", "TerminateInstances"); try { #if DESKTOP return(client.TerminateInstances(request)); #elif CORECLR return(client.TerminateInstancesAsync(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; } }
IAsyncResult invokeTerminateInstances(TerminateInstancesRequest terminateInstancesRequest, AsyncCallback callback, object state, bool synchronized) { IRequest irequest = new TerminateInstancesRequestMarshaller().Marshall(terminateInstancesRequest); var unmarshaller = TerminateInstancesResponseUnmarshaller.GetInstance(); AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller); Invoke(result); return result; }
private void TerminateAgents(AmazonEC2Client ec2Client, List<string> instanceIds) { var termRequest = new TerminateInstancesRequest {InstanceIds = instanceIds}; TerminateInstancesResponse termResponse = ec2Client.TerminateInstances(termRequest); if (termResponse.HttpStatusCode != HttpStatusCode.OK) { throw new Exception("Agents were not terminated succesfully"); } }
public async Task terminateInstanceAsync(string instanceId) { TerminateInstancesRequest request = new TerminateInstancesRequest { InstanceIds = new List<string> { instanceId } }; await _ec2Client.TerminateInstancesAsync(request); }
/// <summary> /// <para>Shuts down one or more instances. This operation is idempotent; if you terminate an instance more than once, each call /// succeeds.</para> <para>Terminated instances remain visible after termination (for approximately one hour).</para> <para>By default, Amazon /// EC2 deletes all Amazon EBS volumes that were attached when the instance launched. Volumes attached after instance launch continue /// running.</para> <para>You can stop, start, and terminate EBS-backed instances. You can only terminate instance store-backed instances. What /// happens to an instance differs if you stop it or terminate it. For example, when you stop an instance, the root device and any other devices /// attached to the instance persist. When you terminate an instance, the root device and any other devices attached during the instance launch /// are automatically deleted. For more information about the differences between stopping and terminating instances, see <a /// href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html" >Instance Lifecycle</a> in the <i>Amazon Elastic /// Compute Cloud User Guide</i> .</para> /// </summary> /// /// <param name="terminateInstancesRequest">Container for the necessary parameters to execute the TerminateInstances service method on /// AmazonEC2.</param> /// /// <returns>The response from the TerminateInstances service method, as returned by AmazonEC2.</returns> /// public TerminateInstancesResponse TerminateInstances(TerminateInstancesRequest terminateInstancesRequest) { IAsyncResult asyncResult = invokeTerminateInstances(terminateInstancesRequest, null, null, true); return EndTerminateInstances(asyncResult); }
private void TerminateInstance(AwsRegionLocations region, string instanceId) { var client = ec2Clients.GetOrAdd(region, r => AWSClientFactory.CreateAmazonEC2Client(credentials, region.ToAwsRegionEndpoint())); var deleteRequest = new TerminateInstancesRequest() { InstanceIds = new List<string>() { instanceId } }; client.TerminateInstances(deleteRequest); }
/// <summary> /// Terminates an EC2 instance. /// </summary> /// <param name="instanceIds"></param> public void TerminateInstance(IEnumerable<string> instanceIds) { var request = new TerminateInstancesRequest { InstanceId = new List<string>(instanceIds) }; Client.TerminateInstances(request); }
public void terminate(string instanceId) { try { TerminateInstancesRequest request = new TerminateInstancesRequest(); request.InstanceId.Add(instanceId); TerminateInstancesResponse response = _service.TerminateInstances(request); } catch (AmazonEC2Exception ex) { throw new Exception("Caught Exception: " + ex.XML); } }
internal TerminateInstancesResponse TerminateInstances(TerminateInstancesRequest request) { var task = TerminateInstancesAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
/// <summary> /// Shuts down one or more instances. This operation is idempotent; if you terminate an /// instance more than once, each call succeeds. /// /// /// <para> /// Terminated instances remain visible after termination (for approximately one hour). /// </para> /// /// <para> /// By default, Amazon EC2 deletes all EBS volumes that were attached when the instance /// launched. Volumes attached after instance launch continue running. /// </para> /// /// <para> /// You can stop, start, and terminate EBS-backed instances. You can only terminate instance /// store-backed instances. What happens to an instance differs if you stop it or terminate /// it. For example, when you stop an instance, the root device and any other devices /// attached to the instance persist. When you terminate an instance, the root device /// and any other devices attached during the instance launch are automatically deleted. /// For more information about the differences between stopping and terminating instances, /// see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance /// Lifecycle</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. /// </para> /// /// <para> /// For more information about troubleshooting, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesShuttingDown.html">Troubleshooting /// Terminating Your Instance</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. /// </para> /// </summary> /// <param name="request">Container for the necessary parameters to execute the TerminateInstances service method.</param> /// /// <returns>The response from the TerminateInstances service method, as returned by EC2.</returns> public TerminateInstancesResponse TerminateInstances(TerminateInstancesRequest request) { var marshaller = new TerminateInstancesRequestMarshaller(); var unmarshaller = TerminateInstancesResponseUnmarshaller.Instance; return Invoke<TerminateInstancesRequest,TerminateInstancesResponse>(request, marshaller, unmarshaller); }
/// <summary> /// <para>Shuts down one or more instances. This operation is idempotent; if you terminate an instance more than once, each call /// succeeds.</para> <para>Terminated instances remain visible after termination (for approximately one hour).</para> <para>By default, Amazon /// EC2 deletes all Amazon EBS volumes that were attached when the instance launched. Volumes attached after instance launch continue /// running.</para> <para>You can stop, start, and terminate EBS-backed instances. You can only terminate instance store-backed instances. What /// happens to an instance differs if you stop it or terminate it. For example, when you stop an instance, the root device and any other devices /// attached to the instance persist. When you terminate an instance, the root device and any other devices attached during the instance launch /// are automatically deleted. For more information about the differences between stopping and terminating instances, see <a href="http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance Lifecycle</a> in the <i>Amazon Elastic /// Compute Cloud User Guide</i> .</para> /// </summary> /// /// <param name="terminateInstancesRequest">Container for the necessary parameters to execute the TerminateInstances service method on /// AmazonEC2.</param> /// /// <returns>The response from the TerminateInstances 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<TerminateInstancesResponse> TerminateInstancesAsync(TerminateInstancesRequest terminateInstancesRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new TerminateInstancesRequestMarshaller(); var unmarshaller = TerminateInstancesResponseUnmarshaller.GetInstance(); return Invoke<IRequest, TerminateInstancesRequest, TerminateInstancesResponse>(terminateInstancesRequest, marshaller, unmarshaller, signer, cancellationToken); }
/// <summary> /// Shuts down one or more instances. This operation is idempotent; if you terminate an instance more than once, each call succeeds. /// Terminated instances remain visible after termination (for approximately one hour). By default, Amazon EC2 deletes all EBS volumes that were attached when the instance /// launched. Volumes attached after instance launch continue running. You can stop, start, and terminate EBS-backed instances. You can only terminate /// instance store-backed instances. What happens to an instance differs if you stop it or terminate it. For example, when you stop an instance, the root device and /// any other devices attached to the instance persist. When you terminate an instance, any attached EBS volumes with the DeleteOnTermination block device mapping parameter /// set to true are automatically deleted. For more information about the differences between stopping and terminating instances, see Instance Lifecycle in the Amazon EC2 User Guide. /// </summary> /// <param name="instances">A list of instance IDs to be stopped.</param> /// <param name="settings">The <see cref="EC2Settings"/> used during the request to AWS.</param> public bool TerminateInstances(IList<string> instances, EC2Settings settings) { if ((instances == null) || (instances.Count == 0)) { throw new ArgumentNullException("instances"); } //Create Request AmazonEC2Client client = this.CreateClient(settings); TerminateInstancesRequest request = new TerminateInstancesRequest(); foreach (string instance in instances) { request.InstanceIds.Add(instance); } //Check Response TerminateInstancesResponse response = client.TerminateInstances(request); if (response.HttpStatusCode == HttpStatusCode.OK) { _Log.Verbose("Successfully terminated instances '{0}'", string.Join(",", instances)); return true; } else { _Log.Error("Failed to terminate instances '{0}'", string.Join(",", instances)); return false; } }
/// <summary> /// Initiates the asynchronous execution of the TerminateInstances operation. /// <seealso cref="Amazon.EC2.IAmazonEC2.TerminateInstances"/> /// </summary> /// /// <param name="terminateInstancesRequest">Container for the necessary parameters to execute the TerminateInstances 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 /// EndTerminateInstances operation.</returns> public IAsyncResult BeginTerminateInstances(TerminateInstancesRequest terminateInstancesRequest, AsyncCallback callback, object state) { return invokeTerminateInstances(terminateInstancesRequest, callback, state, false); }
/// <summary> /// The TerminateInstances operation shuts down one or more instances. This /// operation is idempotent; if you terminate an instance more than once, each call /// will succeed. /// Terminated instances will remain visible after termination (approximately one /// hour). /// /// </summary> /// <param name="service">Instance of AmazonEC2 service</param> /// <param name="request">TerminateInstancesRequest request</param> public static void InvokeTerminateInstances(AmazonEC2 service, TerminateInstancesRequest request) { try { TerminateInstancesResponse response = service.TerminateInstances(request); Console.WriteLine ("Service Response"); Console.WriteLine ("============================================================================="); Console.WriteLine (); Console.WriteLine(" TerminateInstancesResponse"); if (response.IsSetResponseMetadata()) { Console.WriteLine(" ResponseMetadata"); ResponseMetadata responseMetadata = response.ResponseMetadata; if (responseMetadata.IsSetRequestId()) { Console.WriteLine(" RequestId"); Console.WriteLine(" {0}", responseMetadata.RequestId); } } if (response.IsSetTerminateInstancesResult()) { Console.WriteLine(" TerminateInstancesResult"); TerminateInstancesResult terminateInstancesResult = response.TerminateInstancesResult; List<TerminatingInstance> terminatingInstanceList = terminateInstancesResult.TerminatingInstance; foreach (TerminatingInstance terminatingInstance in terminatingInstanceList) { Console.WriteLine(" TerminatingInstance"); if (terminatingInstance.IsSetInstanceId()) { Console.WriteLine(" InstanceId"); Console.WriteLine(" {0}", terminatingInstance.InstanceId); } if (terminatingInstance.IsSetShutdownState()) { Console.WriteLine(" ShutdownState"); InstanceState shutdownState = terminatingInstance.ShutdownState; if (shutdownState.IsSetCode()) { Console.WriteLine(" Code"); Console.WriteLine(" {0}", shutdownState.Code); } if (shutdownState.IsSetName()) { Console.WriteLine(" Name"); Console.WriteLine(" {0}", shutdownState.Name); } } if (terminatingInstance.IsSetPreviousState()) { Console.WriteLine(" PreviousState"); InstanceState previousState = terminatingInstance.PreviousState; if (previousState.IsSetCode()) { Console.WriteLine(" Code"); Console.WriteLine(" {0}", previousState.Code); } if (previousState.IsSetName()) { Console.WriteLine(" Name"); Console.WriteLine(" {0}", previousState.Name); } } } } } 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 TerminateInstances operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the TerminateInstances 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 EndTerminateInstances /// operation.</returns> public IAsyncResult BeginTerminateInstances(TerminateInstancesRequest request, AsyncCallback callback, object state) { var marshaller = new TerminateInstancesRequestMarshaller(); var unmarshaller = TerminateInstancesResponseUnmarshaller.Instance; return BeginInvoke<TerminateInstancesRequest>(request, marshaller, unmarshaller, callback, state); }
public void TerminateInstance(string instanceId) { TerminateInstancesRequest terminateInstancesRequest = new TerminateInstancesRequest() { InstanceId = new List<string>() { instanceId } }; var terminateInstancesResponse = amazonEc2.TerminateInstances(terminateInstancesRequest); }
/// <summary> /// Initiates the asynchronous execution of the TerminateInstances operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the TerminateInstances 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<TerminateInstancesResponse> TerminateInstancesAsync(TerminateInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new TerminateInstancesRequestMarshaller(); var unmarshaller = TerminateInstancesResponseUnmarshaller.Instance; return InvokeAsync<TerminateInstancesRequest,TerminateInstancesResponse>(request, marshaller, unmarshaller, cancellationToken); }
public override void DestroyNode(Node node) { TerminateInstancesRequest request = new TerminateInstancesRequest () { InstanceId = new List<string> () { node.Id }}; TerminateInstancesResponse response = Client.TerminateInstances (request); }