-- coding: utf-8 --
import sys
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
from TerminateTotalInstance import TerminateTotalInstance

if __name__ == '__main__':
    try:
        region = "ap-beijing"
        ins = "ins-irmer45l"
        TerminateTotalInstance(region=region).process(instance_id=instance_id)
        print("done!")
    except TencentCloudSDKException as e:
        print(e)
    except Exception as e:
        print("failed")


# -*- coding: utf-8 -*-
import logging
import time

from tencentcloud.common import credential
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.cvm.v20170312 import cvm_client, models as cvm_models
from tencentcloud.cbs.v20170312 import cbs_client, models as cbs_models


class TerminateTotalInstance(object):
    def __init__(self, region):
     Retrieve secretId and secretKey from environment variables TENCENTCLOUD_SECRET_ID and TENCENTCLOUD_SECRET_KEY by default
  For more credential management methods, please refer to: https://github.com/TencentCloud/tencentcloud-sdk-python#credential-management
        self.cred = credential.EnvironmentVariableCredential().get_credential()
        self.cbs_client = self.__create_cbs_client(region)
        self.cvm_client = self.__create_cvm_client(region)

    def get_cred(self):
        # If the identity is obtained based on the token, you need to check if the token is valid here.
        # If invalid, reacquire the credential
        if not self.cred:
            self.cred = credential.EnvironmentVariableCredential().get_credential()
        return self.cred
    def process(self, instance_id):
        # Retrieve cloud disk
        cbs_ids = self.describe_disks_for_instance(instance_id)

        # Return instance
        cvm_resp, cvm_api_errors = self.terminate_instance(instance_id)
        if cvm_api_errors:
            raise Exception(cvm_api_errors)

        # Confirm the successful return of the instance
        is_succ, cvm_api_errors = self.check_terminate_instance_success(instance_id)
        if not is_succ:
            raise Exception(cvm_api_errors)

        # Unmount and batch return cloud disks
        if not cbs_ids:
            return
        cbs_resp, cbs_api_errors = self.detach_disks(cbs_ids)
        if cbs_api_errors:
            raise Exception(cbs_api_errors)

        cbs_resp, cbs_api_errors = self.terminate_disks_for_instance(cbs_ids)
        if cbs_api_errors:
            raise Exception(cbs_api_errors)

    def terminate_instance(self, instance_id):
        # Call failure history
        cvm_api_errors = []

        for i in range(0, 5):
            try:
                req = cvm_models.TerminateInstancesRequest()
                params = '{"InstanceIds":["%s"]}' % instance_id
                req.from_json_string(params)
                resp = self.cvm_client.TerminateInstances(req)
                cvm_api_errors.clear()
                return resp, cvm_api_errors

            except TencentCloudSDKException as e:
                # Retry on failure and log errors
                cvm_api_errors.append(e)
                logging.error(e)
            time.sleep(3)

        return None, cvm_api_errors

    def check_terminate_instance_success(self, instance_id):
        # Call failure history
        cvm_api_errors = []

        for _ in range(0, 30):
            try:
                req = cvm_models.DescribeInstancesStatusRequest()
                params = '{"InstanceIds":["%s"]}' % instance_id
                req.from_json_string(params)
                resp = self.cvm_client.DescribeInstancesStatus(req)
                cvm_api_errors.clear()
                if resp.TotalCount > 0:
                    if resp.InstanceStatusSet[0].InstanceState == "SHUTDOWN":
                        return True, cvm_api_errors
                    else:
                        logging.error(resp)

            except TencentCloudSDKException as e:
                # Retry on failure and log errors
                cvm_api_errors.append(e)
                logging.error(e)
            time.sleep(6)

        return False, cvm_api_errors

    def describe_disks_for_instance(self, instance_id):
        # Retrieve the data disks attached to the instance
        req = cbs_models.DescribeDisksRequest()
        params = '{"Filters": [ { "Name": "instance-id", "Values": [ "%s" ]}]}' % instance_id
        req.from_json_string(params)
        disks = self.cbs_client.DescribeDisks(req)
        if hasattr(disks, "DiskSet"):
            cbs_ids = [disk.DiskId for disk in disks.DiskSet if disk.DiskUsage == "DATA_DISK"]
        else:
            cbs_ids = list()
        return cbs_ids

    def detach_disks(self, cbs_ids):
        # Unmount data disk
        cbs_api_errors = []
        for _ in range(0, 5):
            try:
                req = cbs_models.DetachDisksRequest()
                req.DiskIds = cbs_ids
                resp = self.cbs_client.DetachDisks(req)
                cbs_api_errors.clear()
                return resp, cbs_api_errors

            except TencentCloudSDKException as e:
                # Retry on failure and log errors
                cbs_api_errors.append(e)
                logging.error(e)
            time.sleep(3)

        return None, cbs_api_errors

    def terminate_disks_for_instance(self, cbs_ids):
        # Return data disk
        cbs_api_errors = []
        for _ in range(0, 10):
            try:
                req = cbs_models.TerminateDisksRequest()
                req.DiskIds = cbs_ids
                resp = self.cbs_client.TerminateDisks(req)
                cbs_api_errors.clear()
                return resp, cbs_api_errors

            except TencentCloudSDKException as e:
                # Retry on failure and log errors
                cbs_api_errors.append(e)
                logging.error(e)
            time.sleep(6)
        return None, cbs_api_errors

    def __create_cbs_client(self, region):
        http_profile = HttpProfile()
        http_profile.endpoint = "cbs.tencentcloudapi.com"

        client_profile = ClientProfile()
        client_profile.httpProfile = http_profile
        return cbs_client.CbsClient(self.get_cred(), region, client_profile)

    def __create_cvm_client(self, region):
        http_profile = HttpProfile()
        http_profile.endpoint = "cvm.tencentcloudapi.com"

        client_profile = ClientProfile()
        client_profile.httpProfile = http_profile
        return cvm_client.CvmClient(self.get_cred(), region, client_profile)