diff --git a/README.md b/README.md index 970b0fc4b109055de0117f76eecff9fb31e50a39..a32eb246cb49f395318a5c5216c7c9fc89125bcb 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ pip install -U "prefect" pip install prefect-hwc -prefect block register --module prefect-hwc +prefect block register --module prefect_huaweicloud ``` ## Contributing diff --git a/__pycache__/dewClient.cpython-311.pyc b/__pycache__/dewClient.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ba12c137a720a2c241e4d9c07b50cf500965ce1 Binary files /dev/null and b/__pycache__/dewClient.cpython-311.pyc differ diff --git a/build/lib/prefect_huaweicloud/__init__.py b/build/lib/prefect_huaweicloud/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c6711c32cab2b6808faa86d7c978340a1c457249 --- /dev/null +++ b/build/lib/prefect_huaweicloud/__init__.py @@ -0,0 +1,6 @@ +# ensure core blocks are registered + +from prefect_huaweicloud.obs_block import ObsBlock +from prefect_huaweicloud.dew_block import DewBlock +# from prefect_huaweicloud.dew import DEW +__all__ = ["ObsBlock","DewBlocks"] diff --git a/build/lib/prefect_huaweicloud/dew.py b/build/lib/prefect_huaweicloud/dew.py new file mode 100644 index 0000000000000000000000000000000000000000..f5b529c46e0abc4761a6b4b8c3cc02c5e319f65a --- /dev/null +++ b/build/lib/prefect_huaweicloud/dew.py @@ -0,0 +1,413 @@ + +from typing import Any, Dict, List, Optional, Union + + + +# @task +# async def read_secret( +# secret_name: str, +# aws_credentials: AwsCredentials, +# version_id: Optional[str] = None, +# version_stage: Optional[str] = None, +# ) -> Union[str, bytes]: +# """ +# Reads the value of a given secret from AWS Secrets Manager. + +# Args: +# secret_name: Name of stored secret. +# aws_credentials: Credentials to use for authentication with AWS. +# version_id: Specifies version of secret to read. Defaults to the most recent +# version if not given. +# version_stage: Specifies the version stage of the secret to read. Defaults to +# AWS_CURRENT if not given. + +# Returns: +# The secret values as a `str` or `bytes` depending on the format in which the +# secret was stored. + +# Example: +# Read a secret value: + +# ```python +# from prefect import flow +# from prefect_aws import AwsCredentials +# from prefect_aws.secrets_manager import read_secret + +# @flow +# def example_read_secret(): +# aws_credentials = AwsCredentials( +# aws_access_key_id="access_key_id", +# aws_secret_access_key="secret_access_key" +# ) +# secret_value = read_secret( +# secret_name="db_password", +# aws_credentials=aws_credentials +# ) + +# example_read_secret() +# ``` +# """ +# logger = get_run_logger() +# logger.info("Getting value for secret %s", secret_name) + +# client = aws_credentials.get_boto3_session().client("secretsmanager") + +# get_secret_value_kwargs = dict(SecretId=secret_name) +# if version_id is not None: +# get_secret_value_kwargs["VersionId"] = version_id +# if version_stage is not None: +# get_secret_value_kwargs["VersionStage"] = version_stage + +# try: +# response = await run_sync_in_worker_thread( +# client.get_secret_value, **get_secret_value_kwargs +# ) +# except ClientError: +# logger.exception("Unable to get value for secret %s", secret_name) +# raise +# else: +# return response.get("SecretString") or response.get("SecretBinary") + + +# @task +# async def update_secret( +# secret_name: str, +# secret_value: Union[str, bytes], +# aws_credentials: AwsCredentials, +# description: Optional[str] = None, +# ) -> Dict[str, str]: +# """ +# Updates the value of a given secret in AWS Secrets Manager. + +# Args: +# secret_name: Name of secret to update. +# secret_value: Desired value of the secret. Can be either `str` or `bytes`. +# aws_credentials: Credentials to use for authentication with AWS. +# description: Desired description of the secret. + +# Returns: +# A dict containing the secret ARN (Amazon Resource Name), +# name, and current version ID. +# ```python +# { +# "ARN": str, +# "Name": str, +# "VersionId": str +# } +# ``` + +# Example: +# Update a secret value: + +# ```python +# from prefect import flow +# from prefect_aws import AwsCredentials +# from prefect_aws.secrets_manager import update_secret + +# @flow +# def example_update_secret(): +# aws_credentials = AwsCredentials( +# aws_access_key_id="access_key_id", +# aws_secret_access_key="secret_access_key" +# ) +# update_secret( +# secret_name="life_the_universe_and_everything", +# secret_value="42", +# aws_credentials=aws_credentials +# ) + +# example_update_secret() +# ``` + +# """ +# update_secret_kwargs: Dict[str, Union[str, bytes]] = dict(SecretId=secret_name) +# if description is not None: +# update_secret_kwargs["Description"] = description +# if isinstance(secret_value, bytes): +# update_secret_kwargs["SecretBinary"] = secret_value +# elif isinstance(secret_value, str): +# update_secret_kwargs["SecretString"] = secret_value +# else: +# raise ValueError("Please provide a bytes or str value for secret_value") + +# logger = get_run_logger() +# logger.info("Updating value for secret %s", secret_name) + +# client = aws_credentials.get_boto3_session().client("secretsmanager") + +# try: +# response = await run_sync_in_worker_thread( +# client.update_secret, **update_secret_kwargs +# ) +# response.pop("ResponseMetadata", None) +# return response +# except ClientError: +# logger.exception("Unable to update secret %s", secret_name) +# raise + + +# @task +# async def create_secret( +# secret_name: str, +# secret_value: Union[str, bytes], +# aws_credentials: AwsCredentials, +# description: Optional[str] = None, +# tags: Optional[List[Dict[str, str]]] = None, +# ) -> Dict[str, str]: +# """ +# Creates a secret in AWS Secrets Manager. + +# Args: +# secret_name: The name of the secret to create. +# secret_value: The value to store in the created secret. +# aws_credentials: Credentials to use for authentication with AWS. +# description: A description for the created secret. +# tags: A list of tags to attach to the secret. Each tag should be specified as a +# dictionary in the following format: +# ```python +# { +# "Key": str, +# "Value": str +# } +# ``` + +# Returns: +# A dict containing the secret ARN (Amazon Resource Name), +# name, and current version ID. +# ```python +# { +# "ARN": str, +# "Name": str, +# "VersionId": str +# } +# ``` +# Example: +# Create a secret: + +# ```python +# from prefect import flow +# from prefect_aws import AwsCredentials +# from prefect_aws.secrets_manager import create_secret + +# @flow +# def example_create_secret(): +# aws_credentials = AwsCredentials( +# aws_access_key_id="access_key_id", +# aws_secret_access_key="secret_access_key" +# ) +# create_secret( +# secret_name="life_the_universe_and_everything", +# secret_value="42", +# aws_credentials=aws_credentials +# ) + +# example_create_secret() +# ``` + + +# """ +# create_secret_kwargs: Dict[str, Union[str, bytes, List[Dict[str, str]]]] = dict( +# Name=secret_name +# ) +# if description is not None: +# create_secret_kwargs["Description"] = description +# if tags is not None: +# create_secret_kwargs["Tags"] = tags +# if isinstance(secret_value, bytes): +# create_secret_kwargs["SecretBinary"] = secret_value +# elif isinstance(secret_value, str): +# create_secret_kwargs["SecretString"] = secret_value +# else: +# raise ValueError("Please provide a bytes or str value for secret_value") + +# logger = get_run_logger() +# logger.info("Creating secret named %s", secret_name) + +# client = aws_credentials.get_boto3_session().client("secretsmanager") + +# try: +# response = await run_sync_in_worker_thread( +# client.create_secret, **create_secret_kwargs +# ) +# print(response.pop("ResponseMetadata", None)) +# return response +# except ClientError: +# logger.exception("Unable to create secret %s", secret_name) +# raise + + +# @task +# async def delete_secret( +# secret_name: str, +# aws_credentials: AwsCredentials, +# recovery_window_in_days: int = 30, +# force_delete_without_recovery: bool = False, +# ) -> Dict[str, str]: +# """ +# Deletes a secret from AWS Secrets Manager. + +# Secrets can either be deleted immediately by setting `force_delete_without_recovery` +# equal to `True`. Otherwise, secrets will be marked for deletion and available for +# recovery for the number of days specified in `recovery_window_in_days` + +# Args: +# secret_name: Name of the secret to be deleted. +# aws_credentials: Credentials to use for authentication with AWS. +# recovery_window_in_days: Number of days a secret should be recoverable for +# before permanent deletion. Minium window is 7 days and maximum window +# is 30 days. If `force_delete_without_recovery` is set to `True`, this +# value will be ignored. +# force_delete_without_recovery: If `True`, the secret will be immediately +# deleted and will not be recoverable. + +# Returns: +# A dict containing the secret ARN (Amazon Resource Name), +# name, and deletion date of the secret. DeletionDate is the date and +# time of the delete request plus the number of days in +# `recovery_window_in_days`. +# ```python +# { +# "ARN": str, +# "Name": str, +# "DeletionDate": datetime.datetime +# } +# ``` + +# Examples: +# Delete a secret immediately: + +# ```python +# from prefect import flow +# from prefect_aws import AwsCredentials +# from prefect_aws.secrets_manager import delete_secret + +# @flow +# def example_delete_secret_immediately(): +# aws_credentials = AwsCredentials( +# aws_access_key_id="access_key_id", +# aws_secret_access_key="secret_access_key" +# ) +# delete_secret( +# secret_name="life_the_universe_and_everything", +# aws_credentials=aws_credentials, +# force_delete_without_recovery: True +# ) + +# example_delete_secret_immediately() +# ``` + +# Delete a secret with a 90 day recovery window: + +# ```python +# from prefect import flow +# from prefect_aws import AwsCredentials +# from prefect_aws.secrets_manager import delete_secret + +# @flow +# def example_delete_secret_with_recovery_window(): +# aws_credentials = AwsCredentials( +# aws_access_key_id="access_key_id", +# aws_secret_access_key="secret_access_key" +# ) +# delete_secret( +# secret_name="life_the_universe_and_everything", +# aws_credentials=aws_credentials, +# recovery_window_in_days=90 +# ) + +# example_delete_secret_with_recovery_window() +# ``` + + +# """ +# if not force_delete_without_recovery and not (7 <= recovery_window_in_days <= 30): +# raise ValueError("Recovery window must be between 7 and 30 days.") + +# delete_secret_kwargs: Dict[str, Union[str, int, bool]] = dict(SecretId=secret_name) +# if force_delete_without_recovery: +# delete_secret_kwargs["ForceDeleteWithoutRecovery"] = ( +# force_delete_without_recovery +# ) +# else: +# delete_secret_kwargs["RecoveryWindowInDays"] = recovery_window_in_days + +# logger = get_run_logger() +# logger.info("Deleting secret %s", secret_name) + +# client = aws_credentials.get_boto3_session().client("secretsmanager") + +# try: +# response = await run_sync_in_worker_thread( +# client.delete_secret, **delete_secret_kwargs +# ) +# response.pop("ResponseMetadata", None) +# return response +# except ClientError: +# logger.exception("Unable to delete secret %s", secret_name) +# raise + + +from obs_block import ObsBlock + +from prefect import get_run_logger, task +from prefect.blocks.abstract import SecretBlock +from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible +from pydantic import VERSION as PYDANTIC_VERSION + +if PYDANTIC_VERSION.startswith("2."): + from pydantic.v1 import Field +else: + from pydantic import Field + + + +class DEW(ObsBlock): + + _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png" # noqa + _block_type_name = "HuaweiCloud DEW" + _documentation_url = ("https://support.huaweicloud.com/intl/zh-cn/sdk-python-devg-obs/obs_22_0100.html") # noqa + obs: ObsBlock#用于向 HWC 进行身份验证的凭证。 + secret_name: str = Field(default=..., description="The name of the secret.")#密钥名字 + @sync_compatible + async def read_secret( + self, + version_id: str = None,#用于指定要读取的密钥的版本，默认最新 + version_stage: str = None,#指定密钥的某个阶段 + **read_kwargs: Dict[str, Any], + ) -> bytes: + """ + Reads the secret from the secret storage service. + + Args: + version_id: The version of the secret to read. If not provided, the latest + version will be read. + version_stage: The version stage of the secret to read. If not provided, + the latest version will be read. + read_kwargs: Additional keyword arguments to pass to the + `get_secret_value` method of the boto3 client. + + Returns: + The secret data. + + Examples: + Reads a secret. + ```python + secrets_manager = SecretsManager.load("MY_BLOCK") + secrets_manager.read_secret() + ``` + """ + client = self.obs._get_obs_client() + if version_id is not None: + read_kwargs["VersionId"] = version_id + if version_stage is not None: + read_kwargs["VersionStage"] = version_stage + response = await run_sync_in_worker_thread( + self.obs.huawei_cloud_security_token.get_secret_value, SecretId=self.secret_name, **read_kwargs + ) + if "SecretBinary" in response: + secret = response["SecretBinary"] + elif "SecretString" in response: + secret = response["SecretString"] + arn = response["ARN"] + self.logger.info(f"The secret {arn!r} data was successfully read.") + return secret diff --git a/build/lib/prefect_huaweicloud/dew_block.py b/build/lib/prefect_huaweicloud/dew_block.py new file mode 100644 index 0000000000000000000000000000000000000000..897de757935cb9a34bce24778f74078fdc9575f8 --- /dev/null +++ b/build/lib/prefect_huaweicloud/dew_block.py @@ -0,0 +1,73 @@ + +from typing import Any, Dict, List, Optional, Union + +from obs_block import ObsBlock +from pydantic import Field, SecretStr +from prefect import get_run_logger, task +from prefect.blocks.abstract import SecretBlock +from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible +from pydantic import VERSION as PYDANTIC_VERSION + +if PYDANTIC_VERSION.startswith("2."): + from pydantic.v1 import Field +else: + from pydantic import Field +from dewClient import DewClient +# from obs import DewClient +from huaweicloudsdkkms.v2.model import * +class DewBlock(SecretBlock): + + _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png" # noqa + _block_type_name = "HuaweiCloud DEW" + _documentation_url = ("https://support.huaweicloud.com/intl/zh-cn/sdk-python-devg-obs/obs_22_0100.html") # noqa + + huawei_cloud_access_key_id: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud access key ID.", + title="Huawei Cloud Access Key ID:", + ) + huawei_cloud_secret_access_key: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud secret access key.", + title="Huawei Cloud Access Key Secret:", + + ) + huawei_cloud_security_token: Optional[SecretStr] = Field( + default=None, + description="SecurityToken in the temporary access key, " + "You can select a temporary token or AK/SK for authentication", + title="Huawei Cloud Security Token", + ) + region_id:Optional[str] = Field( + default=None, + title="region id", + ) + def _get_dew_client(self) -> DewClient: + if self.huawei_cloud_security_token: + return DewClient( + security_token=self.huawei_cloud_security_token.get_secret_value(), + region_id=self.region_id, + ) + if not self.huawei_cloud_access_key_id or not self.huawei_cloud_secret_access_key: + raise Exception("please input both huawei_cloud_access_key_id and huawei_cloud_secret_access_key") + + return DewClient( + access_key_id=self.huawei_cloud_access_key_id.get_secret_value(), + secret_access_key=self.huawei_cloud_secret_access_key.get_secret_value(), + region_id=self.region_id, + ) + + + sync_compatible + async def read_secret(self,key_id:str=None,cipher_text:str=None): + client=self._get_dew_client() + if cipher_text is not None: + decrypt_data_key_response=client.decrypt_data_key(key_id=key_id, + cipher_text=cipher_text, + datakey_cipher_length=len(cipher_text)/2) + print(decrypt_data_key_response.cipher_text) + else: + key_value=client.create_data_key(key_id=key_id) + print(key_value.cipher_text) + + diff --git a/build/lib/prefect_huaweicloud/obs_block.py b/build/lib/prefect_huaweicloud/obs_block.py new file mode 100644 index 0000000000000000000000000000000000000000..bea8e36fb03e65bc3d7f5fc41f2c39c2cc0171da --- /dev/null +++ b/build/lib/prefect_huaweicloud/obs_block.py @@ -0,0 +1,364 @@ +import io +import json +import os +from logging import Logger +from typing import Optional +from pathlib import Path + +from obs import ObsClient + +from prefect.blocks.core import Block +from prefect.filesystems import WritableDeploymentStorage, WritableFileSystem +from pydantic import Field, SecretStr + +from prefect.utilities.asyncutils import sync_compatible, run_sync_in_worker_thread +from prefect.utilities.filesystem import filter_files +from prefect.logging.loggers import get_logger, get_run_logger +from prefect.exceptions import MissingContextError + + +class ObsBlock(WritableFileSystem, WritableDeploymentStorage, Block): + + + _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png" # noqa + _block_type_name = "HuaweiCloud Obs" + _documentation_url = ("https://support.huaweicloud.com/intl/zh-cn/sdk-python-devg-obs/obs_22_0100.html") # noqa + + huawei_cloud_access_key_id: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud access key ID.", + title="Huawei Cloud Access Key ID", + ) + huawei_cloud_secret_access_key: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud secret access key.", + title="Huawei Cloud Access Key Secret", + ) + huawei_cloud_security_token: Optional[SecretStr] = Field( + default=None, + description="SecurityToken in the temporary access key, " + "You can select a temporary token or AK/SK for authentication", + title="Huawei Cloud Security Token", + ) + end_point: str = Field( + default="https://obs.cn-south-1.myhuaweicloud.com", + description=( + "Service address for connecting to OBS. The value can contain the protocol type, domain name, " + "and port number. Example: https://your-endpoint:443. (For security purposes, HTTPS is recommended.)" + ), + title="End Point", + ) + bucket: str = Field( + default=None, + description=( + "Name of the bucket for creating a bucket client" + ), + title="Bucket", + ) + + prefix: Optional[str] = Field( + default=None, + description=( + "Name prefix that the objects to be listed must contain. example: xxx/xxx. prefix cannot start with /" + ), + title="Prefix", + ) + + extra_params: Optional[str] = Field( + default='{}', + description=( + "Additional parameters such as max_retry_count," + " max_redirect_count, and ssl_verify are written in JSON format," + " as shown in {'max_retry_count': 3,'max_redirect_count': 2}." + "Detailed link: https://support.huaweicloud.com/intl/en-us/sdk-python-devg-obs/obs_22_0601.html" + ), + title="Extra Params", + ) + + @property + def logger(self) -> Logger: + """ + Returns a logger based on whether the ObjectStorageBlock + is called from within a flow or task run context. + If a run context is present, the logger property returns a run logger. + Else, it returns a default logger labeled with the class's name. + + Returns: + The run logger or a default logger with the class's name. + """ + try: + return get_run_logger() + except MissingContextError: + return get_logger(self.__class__.__name__) + + @sync_compatible + async def read_path(self, path: str) -> bytes: + """ + Reading OBS File Objects + Args: + path: OBS File Object Key + + Returns: OBS File BytesIO + + """ + path = self._resolve_path(path) + return await run_sync_in_worker_thread(self._download_file_object, path) + + @sync_compatible + async def write_path(self, path: str, content: bytes) -> None: + """ + Writing a File Object to OBS + Args: + path: OBS Storage Path + content: File Object Flow + Returns: + + """ + path = self._resolve_path(path) + + await run_sync_in_worker_thread(self._upload_file_object, path, content) + + return path + + @sync_compatible + async def get_directory( + self, from_path: str = None, local_path: str = None + ) -> None: + """ + Download all files from the folder path in the OBS bucket to the local path. + Args: + from_path: obs dir path + local_path: local dir path + + Returns: + + """ + + folder_path = self.prefix if not self.prefix == "/" else None + if from_path is None: + from_path = str(folder_path) if folder_path else None + + if local_path is None: + local_path = str(Path("..").absolute()) + else: + local_path = str(Path(local_path).expanduser()) + obs_client = self._get_obs_client() + for path, is_dir in self._bucket_list_object(from_path): + self.logger.info(path) + target_path = os.path.join( + local_path, + path + ) + target_path = os.path.normpath(target_path) + if is_dir: + os.makedirs(target_path, exist_ok=True) + continue + try: + resp = obs_client.getObject(self.bucket, path, downloadPath=target_path) + if resp.status < 300: + self.logger.info('requestId: %s', resp.requestId) + else: + self.logger.error('errorCode: %s', resp.errorCode) + self.logger.error('errorMessage: %s', resp.errorMessage) + except Exception as e: + import traceback + self.logger.error(traceback.format_exc()) + + @sync_compatible + async def put_directory( + self, local_path: str = None, to_path: str = None, ignore_file: str = None + ) -> int: + """ + Pushes all files in the local folder to the specified folder in the OBS bucket. + + Args: + local_path: Path to local directory to upload from. + to_path: Path in OBS bucket to upload to. Defaults to block's configured + basepath. + ignore_file: Path to file containing gitignore style expressions for + filepaths to ignore. + Returns: + + """ + + if local_path is None: + raise Exception("local_path can't be None") + + local_path = os.path.normpath(local_path) + included_files = None + if ignore_file: + with open(ignore_file, "r") as f: + ignore_patterns = f.readlines() + + included_files = filter_files(local_path, ignore_patterns) + + uploaded_file_count = 0 + for local_file_path in Path(local_path).expanduser().rglob("*"): + if ( + included_files is not None + and str(local_file_path.relative_to(local_path)) not in included_files + ): + continue + elif not local_file_path.is_dir(): + remote_file_path = Path(to_path) / local_file_path.relative_to( + local_path + ) + with open(local_file_path, "rb") as local_file: + local_file_content = local_file.read() + + await self.write_path( + path=remote_file_path.as_posix(), content=local_file_content + ) + uploaded_file_count += 1 + + return uploaded_file_count + + def _get_obs_client(self) -> ObsClient: + """ + The authenticated OBS client is returned. You can select a temporary token or AK/SK for authentication. + Returns: ObsClient + """ + extra_params = json.loads(self.extra_params) + + if self.huawei_cloud_security_token: + return ObsClient( + security_token=self.huawei_cloud_security_token.get_secret_value(), + server=self.end_point, + **extra_params + ) + if not self.huawei_cloud_access_key_id or not self.huawei_cloud_secret_access_key: + raise Exception("please input both huawei_cloud_access_key_id and huawei_cloud_secret_access_key") + + return ObsClient( + access_key_id=self.huawei_cloud_access_key_id.get_secret_value(), + secret_access_key=self.huawei_cloud_secret_access_key.get_secret_value(), + server=self.end_point, + **extra_params + ) + + def _resolve_path(self, path): + """ + Concatenate the file object path based on the preset path prefix. + + Args: + path: Path before splicing + + Returns: Path after splicing + + """ + + path = ( + (Path(self.prefix) / path).as_posix() if self.prefix else path + ) + + return path + + def _download_file_object_inner(self, obs_client, key, stream): + resp = obs_client.getObject(self.bucket, key, loadStreamInMemory=False) + + if resp.status < 300: + self.logger.info('requestId: %s', resp.requestId) + # 读取对象内容 + while True: + chunk = resp.body.response.read(65536) + if not chunk: + break + stream.write(chunk) + resp.body.response.close() + else: + self.logger.error('errorCode: %s', resp.errorCode) + self.logger.error('errorMessage: %s', resp.errorMessage) + + def _download_file_object(self, key: str): + """ + Downloading a File Object from OBS + + Args: + key: OBS File Object Key + + Returns: OBS File BytesIO + + """ + obs_client = self._get_obs_client() + with io.BytesIO() as stream: + try: + self._download_file_object_inner(obs_client, key, stream) + except Exception as e: + import traceback + self.logger.error(traceback.format_exc()) + stream.seek(0) + output = stream.read() + obs_client.close() + return output + + def _upload_file_object(self, path: str, data: bytes) -> None: + """ + Uploading a File Object to OBS + Args: + path: OBS Storage Path + data: File Object Flow + + Returns: + + """ + obs_client = self._get_obs_client() + try: + + resp = obs_client.putContent(self.bucket, path, content=data) + + if resp.status < 300: + self.logger.info('requestId: %s', resp.requestId) + else: + self.logger.error('errorCode: %s', resp.errorCode) + self.logger.error('errorMessage: %s', resp.errorMessage) + except Exception as e: + import traceback + self.logger.error(traceback.format_exc()) + + def _bucket_list_object_inner(self, obs_client, prefix, mark, max_num): + object_list = [] + resp = obs_client.listObjects(self.bucket, prefix=prefix, marker=mark, max_keys=max_num) + self.logger.info(resp) + if resp.status < 300: + self.logger.info('requestId: %s', resp.requestId) + index = 1 + for content in resp.body.contents: + self.logger.info('object [%s]', str(index)) + index += 1 + if content.size == 0: + object_list.append((content.key, True)) + else: + object_list.append((content.key, False)) + if resp.body.is_truncated is True: + return object_list, False, resp.body.next_marker + else: + return object_list, True, resp.body.next_marker + else: + self.logger.error('errorCode: %s', resp.errorCode) + self.logger.error('errorMessage: %s', resp.errorMessage) + return [], True, False + + def _bucket_list_object(self, prefix): + """ + Querying All Objects in a Bucket + Args: + prefix: Path Prefix + + Returns: file object key and is dir bool + + """ + obs_client = self._get_obs_client() + max_num = 1000 + mark = None + all_object_list = [] + is_break = False + try: + while not is_break: + object_list, is_break, mark = self._bucket_list_object_inner(obs_client, prefix, mark, max_num) + all_object_list.extend(object_list) + except Exception as e: + import traceback + self.logger.error(traceback.format_exc()) + finally: + obs_client.close() + return all_object_list diff --git a/dew_block.py b/dew_block.py new file mode 100644 index 0000000000000000000000000000000000000000..21b1a6a660fb564b4eae0019c233fe627e8a8f1b --- /dev/null +++ b/dew_block.py @@ -0,0 +1,978 @@ + +from typing import Any, Dict, List, Optional, Union +from logging import Logger +from pydantic import Field, SecretStr +# from prefect import get_run_logger, task +from prefect.blocks.abstract import SecretBlock +from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible +from prefect.logging.loggers import get_logger, get_run_logger +from prefect.exceptions import MissingContextError +from prefect import task +from pydantic import VERSION as PYDANTIC_VERSION +import json +if PYDANTIC_VERSION.startswith("2."): + from pydantic.v1 import Field +else: + from pydantic import Field +from prefect_huaweicloud.dew_client import DewClient +# from obs import DewClient +from huaweicloudsdkkms.v2.model import * +from huaweicloudsdkcore.exceptions import exceptions + +from huaweicloudsdkkms.v2.region.kms_region import KmsRegion +from huaweicloudsdkkps.v3.region.kps_region import KpsRegion +from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion +from huaweicloudsdkcsms.v1 import * +from huaweicloudsdkkms.v2 import * +from huaweicloudsdkkps.v3 import * +class DewBlock(SecretBlock): + + _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png" # noqa + _block_type_name = "HuaweiCloud DEW" + _documentation_url = ("https://support.huaweicloud.com/intl/zh-cn/sdk-python-devg-obs/obs_22_0100.html") # noqa + + huawei_cloud_access_key_id: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud access key ID.", + title="Huawei Cloud Access Key ID:", + ) + huawei_cloud_secret_access_key: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud secret access key.", + title="Huawei Cloud Access Key Secret:", + + ) + huawei_cloud_security_token: Optional[SecretStr] = Field( + default=None, + description="SecurityToken in the temporary access key, " + "You can select a temporary token or AK/SK for authentication", + title="Huawei Cloud Security Token", + ) + region_id:Optional[str] = Field( + default=None, + title="region id", + ) + def _get_dew_client(self) -> DewClient: + if not self.huawei_cloud_access_key_id or not self.huawei_cloud_secret_access_key: + raise Exception("please input both huawei_cloud_access_key_id and huawei_cloud_secret_access_key") + + return DewClient( + ak=self.huawei_cloud_access_key_id.get_secret_value(), + sk=self.huawei_cloud_secret_access_key.get_secret_value(), + region_id=self.region_id, + ) + + + @sync_compatible + async def read_secret(self,key_id:str=None,cipher_text:str=None,**kwargs): + + response =await run_sync_in_worker_thread(self._get_dew_client().decrypt_data_key, key_id,cipher_text,32) + if hasattr(response, 'status_code') and response.status_code==200: + self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully read.") + return response + + @sync_compatible + async def write_secret(self,key_id:str=None,plain_text:str=None,**kwargs): + global encrypt_data_key_response + if key_id is None : + new_key = await run_sync_in_worker_thread(self._get_dew_client().create_key,key_alias="new_key",key_spec="AES_256") + new_data_key = await run_sync_in_worker_thread(self._get_dew_client().create_data_key,new_key.key_id) + encrypt_data_key_response = await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, new_key.key_id, plain_text or new_data_key.plain_text,32) + + elif plain_text is None: + new_data_key =await run_sync_in_worker_thread(self._get_dew_client().create_data_key, key_id) + encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, key_id, new_data_key.plain_text,32) + + else: + encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key,key_id,plain_text,32) + + if hasattr(encrypt_data_key_response, 'status_code') and encrypt_data_key_response.status_code==200: + self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully write.") + return encrypt_data_key_response + + @sync_compatible + async def delete_secret(self, key_id,pending_days,**kwargs): + + response =await run_sync_in_worker_thread(self._get_dew_client().delete_key,key_id=key_id,pending_days=pending_days) + if hasattr(response, 'status_code') and response.status_code==200: + self.logger.info(f"The secret {key_id} was deleted successfully.") + return response + + @property + def logger(self) -> Logger: + """ + Returns a logger based on whether the ObjectStorageBlock + is called from within a flow or task run context. + If a run context is present, the logger property returns a run logger. + Else, it returns a default logger labeled with the class's name. + + Returns: + The run logger or a default logger with the class's name. + """ + try: + return get_run_logger() + except MissingContextError: + return get_logger(self.__class__.__name__) + + def create_key(self,key_alias=None, key_spec=None, key_usage=None, key_description=None, origin=None, enterprise_project_id=None, sequence=None, keystore_id=None,**kwargs): + try: + request = CreateKeyRequest() + request.body = CreateKeyRequestBody( + key_alias=key_alias, + key_spec=key_spec, + key_usage=key_usage, + key_description=key_description, + origin=origin, + enterprise_project_id=enterprise_project_id, + sequence=sequence, + keystore_id=keystore_id + ) + response =self._get_dew_client().kms_client.create_key(request) + self.logger.debug("Created key") + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def delete_key(self,key_id=None,pending_days=None, sequence=None,**kwargs): + try: + request = DeleteKeyRequest() + request.body = ScheduleKeyDeletionRequestBody( + key_id=key_id, + pending_days=pending_days, + sequence=sequence + ) + response = self._get_dew_client().kms_client.delete_key(request) + self.logger.debug("Successfully delete_key") + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def disable_key(self,key_id=None,sequence=None,**kwargs): + try: + request = DisableKeyRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response =self._get_dew_client().kms_client.disable_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def enable_key(self,key_id=None, sequence=None,**kwargs): + try: + request = EnableKeyRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response =self._get_dew_client().kms_client.enable_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_key_Alias(self,key_id=None, key_alias=None, sequence=None,**kwargs): + try: + request = UpdateKeyAliasRequest() + request.body = UpdateKeyAliasRequestBody( + key_alias=key_alias, + key_id=key_id, + sequence=sequence + ) + response =self._get_dew_client().kms_client.update_key_alias(request) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_key_description(self,key_id=None, key_description=None, sequence=None,**kwargs): + try: + request = UpdateKeyDescriptionRequest() + request.body = UpdateKeyDescriptionRequestBody( + key_id=key_id, + key_description=key_description, + sequence=sequence + ) + response =self._get_dew_client().kms_client.update_key_description(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def cancel_key_deletion(self,key_id=None,sequence=None,**kwargs): + try: + request = CancelKeyDeletionRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.cancel_key_deletion(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def create_data_key(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs): + try: + request = CreateDatakeyRequest() + request.body = CreateDatakeyRequestBody( + key_id=key_id, + key_spec=key_spec, + datakey_length=datakey_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_datakey(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_data_key_without_plaintext(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs): + try: + request = CreateDatakeyWithoutPlaintextRequest() + request.body = CreateDatakeyRequestBody( + key_id=key_id, + key_spec=key_spec, + datakey_length=datakey_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_datakey_without_plaintext(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_random(self,random_data_length=None, sequence=None,**kwargs): + try: + request = CreateRandomRequest() + request.body = GenRandomRequestBody( + random_data_length=random_data_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_random(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def decrypt_data_key(self,key_id=None, cipher_text=None, datakey_cipher_length=None, sequence=None,**kwargs): + try: + request = DecryptDatakeyRequest() + request.body = DecryptDatakeyRequestBody( + key_id=key_id, + cipher_text=cipher_text, + datakey_cipher_length=datakey_cipher_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.decrypt_datakey(request) + self.logger.info(response) + return response + + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def encrypt_data_key(self,key_id=None, plain_text=None, datakey_plain_length=None, sequence=None,**kwargs): + try: + request = EncryptDatakeyRequest() + request.body = EncryptDatakeyRequestBody( + key_id=key_id, + plain_text=plain_text, + datakey_plain_length=datakey_plain_length, + sequence=sequence + + ) + response = self._get_dew_client().kms_client.encrypt_datakey(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def create_parameters_for_import(self,key_id,wrapping_algorithm=None, sequence=None,**kwargs): + try: + request = CreateParametersForImportRequest() + request.body = GetParametersForImportRequestBody( + key_id=key_id, + wrapping_algorithm=wrapping_algorithm, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_parameters_for_import(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_imported_key_material(self,key_id,sequence=None,**kwargs): + try: + request = DeleteImportedKeyMaterialRequest() + request.body = OperateKeyRequestBody( + key_id = key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.delete_imported_key_material(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def import_key_material(self,key_id=None, import_token=None, encrypted_key_material=None, encrypted_privatekey=None, expiration_time=None, sequence=None,**kwargs): + try: + request = ImportKeyMaterialRequest() + request.body = ImportKeyMaterialRequestBody( + key_id=key_id, + import_token=import_token, + encrypted_key_material=encrypted_key_material, + encrypted_privatekey=encrypted_privatekey, + expiration_time=expiration_time, + sequence=sequence + ) + response = self._get_dew_client().kms_client.import_key_material(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def decrypt_data(self,cipher_text=None, encryption_algorithm=None, key_id=None, sequence=None,**kwargs): + try: + request = DecryptDataRequest() + request.body = DecryptDataRequestBody( + cipher_text=cipher_text, + encryption_algorithm=encryption_algorithm, + key_id=key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.decrypt_data(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def encrypt_data(self,key_id=None,plain_text=None, encryption_algorithm=None, sequence=None,**kwargs): + try: + request = EncryptDataRequest() + request.body = EncryptDataRequestBody( + plain_text=plain_text, + key_id=key_id, + encryption_algorithm=encryption_algorithm, + sequence=sequence + ) + response = self._get_dew_client().kms_client.encrypt_data(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def list_key_detail(self,key_id=None,sequence=None,**kwargs): + try: + request = ListKeyDetailRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.list_key_detail(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keys(self,limit=None, marker=None, key_state=None, key_spec=None, enterprise_project_id=None, sequence=None,**kwargs): + try: + request = ListKeysRequest() + request.body = ListKeysRequestBody( + limit=limit, + marker=marker, + key_state=key_state, + key_spec=key_spec, + enterprise_project_id=enterprise_project_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.list_keys(request) + # print(response.to_dict()) + print(json.dumps(response.to_dict()).replace('}','}\n')) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_public_key(self,key_id=None, sequence=None,**kwargs): + try: + request = ShowPublicKeyRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, sequence=sequence + ) + response = self._get_dew_client().kms_client.show_public_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_user_instances(self,**kwargs): + try: + request = ShowUserInstancesRequest() + response = self._get_dew_client().kms_client.show_user_instances(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_user_quotas(self,**kwargs): + try: + request = ShowUserQuotasRequest() + response = self._get_dew_client().kms_client.show_user_quotas(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def show_version(self,**kwargs): + try: + request = ShowVersionRequest(kwargs) + response = self._get_dew_client().kms_client.show_version(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_versions(self,**kwargs): + try: + request = ShowVersionsRequest() + response = self._get_dew_client().kms_client.show_versions(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_keypair(self,name=None, type=None, public_key=None, scope=None, user_id=None, key_protection=None,**kwargs): + try: + request = CreateKeypairRequest() + keypairbody = CreateKeypairAction( + name=name, + type=type, + public_key=public_key, + scope=scope, + user_id=user_id, + key_protection=key_protection + ) + request.body = CreateKeypairRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.create_keypair(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keypairs(self,limit=None, marker=None,**kwargs): + try: + request = ListKeypairsRequest( + limit=limit, + marker=marker + ) + response = self._get_dew_client().kps_client.list_keypairs(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def clear_private_key(self,keypair_name=None,**kwargs): + try: + request = ClearPrivateKeyRequest(keypair_name=keypair_name) + response = self._get_dew_client().kps_client.clear_private_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def import_private_key(self,user_id=None, name=None,type="default",kms_key_name="kps/default",private_key=None,**kwargs): + try: + request = ImportPrivateKeyRequest() + encryptionKeyProtection = Encryption( + type=type, + kms_key_name=kms_key_name + ) + keyProtectionKeypair = ImportPrivateKeyProtection( + private_key=private_key, + encryption=encryptionKeyProtection + ) + keypairbody = ImportPrivateKeyKeypairBean( + name=name, + key_protection=keyProtectionKeypair, + user_id=user_id + ) + request.body = ImportPrivateKeyRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.import_private_key(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keypair_detail(self,keypair_name=None,**kwargs): + try: + request = ListKeypairDetailRequest(keypair_name=keypair_name) + response = self._get_dew_client().kps_client.list_keypair_detail(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_keypair_description(self,keypair_name=None,description=None,**kwargs): + try: + request = UpdateKeypairDescriptionRequest( + keypair_name=keypair_name + ) + keypairbody = UpdateKeypairDescriptionReq( + description=description + ) + request.body = UpdateKeypairDescriptionRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.update_keypair_description(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def export_private_key(self,name=None,**kwargs): + try: + request = ExportPrivateKeyRequest() + keypairbody = KeypairBean( + name=name + ) + request.body = ExportPrivateKeyRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.export_private_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_keypair(self,keypair_name=None,**kwargs): + try: + request = DeleteKeypairRequest(keypair_name=keypair_name) + response = self._get_dew_client().kps_client.delete_keypair(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def associate_keypair(self,keypair_name=None,type=None,key=None,id=None, disable_password=False, port=None,**kwargs): + try: + request = AssociateKeypairRequest() + authServer = Auth( + type=type, + key=key + ) + serverbody = EcsServerInfo( + id=id, + auth=authServer, + disable_password=disable_password, + port=port + ) + request.body = AssociateKeypairRequestBody( + server=serverbody, + keypair_name=keypair_name + ) + response = self._get_dew_client().kps_client.associate_keypair(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def batch_associate_keypair(self,keypair_name=[],type=[],key=[],id=[],disable_password=[],port=[],**kwargs): + try: + request = BatchAssociateKeypairRequest() + listBatchKeypairsbody = [] + for s in range(len(keypair_name),**kwargs): + authServer = Auth( + type=type[s], + key=key[s] + ) + serverBatchKeypairs = EcsServerInfo( + id=id[s], + auth=authServer, + disable_password=disable_password[s], + port=port[s] + ) + listBatchKeypairsbody.append(AssociateKeypairRequestBody( + keypair_name=keypair_name[s], + server=serverBatchKeypairs + )) + + request.body = BatchAssociateKeypairRequestBody( + batch_keypairs=listBatchKeypairsbody + ) + response = self._get_dew_client().kps_client.batch_associate_keypair(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_all_failed_task(self,**kwargs): + try: + request = DeleteAllFailedTaskRequest() + response = self._get_dew_client().kps_client.delete_all_failed_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_failed_task(self,task_id,**kwargs): + try: + request = DeleteFailedTaskRequest( + task_id=task_id, + ) + response = self._get_dew_client().kps_client.delete_failed_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def disassociate_keypair(self,id=None,type=None,key=None,**kwargs): + try: + request = DisassociateKeypairRequest() + authServer = Auth( + type=type, + key=key + ) + serverbody = DisassociateEcsServerInfo( + id=id, + auth=authServer + ) + request.body = DisassociateKeypairRequestBody( + server=serverbody + ) + response = self._get_dew_client().kps_client.disassociate_keypair(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_failed_task(self,limit=None, offset=None,**kwargs): + try: + request = ListFailedTaskRequest() + request.limit = limit + request.offset = offset + response = self._get_dew_client().kps_client.list_failed_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keypair_task(self,task_id=None,**kwargs): + try: + request = ListKeypairTaskRequest( + task_id=task_id + ) + response = self._get_dew_client().kps_client.list_keypair_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_running_task(self,limit=None,offset=None,**kwargs): + try: + request = ListRunningTaskRequest() + request.limit = limit + request.offset = offset + response = self._get_dew_client().kps_client.list_running_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_secret(self,name=None, kms_key_id=None, description=None, secret_binary=None, secret_string=None, secret_type=None, auto_rotation=None, rotation_period=None, rotation_config=None, event_subscriptions=None, enterprise_project_id=None,**kwargs): + try: + request = CreateSecretRequest() + request.body = CreateSecretRequestBody( + secret_string=secret_string, + kms_key_id=kms_key_id, + name=name, + description=description, + secret_binary=secret_binary, + secret_type=secret_type, + auto_rotation=auto_rotation, + rotation_period=rotation_period, + rotation_config=rotation_config, + event_subscriptions=event_subscriptions, + enterprise_project_id=enterprise_project_id + ) + response = self._get_dew_client().cms_client.create_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def download_secret_blob(self,secret_name:None,**kwargs): + try: + request = DownloadSecretBlobRequest( + secret_name=secret_name + ) + response = self._get_dew_client().cms_client.download_secret_blob(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_secrets(self,limit=None,marker=None,event_name=None,**kwargs): + try: + request = ListSecretsRequest() + request.limit = limit + request.marker = marker + request.event_name = event_name + response = self._get_dew_client().cms_client.list_secrets(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_secret(self,secret_name,**kwargs): + try: + request = ShowSecretRequest( + secret_name=secret_name + ) + response = self._get_dew_client().cms_client.show_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_secret(self,kms_key_id=None,secret_name=None, description=None, auto_rotation=None, rotation_period=None, listEventSubscriptionsbody=None,**kwargs): + try: + request = UpdateSecretRequest() + request.body = UpdateSecretRequestBody( + event_subscriptions=listEventSubscriptionsbody, + description=description, + kms_key_id=kms_key_id, + auto_rotation=auto_rotation, + rotation_period=rotation_period, + ) + request.secret_name=secret_name + response = self._get_dew_client().cms_client.update_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_secret_event(self,target_type=None, target_id=None, target_name=None,name=None, state=None, listEventTypesbody=[],**kwargs): + try: + request = CreateSecretEventRequest() + notificationbody = Notification( + target_type=target_type, + target_id=target_id, + target_name=target_name + ) + request.body = CreateSecretEventRequestBody( + notification=notificationbody, + state=state, + event_types=listEventTypesbody, + name=name, + ) + response = self._get_dew_client().cms_client.create_secret_event(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def upload_secret_blob(self,secret_blob,**kwargs): + try: + request = UploadSecretBlobRequest() + request.body = UploadSecretBlobRequestBody( + secret_blob=secret_blob + ) + response = self._get_dew_client().cms_client.upload_secret_blob(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + print(e.status_code) + print(e.request_id) + print(e.error_code) + def rotate_secret(self,secret_name=None,**kwargs): + try: + request = RotateSecretRequest( + secret_name=secret_name + ) + response = self._get_dew_client().cms_client.rotate_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def restore_secret(self,secret_name,**kwargs): + try: + request = RestoreSecretRequest(secret_name=secret_name) + response = self._get_dew_client().cms_client.restore_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_secret_for_schedule(self,recovery_window_in_days=None,secret_name=None,**kwargs): + try: + request = DeleteSecretForScheduleRequest(secret_name=secret_name) + request.body = DeleteSecretForScheduleRequestBody( + recovery_window_in_days=recovery_window_in_days + ) + response = self._get_dew_client().cms_client.delete_secret_for_schedule(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_secret(self,secret_name,**kwargs): + try: + request = DeleteSecretRequest(secret_name=secret_name) + response = self._get_dew_client().cms_client.delete_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def create_secret_version(self,secret_name=None,secret_binary=None, secret_string=None, version_stages=None, expire_time=None,**kwargs): + try: + request = CreateSecretVersionRequest(secret_name=secret_name) + request.body = CreateSecretVersionRequestBody( + secret_string=secret_string, + secret_binary=secret_binary, + version_stages=version_stages, + expire_time=expire_time + ) + response = self._get_dew_client().cms_client.create_secret_version(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_secret_versions(self,secret_name=None, marker=None, limit=None,**kwargs): + try: + request = ListSecretVersionsRequest() + request.secret_name = secret_name + request.marker = marker + request.limit = limit + response = self._get_dew_client().cms_client.list_secret_versions(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def show_secret_version(self,secret_name=None,version_id=None,**kwargs): + try: + request = ShowSecretVersionRequest() + request.secret_name=secret_name + request.version_id = version_id + response = self._get_dew_client().cms_client.show_secret_version(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_version(self,secret_name=None, version_id=None, expire_time=None,**kwargs): + try: + request = UpdateVersionRequest() + request.version_id=version_id + request.secret_name=secret_name + request.body = UpdateVersionRequestBody( + expire_time=expire_time + ) + response = self._get_dew_client().cms_client.update_version(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + diff --git a/dew_client.py b/dew_client.py new file mode 100644 index 0000000000000000000000000000000000000000..8067916da363f2552eb5fe6d5ee8c3ca8e732a67 --- /dev/null +++ b/dew_client.py @@ -0,0 +1,44 @@ +from huaweicloudsdkcore.auth.credentials import BasicCredentials +from huaweicloudsdkcore.exceptions import exceptions +from huaweicloudsdkkms.v2.region.kms_region import KmsRegion +from huaweicloudsdkkms.v2 import * +from huaweicloudsdkkps.v3.region.kps_region import KpsRegion +from huaweicloudsdkkps.v3 import * +from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion +from huaweicloudsdkcsms.v1 import * +from typing import Any, Coroutine, Dict, List, Optional, Union + +from prefect import get_run_logger, task +from prefect.blocks.abstract import SecretBlock +from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible +from pydantic import VERSION as PYDANTIC_VERSION +import json +if PYDANTIC_VERSION.startswith("2."): + from pydantic.v1 import Field +else: + from pydantic import Field +class DewClient(): + def __init__(self,region_id:str,ak:str,sk:str): + self.region_id=region_id + self.__ak=ak + self.__sk=sk + @property + def kms_client(self)->KmsClient: + return KmsClient.new_builder() \ + .with_credentials(BasicCredentials(self.__ak,self.__sk)) \ + .with_region(KmsRegion.value_of(self.region_id)) \ + .build() + @property + def kps_client(self)->KpsClient: + return KpsClient.new_builder() \ + .with_credentials(BasicCredentials(self.__ak,self.__sk)) \ + .with_region(KpsRegion.value_of(self.region_id)) \ + .build() + @property + def cms_client(self)->CsmsClient: + return CsmsClient.new_builder() \ + .with_credentials(BasicCredentials(self.__ak,self.__sk)) \ + .with_region(CsmsRegion.value_of(self.region_id)) \ + .build() + + \ No newline at end of file diff --git a/dist/prefect_hwc-0.1.0-py3.11.egg b/dist/prefect_hwc-0.1.0-py3.11.egg new file mode 100644 index 0000000000000000000000000000000000000000..ffcf719b61b09c205ae7af79933a3d270a55095c Binary files /dev/null and b/dist/prefect_hwc-0.1.0-py3.11.egg differ diff --git a/prefect_huaweicloud/__init__.py b/prefect_huaweicloud/__init__.py index e5be0e0db4e10ff186c46c66f08dd528c7c057ec..a134201b68ec103e31fa8220bec7dcb51f87d0e3 100644 --- a/prefect_huaweicloud/__init__.py +++ b/prefect_huaweicloud/__init__.py @@ -1,5 +1,5 @@ # ensure core blocks are registered from prefect_huaweicloud.obs_block import ObsBlock - +# from prefect_huaweicloud.dew import DEW __all__ = ["ObsBlock"] diff --git a/prefect_huaweicloud/__pycache__/__init__.cpython-311.pyc b/prefect_huaweicloud/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dcc14e43ce871cbb94b0da8a350b27ab7cc26f68 Binary files /dev/null and b/prefect_huaweicloud/__pycache__/__init__.cpython-311.pyc differ diff --git a/prefect_huaweicloud/__pycache__/dew.cpython-311.pyc b/prefect_huaweicloud/__pycache__/dew.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..07844b1c964d32163167b14850d01dd14519c366 Binary files /dev/null and b/prefect_huaweicloud/__pycache__/dew.cpython-311.pyc differ diff --git a/prefect_huaweicloud/__pycache__/dewClient.cpython-311.pyc b/prefect_huaweicloud/__pycache__/dewClient.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5fd7b665985dab71746198630460b5662b0e24b9 Binary files /dev/null and b/prefect_huaweicloud/__pycache__/dewClient.cpython-311.pyc differ diff --git a/prefect_huaweicloud/__pycache__/dew_block.cpython-311.pyc b/prefect_huaweicloud/__pycache__/dew_block.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3140263a8fd1d25525d793b4647fdb7522fafcd9 Binary files /dev/null and b/prefect_huaweicloud/__pycache__/dew_block.cpython-311.pyc differ diff --git a/prefect_huaweicloud/__pycache__/dew_client.cpython-311.pyc b/prefect_huaweicloud/__pycache__/dew_client.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..87458fa098986daee98fdb412f297c5c4dd9504d Binary files /dev/null and b/prefect_huaweicloud/__pycache__/dew_client.cpython-311.pyc differ diff --git a/prefect_huaweicloud/__pycache__/obs_block.cpython-311.pyc b/prefect_huaweicloud/__pycache__/obs_block.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..803a70732afbfe4f346d45db73d25728ecbedb93 Binary files /dev/null and b/prefect_huaweicloud/__pycache__/obs_block.cpython-311.pyc differ diff --git a/prefect_huaweicloud/dew_block.py b/prefect_huaweicloud/dew_block.py new file mode 100644 index 0000000000000000000000000000000000000000..a7fa143ade665fb9d61b427ada3eb108fc653d07 --- /dev/null +++ b/prefect_huaweicloud/dew_block.py @@ -0,0 +1,942 @@ + +from typing import Any, Dict, List, Optional, Union +from logging import Logger +from pydantic import Field, SecretStr +# from prefect import get_run_logger, task +from prefect.blocks.abstract import Block +from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible +from prefect.logging.loggers import get_logger, get_run_logger +from prefect.exceptions import MissingContextError +from prefect import task +from pydantic import VERSION as PYDANTIC_VERSION +import json +if PYDANTIC_VERSION.startswith("2."): + from pydantic.v1 import Field +else: + from pydantic import Field +from prefect_huaweicloud.dew_client import DewClient +# from obs import DewClient +from huaweicloudsdkkms.v2.model import * +from huaweicloudsdkcore.exceptions import exceptions + +from huaweicloudsdkkms.v2.region.kms_region import KmsRegion +from huaweicloudsdkkps.v3.region.kps_region import KpsRegion +from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion +from huaweicloudsdkcsms.v1 import * +from huaweicloudsdkkms.v2 import * +from huaweicloudsdkkps.v3 import * +class DewBlock(Block): + + _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png" # noqa + _block_type_name = "HuaweiCloud DEW" + _documentation_url = ("https://support.huaweicloud.com/intl/zh-cn/sdk-python-devg-obs/obs_22_0100.html") # noqa + + huawei_cloud_access_key_id: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud access key ID.", + title="Huawei Cloud Access Key ID:", + ) + huawei_cloud_secret_access_key: Optional[SecretStr] = Field( + default=None, + description="A specific Huawei Cloud secret access key.", + title="Huawei Cloud Access Key Secret:", + + ) + huawei_cloud_security_token: Optional[SecretStr] = Field( + default=None, + description="SecurityToken in the temporary access key, " + "You can select a temporary token or AK/SK for authentication", + title="Huawei Cloud Security Token", + ) + region_id:Optional[str] = Field( + default=None, + title="region id", + ) + def _get_dew_client(self) -> DewClient: + if not self.huawei_cloud_access_key_id or not self.huawei_cloud_secret_access_key: + raise Exception("please input both huawei_cloud_access_key_id and huawei_cloud_secret_access_key") + + return DewClient( + ak=self.huawei_cloud_access_key_id.get_secret_value(), + sk=self.huawei_cloud_secret_access_key.get_secret_value(), + region_id=self.region_id, + ) + + @property + def logger(self) -> Logger: + """ + Returns a logger based on whether the ObjectStorageBlock + is called from within a flow or task run context. + If a run context is present, the logger property returns a run logger. + Else, it returns a default logger labeled with the class's name. + + Returns: + The run logger or a default logger with the class's name. + """ + try: + return get_run_logger() + except MissingContextError: + return get_logger(self.__class__.__name__) + + def create_key(self,key_alias=None, key_spec=None, key_usage=None, key_description=None, origin=None, enterprise_project_id=None, sequence=None, keystore_id=None,**kwargs): + try: + request = CreateKeyRequest() + request.body = CreateKeyRequestBody( + key_alias=key_alias, + key_spec=key_spec, + key_usage=key_usage, + key_description=key_description, + origin=origin, + enterprise_project_id=enterprise_project_id, + sequence=sequence, + keystore_id=keystore_id + ) + response =self._get_dew_client().kms_client.create_key(request) + self.logger.debug("Created key") + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def delete_key(self,key_id=None,pending_days=None, sequence=None,**kwargs): + try: + request = DeleteKeyRequest() + request.body = ScheduleKeyDeletionRequestBody( + key_id=key_id, + pending_days=pending_days, + sequence=sequence + ) + response = self._get_dew_client().kms_client.delete_key(request) + self.logger.debug("Successfully delete_key") + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def disable_key(self,key_id=None,sequence=None,**kwargs): + try: + request = DisableKeyRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response =self._get_dew_client().kms_client.disable_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def enable_key(self,key_id=None, sequence=None,**kwargs): + try: + request = EnableKeyRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response =self._get_dew_client().kms_client.enable_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_key_Alias(self,key_id=None, key_alias=None, sequence=None,**kwargs): + try: + request = UpdateKeyAliasRequest() + request.body = UpdateKeyAliasRequestBody( + key_alias=key_alias, + key_id=key_id, + sequence=sequence + ) + response =self._get_dew_client().kms_client.update_key_alias(request) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_key_description(self,key_id=None, key_description=None, sequence=None,**kwargs): + try: + request = UpdateKeyDescriptionRequest() + request.body = UpdateKeyDescriptionRequestBody( + key_id=key_id, + key_description=key_description, + sequence=sequence + ) + response =self._get_dew_client().kms_client.update_key_description(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def cancel_key_deletion(self,key_id=None,sequence=None,**kwargs): + try: + request = CancelKeyDeletionRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.cancel_key_deletion(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def create_data_key(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs): + try: + request = CreateDatakeyRequest() + request.body = CreateDatakeyRequestBody( + key_id=key_id, + key_spec=key_spec, + datakey_length=datakey_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_datakey(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_data_key_without_plaintext(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs): + try: + request = CreateDatakeyWithoutPlaintextRequest() + request.body = CreateDatakeyRequestBody( + key_id=key_id, + key_spec=key_spec, + datakey_length=datakey_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_datakey_without_plaintext(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_random(self,random_data_length=None, sequence=None,**kwargs): + try: + request = CreateRandomRequest() + request.body = GenRandomRequestBody( + random_data_length=random_data_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_random(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def decrypt_data_key(self,key_id=None, cipher_text=None, datakey_cipher_length=None, sequence=None,**kwargs): + try: + request = DecryptDatakeyRequest() + request.body = DecryptDatakeyRequestBody( + key_id=key_id, + cipher_text=cipher_text, + datakey_cipher_length=datakey_cipher_length, + sequence=sequence + ) + response = self._get_dew_client().kms_client.decrypt_datakey(request) + self.logger.info(response) + return response + + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def encrypt_data_key(self,key_id=None, plain_text=None, datakey_plain_length=None, sequence=None,**kwargs): + try: + request = EncryptDatakeyRequest() + request.body = EncryptDatakeyRequestBody( + key_id=key_id, + plain_text=plain_text, + datakey_plain_length=datakey_plain_length, + sequence=sequence + + ) + response = self._get_dew_client().kms_client.encrypt_datakey(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def create_parameters_for_import(self,key_id,wrapping_algorithm=None, sequence=None,**kwargs): + try: + request = CreateParametersForImportRequest() + request.body = GetParametersForImportRequestBody( + key_id=key_id, + wrapping_algorithm=wrapping_algorithm, + sequence=sequence + ) + response = self._get_dew_client().kms_client.create_parameters_for_import(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_imported_key_material(self,key_id,sequence=None,**kwargs): + try: + request = DeleteImportedKeyMaterialRequest() + request.body = OperateKeyRequestBody( + key_id = key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.delete_imported_key_material(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def import_key_material(self,key_id=None, import_token=None, encrypted_key_material=None, encrypted_privatekey=None, expiration_time=None, sequence=None,**kwargs): + try: + request = ImportKeyMaterialRequest() + request.body = ImportKeyMaterialRequestBody( + key_id=key_id, + import_token=import_token, + encrypted_key_material=encrypted_key_material, + encrypted_privatekey=encrypted_privatekey, + expiration_time=expiration_time, + sequence=sequence + ) + response = self._get_dew_client().kms_client.import_key_material(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def decrypt_data(self,cipher_text=None, encryption_algorithm=None, key_id=None, sequence=None,**kwargs): + try: + request = DecryptDataRequest() + request.body = DecryptDataRequestBody( + cipher_text=cipher_text, + encryption_algorithm=encryption_algorithm, + key_id=key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.decrypt_data(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def encrypt_data(self,key_id=None,plain_text=None, encryption_algorithm=None, sequence=None,**kwargs): + try: + request = EncryptDataRequest() + request.body = EncryptDataRequestBody( + plain_text=plain_text, + key_id=key_id, + encryption_algorithm=encryption_algorithm, + sequence=sequence + ) + response = self._get_dew_client().kms_client.encrypt_data(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def list_key_detail(self,key_id=None,sequence=None,**kwargs): + try: + request = ListKeyDetailRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.list_key_detail(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keys(self,limit=None, marker=None, key_state=None, key_spec=None, enterprise_project_id=None, sequence=None,**kwargs): + try: + request = ListKeysRequest() + request.body = ListKeysRequestBody( + limit=limit, + marker=marker, + key_state=key_state, + key_spec=key_spec, + enterprise_project_id=enterprise_project_id, + sequence=sequence + ) + response = self._get_dew_client().kms_client.list_keys(request) + # print(response.to_dict()) + print(json.dumps(response.to_dict()).replace('}','}\n')) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_public_key(self,key_id=None, sequence=None,**kwargs): + try: + request = ShowPublicKeyRequest() + request.body = OperateKeyRequestBody( + key_id=key_id, sequence=sequence + ) + response = self._get_dew_client().kms_client.show_public_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_user_instances(self,**kwargs): + try: + request = ShowUserInstancesRequest() + response = self._get_dew_client().kms_client.show_user_instances(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_user_quotas(self,**kwargs): + try: + request = ShowUserQuotasRequest() + response = self._get_dew_client().kms_client.show_user_quotas(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def show_version(self,**kwargs): + try: + request = ShowVersionRequest(kwargs) + response = self._get_dew_client().kms_client.show_version(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_versions(self,**kwargs): + try: + request = ShowVersionsRequest() + response = self._get_dew_client().kms_client.show_versions(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_keypair(self,name=None, type=None, public_key=None, scope=None, user_id=None, key_protection=None,**kwargs): + try: + request = CreateKeypairRequest() + keypairbody = CreateKeypairAction( + name=name, + type=type, + public_key=public_key, + scope=scope, + user_id=user_id, + key_protection=key_protection + ) + request.body = CreateKeypairRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.create_keypair(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keypairs(self,limit=None, marker=None,**kwargs): + try: + request = ListKeypairsRequest( + limit=limit, + marker=marker + ) + response = self._get_dew_client().kps_client.list_keypairs(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def clear_private_key(self,keypair_name=None,**kwargs): + try: + request = ClearPrivateKeyRequest(keypair_name=keypair_name) + response = self._get_dew_client().kps_client.clear_private_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def import_private_key(self,user_id=None, name=None,type="default",kms_key_name="kps/default",private_key=None,**kwargs): + try: + request = ImportPrivateKeyRequest() + encryptionKeyProtection = Encryption( + type=type, + kms_key_name=kms_key_name + ) + keyProtectionKeypair = ImportPrivateKeyProtection( + private_key=private_key, + encryption=encryptionKeyProtection + ) + keypairbody = ImportPrivateKeyKeypairBean( + name=name, + key_protection=keyProtectionKeypair, + user_id=user_id + ) + request.body = ImportPrivateKeyRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.import_private_key(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keypair_detail(self,keypair_name=None,**kwargs): + try: + request = ListKeypairDetailRequest(keypair_name=keypair_name) + response = self._get_dew_client().kps_client.list_keypair_detail(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_keypair_description(self,keypair_name=None,description=None,**kwargs): + try: + request = UpdateKeypairDescriptionRequest( + keypair_name=keypair_name + ) + keypairbody = UpdateKeypairDescriptionReq( + description=description + ) + request.body = UpdateKeypairDescriptionRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.update_keypair_description(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def export_private_key(self,name=None,**kwargs): + try: + request = ExportPrivateKeyRequest() + keypairbody = KeypairBean( + name=name + ) + request.body = ExportPrivateKeyRequestBody( + keypair=keypairbody + ) + response = self._get_dew_client().kps_client.export_private_key(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_keypair(self,keypair_name=None,**kwargs): + try: + request = DeleteKeypairRequest(keypair_name=keypair_name) + response = self._get_dew_client().kps_client.delete_keypair(request) + self.logger.info(response) + return response + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def associate_keypair(self,keypair_name=None,type=None,key=None,id=None, disable_password=False, port=None,**kwargs): + try: + request = AssociateKeypairRequest() + authServer = Auth( + type=type, + key=key + ) + serverbody = EcsServerInfo( + id=id, + auth=authServer, + disable_password=disable_password, + port=port + ) + request.body = AssociateKeypairRequestBody( + server=serverbody, + keypair_name=keypair_name + ) + response = self._get_dew_client().kps_client.associate_keypair(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def batch_associate_keypair(self,keypair_name=[],type=[],key=[],id=[],disable_password=[],port=[],**kwargs): + try: + request = BatchAssociateKeypairRequest() + listBatchKeypairsbody = [] + for s in range(len(keypair_name),**kwargs): + authServer = Auth( + type=type[s], + key=key[s] + ) + serverBatchKeypairs = EcsServerInfo( + id=id[s], + auth=authServer, + disable_password=disable_password[s], + port=port[s] + ) + listBatchKeypairsbody.append(AssociateKeypairRequestBody( + keypair_name=keypair_name[s], + server=serverBatchKeypairs + )) + + request.body = BatchAssociateKeypairRequestBody( + batch_keypairs=listBatchKeypairsbody + ) + response = self._get_dew_client().kps_client.batch_associate_keypair(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_all_failed_task(self,**kwargs): + try: + request = DeleteAllFailedTaskRequest() + response = self._get_dew_client().kps_client.delete_all_failed_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_failed_task(self,task_id,**kwargs): + try: + request = DeleteFailedTaskRequest( + task_id=task_id, + ) + response = self._get_dew_client().kps_client.delete_failed_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def disassociate_keypair(self,id=None,type=None,key=None,**kwargs): + try: + request = DisassociateKeypairRequest() + authServer = Auth( + type=type, + key=key + ) + serverbody = DisassociateEcsServerInfo( + id=id, + auth=authServer + ) + request.body = DisassociateKeypairRequestBody( + server=serverbody + ) + response = self._get_dew_client().kps_client.disassociate_keypair(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_failed_task(self,limit=None, offset=None,**kwargs): + try: + request = ListFailedTaskRequest() + request.limit = limit + request.offset = offset + response = self._get_dew_client().kps_client.list_failed_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_keypair_task(self,task_id=None,**kwargs): + try: + request = ListKeypairTaskRequest( + task_id=task_id + ) + response = self._get_dew_client().kps_client.list_keypair_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_running_task(self,limit=None,offset=None,**kwargs): + try: + request = ListRunningTaskRequest() + request.limit = limit + request.offset = offset + response = self._get_dew_client().kps_client.list_running_task(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_secret(self,name=None, kms_key_id=None, description=None, secret_binary=None, secret_string=None, secret_type=None, auto_rotation=None, rotation_period=None, rotation_config=None, event_subscriptions=None, enterprise_project_id=None,**kwargs): + try: + request = CreateSecretRequest() + request.body = CreateSecretRequestBody( + secret_string=secret_string, + kms_key_id=kms_key_id, + name=name, + description=description, + secret_binary=secret_binary, + secret_type=secret_type, + auto_rotation=auto_rotation, + rotation_period=rotation_period, + rotation_config=rotation_config, + event_subscriptions=event_subscriptions, + enterprise_project_id=enterprise_project_id + ) + response = self._get_dew_client().cms_client.create_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def download_secret_blob(self,secret_name:None,**kwargs): + try: + request = DownloadSecretBlobRequest( + secret_name=secret_name + ) + response = self._get_dew_client().cms_client.download_secret_blob(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_secrets(self,limit=None,marker=None,event_name=None,**kwargs): + try: + request = ListSecretsRequest() + request.limit = limit + request.marker = marker + request.event_name = event_name + response = self._get_dew_client().cms_client.list_secrets(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def show_secret(self,secret_name,**kwargs): + try: + request = ShowSecretRequest( + secret_name=secret_name + ) + response = self._get_dew_client().cms_client.show_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_secret(self,kms_key_id=None,secret_name=None, description=None, auto_rotation=None, rotation_period=None, listEventSubscriptionsbody=None,**kwargs): + try: + request = UpdateSecretRequest() + request.body = UpdateSecretRequestBody( + event_subscriptions=listEventSubscriptionsbody, + description=description, + kms_key_id=kms_key_id, + auto_rotation=auto_rotation, + rotation_period=rotation_period, + ) + request.secret_name=secret_name + response = self._get_dew_client().cms_client.update_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def create_secret_event(self,target_type=None, target_id=None, target_name=None,name=None, state=None, listEventTypesbody=[],**kwargs): + try: + request = CreateSecretEventRequest() + notificationbody = Notification( + target_type=target_type, + target_id=target_id, + target_name=target_name + ) + request.body = CreateSecretEventRequestBody( + notification=notificationbody, + state=state, + event_types=listEventTypesbody, + name=name, + ) + response = self._get_dew_client().cms_client.create_secret_event(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def upload_secret_blob(self,secret_blob,**kwargs): + try: + request = UploadSecretBlobRequest() + request.body = UploadSecretBlobRequestBody( + secret_blob=secret_blob + ) + response = self._get_dew_client().cms_client.upload_secret_blob(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + print(e.status_code) + print(e.request_id) + print(e.error_code) + def rotate_secret(self,secret_name=None,**kwargs): + try: + request = RotateSecretRequest( + secret_name=secret_name + ) + response = self._get_dew_client().cms_client.rotate_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def restore_secret(self,secret_name,**kwargs): + try: + request = RestoreSecretRequest(secret_name=secret_name) + response = self._get_dew_client().cms_client.restore_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_secret_for_schedule(self,recovery_window_in_days=None,secret_name=None,**kwargs): + try: + request = DeleteSecretForScheduleRequest(secret_name=secret_name) + request.body = DeleteSecretForScheduleRequestBody( + recovery_window_in_days=recovery_window_in_days + ) + response = self._get_dew_client().cms_client.delete_secret_for_schedule(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def delete_secret(self,secret_name,**kwargs): + try: + request = DeleteSecretRequest(secret_name=secret_name) + response = self._get_dew_client().cms_client.delete_secret(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def create_secret_version(self,secret_name=None,secret_binary=None, secret_string=None, version_stages=None, expire_time=None,**kwargs): + try: + request = CreateSecretVersionRequest(secret_name=secret_name) + request.body = CreateSecretVersionRequestBody( + secret_string=secret_string, + secret_binary=secret_binary, + version_stages=version_stages, + expire_time=expire_time + ) + response = self._get_dew_client().cms_client.create_secret_version(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def list_secret_versions(self,secret_name=None, marker=None, limit=None,**kwargs): + try: + request = ListSecretVersionsRequest() + request.secret_name = secret_name + request.marker = marker + request.limit = limit + response = self._get_dew_client().cms_client.list_secret_versions(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + def show_secret_version(self,secret_name=None,version_id=None,**kwargs): + try: + request = ShowSecretVersionRequest() + request.secret_name=secret_name + request.version_id = version_id + response = self._get_dew_client().cms_client.show_secret_version(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + def update_version(self,secret_name=None, version_id=None, expire_time=None,**kwargs): + try: + request = UpdateVersionRequest() + request.version_id=version_id + request.secret_name=secret_name + request.body = UpdateVersionRequestBody( + expire_time=expire_time + ) + response = self._get_dew_client().cms_client.update_version(request) + self.logger.info(response) + except exceptions.ClientRequestException as e: + self.logger.error("status_code= %s",e.status_code) + self.logger.error("request_id= %s",e.request_id) + self.logger.error("error_code= %s",e.error_code) + self.logger.error("error_msg= %s",e.error_msg) + + diff --git a/prefect_huaweicloud/dew_client.py b/prefect_huaweicloud/dew_client.py new file mode 100644 index 0000000000000000000000000000000000000000..cfd22f10bd921b4f430b3eb7edcd962efd0cf9c4 --- /dev/null +++ b/prefect_huaweicloud/dew_client.py @@ -0,0 +1,44 @@ +from huaweicloudsdkcore.auth.credentials import BasicCredentials +from huaweicloudsdkcore.exceptions import exceptions +from huaweicloudsdkkms.v2.region.kms_region import KmsRegion +from huaweicloudsdkkms.v2 import * +from huaweicloudsdkkps.v3.region.kps_region import KpsRegion +from huaweicloudsdkkps.v3 import * +from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion +from huaweicloudsdkcsms.v1 import * +from typing import Any, Coroutine, Dict, List, Optional, Union + +from prefect import get_run_logger, task +from prefect.blocks.abstract import SecretBlock +from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible +from pydantic import VERSION as PYDANTIC_VERSION +import json +if PYDANTIC_VERSION.startswith("2."): + from pydantic.v1 import Field +else: + from pydantic import Field +class DewClient(): + def __init__(self,region_id:str,ak:str,sk:str): + self.region_id=region_id + self.__ak=ak + self.__sk=sk + @property + def kms_client(self)->KmsClient: + return KmsClient.new_builder() \ + .with_credentials(BasicCredentials(self.__ak,self.__sk)) \ + .with_region(KmsRegion.value_of(self.region_id)) \ + .build() + @property + def kps_client(self)->KpsClient: + return KpsClient.new_builder() \ + .with_credentials(BasicCredentials(self.__ak,self.__sk)) \ + .with_region(KpsRegion.value_of(self.region_id)) \ + .build() + @property + def cms_client(self)->CsmsClient: + return CsmsClient.new_builder() \ + .with_credentials(BasicCredentials(self.__ak,self.__sk)) \ + .with_region(CsmsRegion.value_of(self.region_id)) \ + .build() + + \ No newline at end of file diff --git a/prefect_hwc.egg-info/PKG-INFO b/prefect_hwc.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..e9488500f62ea87fffa88a0544f1192d704e787d --- /dev/null +++ b/prefect_hwc.egg-info/PKG-INFO @@ -0,0 +1,29 @@ +Metadata-Version: 2.1 +Name: prefect-hwc +Version: 0.1.0 +Summary: Prefect collection of tasks and sub flows to integrate with HuaweiCloud +Home-page: https://gitee.com/HuaweiCloudDeveloper/huaweicloud-prefect-block-python +Author: HuaweiCloud +Author-email: +License: Apache License 2.0 +Keywords: prefect +Requires-Python: >=3.9 +Description-Content-Type: text/markdown + +# Prefect Huawei Cloud Block + +## Welcome! +The prefect-hwc collection enables you to use HUAWEI CLOUD service capabilities in Prefect more efficiently. +## Getting Started + +```bash +pip install -U "prefect" + +pip install prefect-hwc + +prefect block register --module prefect-hwc +``` + +## Contributing + +Thank you for wanting to contribute, you can contribute to [this code repository](https://gitee.com/HuaweiCloudDeveloper/huaweicloud-prefect-block-python) .If you have any questions, consult the community. diff --git a/prefect_hwc.egg-info/SOURCES.txt b/prefect_hwc.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..f8c0fd48b339b970c5361e92f8f5a1d07304be95 --- /dev/null +++ b/prefect_hwc.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +prefect_huaweicloud/__init__.py +prefect_huaweicloud/dew.py +prefect_huaweicloud/obs_block.py +prefect_hwc.egg-info/PKG-INFO +prefect_hwc.egg-info/SOURCES.txt +prefect_hwc.egg-info/dependency_links.txt +prefect_hwc.egg-info/requires.txt +prefect_hwc.egg-info/top_level.txt \ No newline at end of file diff --git a/prefect_hwc.egg-info/dependency_links.txt b/prefect_hwc.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/prefect_hwc.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/prefect_hwc.egg-info/requires.txt b/prefect_hwc.egg-info/requires.txt new file mode 100644 index 0000000000000000000000000000000000000000..ff1be1f77ea23be29caee1b237ccb39b93d29571 --- /dev/null +++ b/prefect_hwc.egg-info/requires.txt @@ -0,0 +1,3 @@ +pydantic==1.10.11 +esdk-obs-python +prefect>=2.10.11 diff --git a/prefect_hwc.egg-info/top_level.txt b/prefect_hwc.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..d32e0ca8d1abd0329195a39e7369ae7c012fbe7d --- /dev/null +++ b/prefect_hwc.egg-info/top_level.txt @@ -0,0 +1 @@ +prefect_huaweicloud diff --git a/setup.py b/setup.py index 11f6623eaecbdcaa5c12591e64f3a6c284af637c..616e6a6873b1ef624220c5e9a49babd1f7a8a982 100644 --- a/setup.py +++ b/setup.py @@ -14,7 +14,7 @@ setup( author_email="", keywords="prefect", url="https://gitee.com/HuaweiCloudDeveloper/huaweicloud-prefect-block-python", - version="0.1.0", + version="0.2.0", long_description=open("README.md").read(), long_description_content_type="text/markdown", python_requires=">=3.9", diff --git a/test_dew.py b/test_dew.py new file mode 100644 index 0000000000000000000000000000000000000000..6f63f24d3d786f45cad0f186d88266f365d47999 --- /dev/null +++ b/test_dew.py @@ -0,0 +1,86 @@ +<<<<<<< HEAD +from prefect_huaweicloud.dew_block import DewBlock +from contextlib import redirect_stdout +import asyncio +from prefect import flow,task,Task +import pytest + + + +def test_list_keys(test_huaweicloud_dew_block): + test_huaweicloud_dew_block.list_keys() + +def kms_key_under_test(huaweicloud_dew_block,key_alias=None): + test_key=huaweicloud_dew_block.create_key(key_alias=key_alias) + return dict( + key_alias=key_alias, + key_id=test_key.key_info.key_id, + key_description=None, + pending_days=7 + ) + +@flow +def test_key_lifecycle_management(kms_key_under_test,huaweicloud_dew_block): + row_key_alias=kms_key_under_test['key_alias'] + huaweicloud_dew_block.create_key(**kms_key_under_test) + huaweicloud_dew_block.disable_key(**kms_key_under_test) + huaweicloud_dew_block.enable_key(**kms_key_under_test) + kms_key_under_test['key_alias']="test_alias" + huaweicloud_dew_block.update_key_Alias(**kms_key_under_test) + kms_key_under_test['key_alias']=row_key_alias + huaweicloud_dew_block.update_key_Alias(**kms_key_under_test) + kms_key_under_test['key_description']="test_update_description" + huaweicloud_dew_block.update_key_description(**kms_key_under_test) + huaweicloud_dew_block.delete_key(**kms_key_under_test) + huaweicloud_dew_block.cancel_key_deletion(**kms_key_under_test) + huaweicloud_dew_block.enable_key(**kms_key_under_test) + + + + +if __name__=="__main__": + huaweicloud_dew_block = DewBlock.load("test-dew-block") +======= +from prefect_huaweicloud.dew_block import DewBlock +from contextlib import redirect_stdout +import asyncio +from prefect import flow,task,Task +import pytest + + + +def test_list_keys(test_huaweicloud_dew_block): + test_huaweicloud_dew_block.list_keys() + +def kms_key_under_test(huaweicloud_dew_block,key_alias=None): + test_key=huaweicloud_dew_block.create_key(key_alias=key_alias) + return dict( + key_alias=key_alias, + key_id=test_key.key_info.key_id, + key_description=None, + pending_days=7 + ) + +@flow +def test_key_lifecycle_management(kms_key_under_test,huaweicloud_dew_block): + row_key_alias=kms_key_under_test['key_alias'] + huaweicloud_dew_block.create_key(**kms_key_under_test) + huaweicloud_dew_block.disable_key(**kms_key_under_test) + huaweicloud_dew_block.enable_key(**kms_key_under_test) + kms_key_under_test['key_alias']="test_alias" + huaweicloud_dew_block.update_key_Alias(**kms_key_under_test) + kms_key_under_test['key_alias']=row_key_alias + huaweicloud_dew_block.update_key_Alias(**kms_key_under_test) + kms_key_under_test['key_description']="test_update_description" + huaweicloud_dew_block.update_key_description(**kms_key_under_test) + huaweicloud_dew_block.delete_key(**kms_key_under_test) + huaweicloud_dew_block.cancel_key_deletion(**kms_key_under_test) + huaweicloud_dew_block.enable_key(**kms_key_under_test) + + + + +if __name__=="__main__": + huaweicloud_dew_block = DewBlock.load("test-dew-block") +>>>>>>> ed71f9ca74fccca7930a70e4546aa9c1ddf8e8bb + test_key_lifecycle_management(kms_key_under_test(huaweicloud_dew_block,key_alias="12-26"),huaweicloud_dew_block) \ No newline at end of file