コード例 #1
0
    def ecs_client(self, region):
        self.log('Geting ECS client')
        config = HttpConfig.get_default_config()
        config.ignore_ssl_verification = True
        if self.credentials["project_id"] and self.credentials[
                "access_key"] and self.credentials["secret_key"] and region:
            _credentials = BasicCredentials(self.credentials["access_key"],
                                            self.credentials["secret_key"],
                                            self.credentials["project_id"])

            if self.credentials["identity_endpoint"]:
                _credentials.iam_endpoint = self.credentials[
                    "identity_endpoint"]

            if self.credentials["cloud"]:
                endpoint = 'https://ecs.{}.{}'.format(
                    region, self.credentials["cloud"])
            else:
                endpoint = 'https://ecs.{}.myhuaweicloud.com'.format(region)
            ecs_client = EcsClient.new_builder() \
            .with_http_config(config) \
            .with_credentials(_credentials) \
            .with_endpoint(endpoint) \
            .build()
        else:
            raise HwcModuleException(
                'Getting ECS client failed: "project_id", "access_key", "access_key" and "region" are required for ECS client'
            )

        return ecs_client
コード例 #2
0
    def cce_client(self):
        self.log('Geting CCE client')
        if not self._cce_client:
            config = HttpConfig.get_default_config()
            config.ignore_ssl_verification = True
            if self.module.params["project_id"]:
                credentials = BasicCredentials(
                    self.module.params["access_key"],
                    self.module.params["secret_key"],
                    self.module.params["project_id"])

                if self.module.params["identity_endpoint"]:
                    credentials.iam_endpoint = self.module.params[
                        "identity_endpoint"]

                endpoint = 'https://cce.{}.{}'.format(
                    self.module.params["region"], self.module.params["cloud"])
                self._cce_client = CceClient.new_builder() \
                .with_http_config(config) \
                .with_credentials(credentials) \
                .with_endpoint(endpoint) \
                .build()
            else:
                raise HwcModuleException(
                    'Getting CCE client failed: "project_id" is required for CCE client'
                )

        return self._cce_client
コード例 #3
0
ファイル: iot.py プロジェクト: hhusjr/intellikeeper-server
def get_iot_client():
    config = HttpConfig.get_default_config()
    credentials = BasicCredentials(HwyunSettings.access_key_id,
                                   HwyunSettings.access_key_secret,
                                   HwyunSettings.project_id,
                                   HwyunSettings.domain_id)
    builder: ClientBuilder = IoTDAClient().new_builder(IoTDAClient)
    client: IoTDAClient = builder.with_http_config(config) \
        .with_credentials(credentials) \
        .with_endpoint(HwyunSettings.endpoint) \
        .with_stream_log(log_level=logging.INFO) \
        .build()
    return client
コード例 #4
0
def test_project_id_with_region(mocker):
    mock_credential = BasicCredentials("ak",
                                       "sk").with_iam_endpoint(MOCK_ENDPOINT)
    client = Client().with_credentials(mock_credential).with_config(
        HttpConfig.get_default_config())
    client.init_http_client()
    http_client = client.get_http_client()

    mocker.patch.object(http_client,
                        'do_request_sync',
                        return_value=mock_keystone_list_projects(REGION_ID))

    result_credential = mock_credential.process_auth_params(
        http_client, ServiceRegion.CN_NORTH_7.id)
    assert result_credential.project_id == "123456789"
コード例 #5
0
def client():
    ak = "my ak"
    sk = "my sk"
    project_id = "my project_id"
    endpoint = "https://vpc.cn-north-x.myhuaweicloud.com"

    config = HttpConfig.get_default_config()
    config.ignore_ssl_verification = True
    credentials = BasicCredentials(ak, sk, project_id)

    client = ClientBuilder(Client) \
        .with_http_config(config) \
        .with_credentials(credentials) \
        .with_endpoint(endpoint) \
        .build()

    yield client
コード例 #6
0
    def build(self):
        if self._config is None:
            self._config = HttpConfig.get_default_config()

        if self._credentials is None:
            self._credentials = EnvCredentials.load_credential_from_env(
                self._credential_type[0])
        if self._credentials is None:
            raise ValueError(
                "credential can not be None, %s credential objects are required"
                % ",".join(self._credential_type))
        if self._credentials.__class__.__name__ not in self._credential_type:
            raise TypeError(
                "credential type error, supported credential type is %s" %
                ",".join(self._credential_type))

        client = self._client_type() \
            .with_credentials(self._credentials) \
            .with_config(self._config) \
            .with_http_handler(self._http_handler)

        client.init_http_client()

        if self._region is not None:
            self._endpoint = self._region.endpoint
            self._credentials = self._credentials.process_auth_params(
                client.get_http_client(), self._region.id)

        if not self._endpoint.startswith(self._http_scheme):
            self._endpoint = self._https_scheme + "://" + self._endpoint

        client.with_endpoint(self._endpoint) \
            .with_credentials(self._credentials)

        if self._file_logger_handler is not None:
            client.add_file_logger(**self._file_logger_handler)
        if self._stream_logger_handler is not None:
            client.add_stream_logger(**self._stream_logger_handler)

        return client
コード例 #7
0
 specific language governing permissions and limitations
 under the LICENSE.
"""

import pytest

from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkcore.http.http_config import HttpConfig
from huaweicloudsdkcore.region.region import Region
from tests.data.project_response_mocker import MOCK_ENDPOINT
from tests.model.service.service_client import ServiceClient
from tests.model.service.service_region import ServiceRegion

OVERRIDE_ENDPOINT = "https://service.cn-north-x.myhuaweicloud.com"

config = HttpConfig.get_default_config()
config.ignore_ssl_verification = True

credentials = BasicCredentials("ak", "sk", "project_id")


def test_endpoint_with_region_1():
    client = ServiceClient.new_builder() \
        .with_http_config(config) \
        .with_credentials(credentials) \
        .with_region(ServiceRegion.CN_NORTH_7) \
        .build()

    assert hasattr(client, "_endpoint") is True
    assert getattr(client, "_endpoint") == MOCK_ENDPOINT