1885 lines
58 KiB
Python
1885 lines
58 KiB
Python
# Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
|
|
# except in compliance with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software distributed under the
|
|
# License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
|
# either express or implied. See the License for the specific language governing permissions
|
|
# and limitations under the License.
|
|
|
|
"""
|
|
This module provides a client class for CDN.
|
|
"""
|
|
|
|
import copy
|
|
import json
|
|
import logging
|
|
import baidubce
|
|
|
|
from baidubce import bce_base_client
|
|
from baidubce.auth import bce_v1_signer
|
|
from baidubce.http import bce_http_client
|
|
from baidubce.http import handler
|
|
from baidubce.http import http_content_types
|
|
from baidubce.http import http_headers
|
|
from baidubce.http import http_methods
|
|
from baidubce.exception import BceClientError
|
|
from baidubce.exception import BceServerError
|
|
from baidubce.utils import required
|
|
from baidubce import utils
|
|
from baidubce.services.cdn.cdn_stats_param import CdnStatsParam
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class CdnClient(bce_base_client.BceBaseClient):
|
|
"""
|
|
CdnClient
|
|
"""
|
|
prefix = b"/v2"
|
|
|
|
def __init__(self, config=None):
|
|
bce_base_client.BceBaseClient.__init__(self, config)
|
|
|
|
def list_domains(self, config=None):
|
|
"""
|
|
get domain list
|
|
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET,
|
|
'/domain',
|
|
config=config)
|
|
|
|
def list_user_domains(self, status, rule=None, config=None):
|
|
"""
|
|
get user domain list
|
|
|
|
:param status: Specify the domain whose return 'status' is status
|
|
:type status: string
|
|
:param rule: domain Fuzzy Matching
|
|
:type rule: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['status'] = status
|
|
|
|
if rule is not None:
|
|
params['rule'] = rule
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/user/domains',
|
|
params=params,
|
|
config=config)
|
|
|
|
def valid_domain(self, domain, config=None):
|
|
"""
|
|
query if a domain can be create
|
|
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET,
|
|
'/domain/' + domain + '/valid',
|
|
config=config)
|
|
|
|
def get_domain_cache_full_url(self, domain, config=None):
|
|
"""
|
|
get cache full url of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'cacheFullUrl': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_cache_share(self, domain, cache_share, config=None):
|
|
"""
|
|
update cacheShare of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param cache_share: detailed configuration of cacheShare
|
|
:type cache_share: dictionary
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'cacheShare': ''},
|
|
body=json.dumps({'cacheShare': cache_share}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_cache_share(self, domain, config=None):
|
|
"""
|
|
get cacheShare configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'cacheShare': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_traffic_limit(self, domain, traffic_limit, config=None):
|
|
"""
|
|
update trafficLimit of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param traffic_limit: detailed configuration of trafficLimit
|
|
:type traffic_limit: dictionary
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'trafficLimit': ''},
|
|
body=json.dumps({'trafficLimit': traffic_limit}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_traffic_limit(self, domain, config=None):
|
|
"""
|
|
get trafficLimit configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'trafficLimit': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_ua_acl(self, domain, ua_acl, config=None):
|
|
"""
|
|
update uaAcl of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param ua_acl: detailed configuration of uaAcl
|
|
:type ua_acl: dictionary
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'uaAcl': ''},
|
|
body=json.dumps({'uaAcl': ua_acl}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_ua_acl(self, domain, config=None):
|
|
"""
|
|
get uaAcl configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'uaAcl': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_origin_protocol(self, domain, origin_protocol, config=None):
|
|
"""
|
|
update originProtocol of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param origin_protocol: detailed configuration of originProtocol
|
|
:type origin_protocol: dictionary
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'originProtocol': ''},
|
|
body=json.dumps({'originProtocol': origin_protocol}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_origin_protocol(self, domain, config=None):
|
|
"""
|
|
get originProtocol configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'originProtocol': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_retry_origin(self, domain, retry_origin, config=None):
|
|
"""
|
|
update retryOrigin of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param retry_origin: detailed configuration of retryOrigin
|
|
:type retry_origin: dictionary
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'retryOrigin': ''},
|
|
body=json.dumps({'retryOrigin': retry_origin}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_retry_origin(self, domain, config=None):
|
|
"""
|
|
get retryOrigin configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'retryOrigin': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_ipv6_dispatch(self, domain, ipv6_dispatch, config=None):
|
|
"""
|
|
update ipv6Dispatch of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param ipv6_dispatch: detailed configuration of IPv6 access and IPv6 back to source
|
|
:type ipv6_dispatch: IPv6Config
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'ipv6Dispatch': ''},
|
|
body=json.dumps({'ipv6Dispatch': ipv6_dispatch}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_ipv6_dispatch(self, domain, config=None):
|
|
"""
|
|
get ipv6Dispatch configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'ipv6Dispatch': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_quic(self, domain, quic, config=None):
|
|
"""
|
|
update QUIC of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param quic: detailed configuration of Quick UDP Internet Connection
|
|
:type quic: bool
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'quic': ''},
|
|
body=json.dumps({'quic': quic}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_quic(self, domain, config=None):
|
|
"""
|
|
get quic configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'quic': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_offline_mode(self, domain, offline_mode, config=None):
|
|
"""
|
|
update offlineMode of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param offline_mode: detailed configuration of offlineMode
|
|
:type offline_mode: bool
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'offlineMode': ''},
|
|
body=json.dumps({'offlineMode': offline_mode}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_offline_mode(self, domain, config=None):
|
|
"""
|
|
get offlineMode configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'offlineMode': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_ocsp(self, domain, ocsp, config=None):
|
|
"""
|
|
update OCSP configuration of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param ocsp: detailed configuration of Online Certificate Status Protocol
|
|
:type ocsp: bool
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'ocsp': ''},
|
|
body=json.dumps({'ocsp': ocsp}),
|
|
config=config)
|
|
|
|
|
|
def get_domain_ocsp(self, domain, config=None):
|
|
"""
|
|
get ocsp configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'ocsp': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_error_page(self, domain, error_page, config=None):
|
|
"""
|
|
update error_page of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param error_page: Detailed configuration of custom error jump pages
|
|
:type error_page: list<ErrorPage>
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'errorPage': ''},
|
|
body=json.dumps({'errorPage': error_page}),
|
|
config=config)
|
|
|
|
def get_domain_error_page(self, domain, config=None):
|
|
"""
|
|
get error page configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'errorPage': ''},
|
|
config=config)
|
|
|
|
|
|
def get_domain_referer_acl(self, domain, config=None):
|
|
"""
|
|
get referer acl configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'refererACL': ''},
|
|
config=config)
|
|
|
|
|
|
def get_domain_ip_acl(self, domain, config=None):
|
|
"""
|
|
get ip acl configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'ipACL': ''},
|
|
config=config)
|
|
|
|
|
|
def set_domain_cors(self, domain, cors, config=None):
|
|
"""
|
|
update cors of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param cors: Accelerating Cross-domain Settings for Domain Names
|
|
:type cors
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'cors': ''},
|
|
body=json.dumps({'cors': cors}),
|
|
config=config)
|
|
|
|
def get_domain_cors(self, domain, config=None):
|
|
"""
|
|
get cors configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'cors': ''},
|
|
config=config)
|
|
|
|
def set_domain_access_limit(self, domain, access_limit, config=None):
|
|
"""
|
|
update access limit of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param access_limit: Setting IP Access Limitation
|
|
:type AccessLimit
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'accessLimit': ''},
|
|
body=json.dumps({'accessLimit': access_limit}),
|
|
config=config)
|
|
|
|
def get_domain_access_limit(self, domain, config=None):
|
|
"""
|
|
get access limit configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'accessLimit': ''},
|
|
config=config)
|
|
|
|
def set_domain_client_ip(self, domain, client_ip, config=None):
|
|
"""
|
|
update Getting Real User IP Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param client_ip: Getting Real User IP Settings
|
|
:type ClientIp
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'clientIp': ''},
|
|
body=json.dumps({'clientIp': client_ip}),
|
|
config=config)
|
|
|
|
def get_domain_client_ip(self, domain, config=None):
|
|
"""
|
|
get client ip configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'clientIp': ''},
|
|
config=config)
|
|
|
|
def set_domain_range_switch(self, domain, range_switch, config=None):
|
|
"""
|
|
update range backsource Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param range_switch: rangre backsource settings
|
|
:type bool
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'rangeSwitch': ''},
|
|
body=json.dumps({'rangeSwitch': range_switch}),
|
|
config=config)
|
|
|
|
def get_domain_range_switch(self, domain, config=None):
|
|
"""
|
|
get range switch configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'rangeSwitch': ''},
|
|
config=config)
|
|
|
|
def set_domain_mobile_access(self, domain, mobile_access, config=None):
|
|
"""
|
|
update mobile access Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param mobile_access: mobile access settings
|
|
:type MobileAccess
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'mobileAccess': ''},
|
|
body=json.dumps({'mobileAccess': mobile_access}),
|
|
config=config)
|
|
|
|
def get_domain_mobile_access(self, domain, config=None):
|
|
"""
|
|
get mobile access configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'mobileAccess': ''},
|
|
config=config)
|
|
|
|
def set_domain_http_header(self, domain, http_header, config=None):
|
|
"""
|
|
update http header Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param http_header: http header settings
|
|
:type HttpHeader
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'httpHeader': ''},
|
|
body=json.dumps({'httpHeader': http_header}),
|
|
config=config)
|
|
|
|
def get_domain_http_header(self, domain, config=None):
|
|
"""
|
|
get http header configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'httpHeader': ''},
|
|
config=config)
|
|
|
|
def set_domain_file_trim(self, domain, file_trim, config=None):
|
|
"""
|
|
update file trim Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param file_trim: file trim settings
|
|
:type bool
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'fileTrim': ''},
|
|
body=json.dumps({'fileTrim': file_trim}),
|
|
config=config)
|
|
|
|
def get_domain_file_trim(self, domain, config=None):
|
|
"""
|
|
get file trim configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'fileTrim': ''},
|
|
config=config)
|
|
|
|
def set_domain_media_drag(self, domain, media_drag, config=None):
|
|
"""
|
|
update media drag Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param media_drag: media drag settings
|
|
:type MediaDragConf
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'mediaDrag': ''},
|
|
body=json.dumps({'mediaDragConf': media_drag}),
|
|
config=config)
|
|
|
|
def get_domain_media_drag(self, domain, config=None):
|
|
"""
|
|
get range switch configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'mediaDrag': ''},
|
|
config=config)
|
|
|
|
def set_domain_compress(self, domain, compress, config=None):
|
|
"""
|
|
update compress Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param compress: media drag settings
|
|
:type compress
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'compress': ''},
|
|
body=json.dumps({'compress': compress}),
|
|
config=config)
|
|
|
|
def get_domain_compress(self, domain, config=None):
|
|
"""
|
|
get compress configuration of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'compress': ''},
|
|
config=config)
|
|
|
|
def get_domain_records(self, Type=None, start_time=None, end_time=None,
|
|
url=None, marker=None, config=None):
|
|
"""
|
|
Query refresh and preload records
|
|
:param Type: None
|
|
:type string
|
|
:param start_time: None
|
|
:type Timestamp
|
|
:param end_time: None
|
|
:type Timestamp
|
|
:param url: None
|
|
:type string
|
|
:param marker: None
|
|
:type string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
|
|
params = {}
|
|
|
|
if Type is not None:
|
|
params['type'] = Type
|
|
|
|
if start_time is not None:
|
|
params['startTime'] = start_time
|
|
|
|
if end_time is not None:
|
|
params['endTime'] = end_time
|
|
|
|
if url is not None:
|
|
params['url'] = url
|
|
|
|
if marker is not None:
|
|
params['marker'] = marker
|
|
|
|
if params is None:
|
|
params = {}
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/cache/records',
|
|
params = params,
|
|
config=config)
|
|
|
|
def set_dsa(self, action, config=None):
|
|
"""
|
|
set das enable
|
|
:param action: dsa enable
|
|
:type string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/dsa',
|
|
body=json.dumps({'action': action}),
|
|
config=config)
|
|
|
|
def set_domain_dsa(self, domain, dsa, config=None):
|
|
"""
|
|
update domain dsa Settings
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param dsa: domain dsa settings
|
|
:type DSA
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'dsa': ''},
|
|
body=json.dumps({'dsa': dsa}),
|
|
config=config)
|
|
|
|
def get_dsa_domains(self, config=None):
|
|
"""
|
|
get dsa domain list
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET,
|
|
'/dsa/domain',
|
|
config=config)
|
|
|
|
def get_log_list(self, log, config=None):
|
|
"""
|
|
get log list
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.POST,
|
|
'/log/list',
|
|
body=json.dumps(log),
|
|
config=config)
|
|
|
|
def create_domain(self, domain, origin, other=None, config=None):
|
|
"""
|
|
create domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param origin: the origin address list
|
|
:type origin: list<OriginPeer>
|
|
:param other: the other config
|
|
:type other: list<CONFIG>
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {'origin': origin}
|
|
if other is not None:
|
|
body.update(other)
|
|
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain,
|
|
body=json.dumps(body),
|
|
config=config)
|
|
|
|
def delete_domain(self, domain, config=None):
|
|
"""
|
|
delete a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.DELETE,
|
|
'/domain/' + domain,
|
|
config=config)
|
|
|
|
def enable_domain(self, domain, config=None):
|
|
"""
|
|
enable a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.POST,
|
|
'/domain/' + domain,
|
|
params={'enable': ''},
|
|
config=config)
|
|
|
|
def disable_domain(self, domain, config=None):
|
|
"""
|
|
disable a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.POST,
|
|
'/domain/' + domain,
|
|
params={'disable': ''},
|
|
config=config)
|
|
|
|
def get_domain_config(self, domain, config=None):
|
|
"""
|
|
get configuration of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
if domain[0] == '*':
|
|
domain = '%2A' + domain[1:]
|
|
|
|
return self._send_request(
|
|
http_methods.GET,
|
|
'/domain/' + domain + '/config',
|
|
config=config)
|
|
|
|
def set_domain_multi_configs(self, domain, multi_configs, config=None):
|
|
"""
|
|
update multiConfigs of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param multi_configs: the domain config list
|
|
:type multi_configs: list<config>
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'multiConfigs': ''},
|
|
body=json.dumps({'multiConfigs': multi_configs}),
|
|
config=config)
|
|
|
|
def set_domain_origin(self, domain, origin, other=None, config=None):
|
|
"""
|
|
update origin address of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param origin: the origin address list
|
|
:type origin: list<OriginPeer>
|
|
:param other: origin extension configuration
|
|
:type other: dictionary
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {'origin': origin}
|
|
if other is not None:
|
|
body.update(other)
|
|
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'origin': ''},
|
|
body=json.dumps(body),
|
|
config=config)
|
|
|
|
def get_domain_cache_ttl(self, domain, config=None):
|
|
"""
|
|
get cache rules of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/domain/' + domain + '/config',
|
|
params={'cacheTTL': ''},
|
|
config=config)
|
|
|
|
@required(domain=str, rules=list)
|
|
def set_domain_cache_ttl(self, domain, rules, config=None):
|
|
"""
|
|
set cache rules of a domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param rules: cache rules
|
|
:type rules: list
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'cacheTTL': ''},
|
|
body=json.dumps({'cacheTTL': rules}),
|
|
config=config)
|
|
|
|
def set_domain_cache_full_url(self, domain, flag, config=None):
|
|
"""
|
|
set if use the full url as cache key
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param flag:
|
|
:type flag: bool
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'cacheFullUrl': ''},
|
|
body=json.dumps({'cacheFullUrl': flag}),
|
|
config=config)
|
|
|
|
@required(domain=str)
|
|
def set_domain_referer_acl(self, domain,
|
|
blackList=None, whiteList=None,
|
|
allowEmpty=True, config=None):
|
|
"""
|
|
set request referer access control
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param blackList: referer blackList
|
|
:type blackList: list
|
|
:param whitelist: referer whitelist
|
|
:type whitelist: list
|
|
:param allowempty: allow empty referer?
|
|
:type allowempty: bool
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
acl = {}
|
|
acl['allowEmpty'] = allowEmpty
|
|
|
|
if blackList is not None:
|
|
acl['blackList'] = blackList
|
|
if whiteList is not None:
|
|
acl['whiteList'] = whiteList
|
|
|
|
return self._send_request(
|
|
http_methods.PUT, '/domain/' + domain + '/config',
|
|
params={'refererACL': ''},
|
|
body=json.dumps({'refererACL': acl}),
|
|
config=config)
|
|
|
|
@required(domain=str)
|
|
def set_domain_ip_acl(self, domain, blackList=None, whiteList=None, config=None):
|
|
"""
|
|
set request ip access control
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param blackList: ip blackList
|
|
:type blackList: list
|
|
:param whitelist: ip whitelist
|
|
:type whitelist: list
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
acl = {}
|
|
|
|
if blackList is not None:
|
|
acl['blackList'] = blackList
|
|
if whiteList is not None:
|
|
acl['whiteList'] = whiteList
|
|
|
|
return self._send_request(
|
|
http_methods.PUT, '/domain/' + domain + '/config',
|
|
params={'ipACL': ''},
|
|
body=json.dumps({'ipACL': acl}),
|
|
config=config)
|
|
|
|
@required(domain=str, https=dict)
|
|
def set_domain_https(self, domain, https, config=None):
|
|
"""
|
|
set request ip access control
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param https: https config
|
|
:type https: dict
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
|
|
return self._send_request(
|
|
http_methods.PUT, '/domain/' + domain + '/config',
|
|
params={'https': ''},
|
|
body=json.dumps({'https': https}),
|
|
config=config)
|
|
|
|
@required(domain=str, limitRate=int)
|
|
def set_domain_limit_rate(self, domain, limitRate, config=None):
|
|
"""
|
|
set limit rate
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param limitRate: limit rate value (Byte/s)
|
|
:type limitRate: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT, '/domain/' + domain + '/config',
|
|
params={'limitRate': ''},
|
|
body=json.dumps({'limitRate': limitRate}),
|
|
config=config)
|
|
|
|
@required(domain=str, request_auth=dict)
|
|
def set_domain_request_auth(self, domain, requestAuth, config=None):
|
|
"""
|
|
set request auth
|
|
:param domain: the domain
|
|
:type domain: string
|
|
:param requestAuth: request auth config
|
|
:type requestAuth: dict
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT, '/domain/' + domain + '/config',
|
|
params={'requestAuth': ''},
|
|
body=json.dumps({'requestAuth': requestAuth}),
|
|
config=config)
|
|
|
|
@required(param=CdnStatsParam)
|
|
def get_domain_stats(self, param, config=None):
|
|
"""
|
|
query stats of the domain or uid or tagId, eg : flow pv
|
|
:param param: the stats query param
|
|
:type param: cdn_stats_param.CdnStatsParam
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.POST,
|
|
'/stat/query',
|
|
body=json.dumps(param.__dict__),
|
|
config=config)
|
|
|
|
def get_domain_pv_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, withRegion=None, config=None):
|
|
"""
|
|
query pv and qps of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param withRegion: if need client region distribution
|
|
:type withRegion: any
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
params['withRegion'] = withRegion
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/pv',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_flow_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, withRegion=None, config=None):
|
|
"""
|
|
query bandwidth of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param withRegion: if need client region distribution
|
|
:type withRegion: any
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
params['withRegion'] = withRegion
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/flow',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_src_flow_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, config=None):
|
|
"""
|
|
query origin bandwidth of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/srcflow',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_hitrate_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, config=None):
|
|
"""
|
|
query hit rate of the domain
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/hitrate',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_httpcode_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, withRegion=None, config=None):
|
|
"""
|
|
query http response code of a domain or all domains of the user
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param withRegion: if need client region distribution
|
|
:type withRegion: any
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
params['withRegion'] = withRegion
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/httpcode',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_topn_url_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, config=None):
|
|
"""
|
|
query top n url of the domain or all domains of the user
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/topn/url',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_topn_referer_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, config=None):
|
|
"""
|
|
query top n referer of the domain or all domains of the user
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/topn/referer',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_uv_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=3600, config=None):
|
|
"""
|
|
query the total number of client of a domain or all domains of the user
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/uv',
|
|
params=params,
|
|
config=config)
|
|
|
|
def get_domain_avg_speed_stat(self, domain=None,
|
|
startTime=None, endTime=None,
|
|
period=300, config=None):
|
|
"""
|
|
query average of the domain or all domains of the user
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param period: time interval of query result
|
|
:type period: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['domain'] = domain
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['period'] = period
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/stat/avgspeed',
|
|
params=params,
|
|
config=config)
|
|
|
|
@required(tasks=list)
|
|
def purge(self, tasks, config=None):
|
|
"""
|
|
purge the cache of specified url or directory
|
|
:param tasks: url or directory list to purge
|
|
:type tasks: list
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {}
|
|
body['tasks'] = tasks
|
|
return self._send_request(
|
|
http_methods.POST, '/cache/purge',
|
|
config=config, body=json.dumps(body))
|
|
|
|
def list_purge_tasks(self, id=None, url=None,
|
|
startTime=None, endTime=None,
|
|
marker=None, config=None):
|
|
"""
|
|
query the status of purge tasks
|
|
:param id: purge task id to query
|
|
:type id: string
|
|
:param url: purge url to query
|
|
:type url: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param marker: 'nextMarker' get from last query
|
|
:type marker: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['id'] = id
|
|
params['url'] = url
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['marker'] = marker
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/cache/purge',
|
|
params=params,
|
|
config=config)
|
|
|
|
@required(tasks=list)
|
|
def prefetch(self, tasks, config=None):
|
|
"""
|
|
prefetch the source of specified url from origin
|
|
:param tasks: url or directory list need prefetch
|
|
:type tasks: list
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {}
|
|
body['tasks'] = tasks
|
|
return self._send_request(
|
|
http_methods.POST,
|
|
'/cache/prefetch',
|
|
config=config, body=json.dumps(body))
|
|
|
|
def list_prefetch_tasks(self, id=None, url=None,
|
|
startTime=None, endTime=None,
|
|
marker=None, config=None):
|
|
"""
|
|
query the status of prefetch tasks
|
|
:param id: prefetch task id to query
|
|
:type id: string
|
|
:param url: prefetch url to query
|
|
:type url: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param marker: 'nextMarker' get from last query
|
|
:type marker: int
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
params['id'] = id
|
|
params['url'] = url
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
params['marker'] = marker
|
|
|
|
return self._send_request(
|
|
http_methods.GET, '/cache/prefetch',
|
|
params=params,
|
|
config=config)
|
|
|
|
def list_quota(self, config=None):
|
|
"""
|
|
query purge quota of the user
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(http_methods.GET,
|
|
'/cache/quota',
|
|
config=config)
|
|
|
|
def get_domain_log(self, domain, startTime, endTime, config=None):
|
|
"""
|
|
get log of the domain in specified period of time
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param startTime: query start time
|
|
:type startTime: Timestamp
|
|
:param endTime: query end time
|
|
:type endTime: Timestamp
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {}
|
|
if startTime is not None:
|
|
params['startTime'] = startTime
|
|
|
|
if endTime is not None:
|
|
params['endTime'] = endTime
|
|
|
|
return self._send_request(
|
|
http_methods.GET,
|
|
'/log/' + domain + '/log',
|
|
params=params,
|
|
config=config)
|
|
|
|
def ip_query(self, action, ip, config=None):
|
|
"""
|
|
check specified ip whether belongs to Baidu CDN
|
|
:param action: 'describeIp'
|
|
:type action: string
|
|
:param ip: specified ip
|
|
:type ip: string
|
|
"""
|
|
params = {}
|
|
params['action'] = action
|
|
params['ip'] = ip
|
|
if params is None:
|
|
params = {}
|
|
return self._send_request(
|
|
http_methods.GET, '/utils',
|
|
params=params,
|
|
config=config)
|
|
|
|
def list_nodes(self, config=None):
|
|
"""
|
|
Baidu back source IP address segment query
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET, '/nodes/list',
|
|
params={},
|
|
config=config)
|
|
|
|
@required(domain=str)
|
|
def set_seo(self, domain, push_record=False, directory_origin=False, config=None):
|
|
"""
|
|
set seo
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param push_record: push record to baidu or not
|
|
:type param: boolean
|
|
:param directory_origin: directory access origin or not
|
|
:param config: None
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
body = dict()
|
|
body['pushRecord'] = "ON" if push_record else "OFF"
|
|
body['diretlyOrigin'] = "ON" if directory_origin else "OFF"
|
|
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'seoSwitch': ''},
|
|
body=json.dumps({'seoSwitch': body}),
|
|
config=config)
|
|
|
|
@required(domain=str)
|
|
def get_seo(self, domain, config=None):
|
|
"""
|
|
get seo configuration.
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.GET,
|
|
'/domain/' + domain + '/config',
|
|
params={'seoSwitch': ''},
|
|
config=config)
|
|
|
|
@required(domain=str)
|
|
def set_follow_protocol(self, domain, follow, config=None):
|
|
"""
|
|
set follow protocol.
|
|
:param domain: the domain name
|
|
:type domain: string
|
|
:param follow: follow protocol or not
|
|
:type follow: boolean
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
return self._send_request(
|
|
http_methods.PUT,
|
|
'/domain/' + domain + '/config',
|
|
params={'followProtocol': ''},
|
|
body=json.dumps({'followProtocol': follow}),
|
|
config=config)
|
|
|
|
@staticmethod
|
|
def _merge_config(self, config):
|
|
if config is None:
|
|
return self.config
|
|
else:
|
|
new_config = copy.copy(self.config)
|
|
new_config.merge_non_none_values(config)
|
|
return new_config
|
|
|
|
def _send_request(
|
|
self, http_method, path,
|
|
body=None, headers=None, params=None,
|
|
config=None,
|
|
body_parser=None):
|
|
config = self._merge_config(self, config)
|
|
if body_parser is None:
|
|
body_parser = handler.parse_json
|
|
|
|
return bce_http_client.send_request(
|
|
config, bce_v1_signer.sign, [handler.parse_error, body_parser],
|
|
http_method, utils.append_uri(CdnClient.prefix, path), body, headers, params)
|