from aliyunsdkcore.client import AcsClient

from aliyunsdkrds.request.v20140815 import DescribeBackupsRequest

import hashlib

import json

import requests

import datetime

import logging

import os

from urllib.request import urlopen

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")

class Rds_Bakup:

    def __init__(self):

        self.access_key_id = "xxxx"

        self.access_key_secret="xxxxxxxxxxxxxx"

        self.region_id="cn-beijing"

        self.db_id="xxxxxxxxxxxxx"

        self.product_code='RDS'

        self.star_time = (datetime.datetime.utcnow() - datetime.timedelta(days=1)).strftime('%Y-%m-%dT%H:%MZ')

        self.end_time = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%MZ')

        self.accept_format = "json"

        self.accept_name = "DescribeBackups"

        self.bakup_time = datetime.datetime.now().strftime('%Y-%m-%d')

        self.rds_bakup_dir = "/data/rdsbak/fullbak/{}".format(self.bakup_time)

        if not os.path.exists(self.rds_bakup_dir) :

            os.mkdir(self.rds_bakup_dir)

    def client_request(self):

        client = AcsClient(self.access_key_id, self.access_key_secret, self.region_id)

        request = DescribeBackupsRequest.DescribeBackupsRequest()

        request.set_accept_format(self.accept_format)

        request.set_action_name(self.accept_name)

        request.set_DBInstanceId(self.db_id)

        request.set_StartTime(self.star_time)

        request.set_EndTime(self.end_time)

        return client, request

    def rds_down(self):

        result = self.client_request()[0].do_action_with_exception(self.client_request()[1]).decode()

        s=json.loads(result)

        for bak_item in s['Items']['Backup']:

            for k,v in bak_item.items():

                if k == "BackupIntranetDownloadURL" :

                    file_down_url = v

                    file_name = v.split('?')[0].split('/')[-1]

                    req = urlopen(file_down_url)

                    log_file = "{0}/{1}_down.log".format(self.rds_bakup_dir, file_name)

                    file_handle = logging.FileHandler(log_file, encoding='utf-8')

                    self.logger = logging.getLogger(log_file)

                    self.logger.addHandler(file_handle)

                    chunk = 32 * 1024

                    try:

                        with open('{0}/{1}'.format(self.rds_bakup_dir, file_name), 'wb') as fobj:

                            while True:

                                data = req.read(chunk)

                                if not data:

                                    break



                                fobj.write(data)

                            self.logger.info("下载成功 {}".format(s))

                        sha_file = "{0}/{1}.SHA256".format(self.rds_bakup_dir, file_name)

                        sha_handle = logging.FileHandler(sha_file, encoding='utf-8')

                        self.logger = logging.getLogger(sha_file)

                        self.logger.addHandler(sha_handle)

                        hash_digest = hashlib.sha256()

                        with open('{}/{}'.format(self.rds_bakup_dir, file_name), 'rb') as hobj:

                            while True:

                                data = hobj.read(chunk)

                                if not data:

                                    break

                                hash_digest.update(data)

                        self.logger.info("SHA256: {}".format(hash_digest.hexdigest()))

                    except Exception as e:

                        self.logger.info("下载出错 {}".format(e))

if __name__ == '__main__':

    getfile = Rds_Bakup()

    try:

        getfile.rds_down()

        logging.info("下载成功 !!!")

    except Exception as e:

        logging.info("下载出错 {}".format(e))