5951 lines
206 KiB
Python
5951 lines
206 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 BCM.
|
|
"""
|
|
import copy
|
|
import json
|
|
import sys
|
|
import uuid
|
|
|
|
from baidubce import bce_base_client, utils, compat
|
|
from baidubce.auth import bce_v1_signer
|
|
from baidubce.http import handler, bce_http_client, http_methods
|
|
from baidubce.services.bcm import bcm_handler, bcm_model
|
|
from baidubce.utils import required
|
|
|
|
if sys.version_info[0] == 2:
|
|
value_type = (str, unicode)
|
|
else:
|
|
value_type = (str, bytes)
|
|
|
|
MAX_INSTANCE_NUMBER = 100
|
|
|
|
|
|
class BcmClient(bce_base_client.BceBaseClient):
|
|
"""
|
|
BCM base sdk client
|
|
"""
|
|
|
|
prefix = b'/json-api'
|
|
csm_prefix = b'/csm/api'
|
|
event_prefix = b'/event-api'
|
|
version = b'/v1'
|
|
version_v2 = b'/v2'
|
|
|
|
content_type_header_key = b"content-type"
|
|
content_type_header_value = b"application/json;charset=UTF-8"
|
|
request_id_header_key = b"x-bce-request-id"
|
|
|
|
def __init__(self, config=None):
|
|
bce_base_client.BceBaseClient.__init__(self, config)
|
|
|
|
def _merge_config(self, config=None):
|
|
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(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, BcmClient.prefix + BcmClient.version + path, body, headers, params)
|
|
|
|
def _send_csm_request(self, http_method, path, version=b'/v1',
|
|
body=None, headers=None, params=None, config=None, body_parser=None):
|
|
config = self._merge_config(config)
|
|
if body_parser is None:
|
|
body_parser = handler.parse_json
|
|
if headers is None:
|
|
headers = {}
|
|
if self.content_type_header_key not in headers:
|
|
headers[self.content_type_header_key] = self.content_type_header_value
|
|
if self.request_id_header_key not in headers:
|
|
headers[self.request_id_header_key] = uuid.uuid4()
|
|
|
|
return bce_http_client.send_request(
|
|
config, bce_v1_signer.sign, [bcm_handler.parse_error, body_parser],
|
|
http_method, BcmClient.csm_prefix + version + path, body, headers, params)
|
|
|
|
def _send_event_request(self, http_method, path,
|
|
body=None, headers=None, params=None, config=None, body_parser=None):
|
|
config = self._merge_config(config)
|
|
if body_parser is None:
|
|
body_parser = handler.parse_json
|
|
if headers is None:
|
|
headers = {}
|
|
if self.content_type_header_key not in headers:
|
|
headers[self.content_type_header_key] = self.content_type_header_value
|
|
if self.request_id_header_key not in headers:
|
|
headers[self.request_id_header_key] = uuid.uuid4()
|
|
|
|
return bce_http_client.send_request(
|
|
config, bce_v1_signer.sign, [bcm_handler.parse_error, body_parser],
|
|
http_method, BcmClient.event_prefix + BcmClient.version + path, body, headers, params)
|
|
|
|
def get_metric_data(self, user_id=None, scope=None, metric_name=None,
|
|
dimensions=None, statistics=None, start_time=None,
|
|
end_time=None, period_in_second=None, config=None):
|
|
"""
|
|
Return metric data of product instances owned by the authenticated user.
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/9jwvym3kb
|
|
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param scope:
|
|
Cloud product namespace, eg: BCE_BCC.
|
|
:type scope: string
|
|
|
|
:param metric_name:
|
|
The metric name of baidu cloud monitor, eg: CpuIdlePercent.
|
|
:type metric_name: string
|
|
|
|
:param dimensions:
|
|
Consists of dimensionName: dimensionValue.
|
|
Use semicolons when items have multiple dimensions,
|
|
such as dimensionName: dimensionValue; dimensionName: dimensionValue.
|
|
Only one dimension value can be specified for the same dimension.
|
|
eg: InstanceId:fakeid-2222
|
|
:type dimensions: string
|
|
|
|
:param statistics:
|
|
According to the format of statistics1,statistics2,statistics3,
|
|
the optional values are `average`, `maximum`, `minimum`, `sum`, `sampleCount`
|
|
:type statistics: string
|
|
|
|
:param start_time:
|
|
Query start time.
|
|
Please refer to the date and time, UTC date indication
|
|
:type start_time: string
|
|
|
|
:param end_time:
|
|
Query end time.
|
|
Please refer to the date and time, UTC date indication
|
|
:type end_time: string
|
|
|
|
:param period_in_second:
|
|
Statistical period.
|
|
Multiples of 60 in seconds (s).
|
|
:type period_in_second: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
scope = compat.convert_to_bytes(scope)
|
|
metric_name = compat.convert_to_bytes(metric_name)
|
|
path = b'/metricdata/%s/%s/%s' % (user_id, scope, metric_name)
|
|
params = {}
|
|
|
|
if dimensions is not None:
|
|
params[b'dimensions'] = dimensions
|
|
if statistics is not None:
|
|
params[b'statistics[]'] = statistics
|
|
if start_time is not None:
|
|
params[b'startTime'] = start_time
|
|
if end_time is not None:
|
|
params[b'endTime'] = end_time
|
|
if period_in_second is not None:
|
|
params[b'periodInSecond'] = period_in_second
|
|
|
|
return self._send_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def get_batch_metric_data(self, user_id=None, scope=None, metric_name=None,
|
|
dimensions=None, statistics=None, start_time=None,
|
|
end_time=None, period_in_second=None, config=None):
|
|
"""
|
|
Return batch metric data of product instances owned by the authenticated user.
|
|
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param scope:
|
|
Cloud product namespace, eg: BCE_BCC.
|
|
:type scope: string
|
|
|
|
:param metric_name:
|
|
The metric name of baidu cloud monitor, eg: CpuIdlePercent.
|
|
Use comma when items have multiple metrics,
|
|
such as metric1,metric2,metric3.
|
|
:type metric_name: string
|
|
|
|
:param dimensions:
|
|
Consists of dimensionName:dimensionValue.
|
|
Use comma when items have multiple dimensions,
|
|
such as dimensionName:dimensionValue,dimensionName:dimensionValue.
|
|
Only one dimension value can be specified for the same dimension.
|
|
eg: InstanceId:itk-1010,InstanceId:itk-1011
|
|
:type dimensions: string
|
|
|
|
:param statistics:
|
|
According to the format of statistics1,statistics2,statistics3,
|
|
the optional values are `average`, `maximum`, `minimum`, `sum`, `sampleCount`
|
|
:type statistics: string
|
|
|
|
:param start_time:
|
|
Query start time.
|
|
Please refer to the date and time, UTC date indication
|
|
:type start_time: string
|
|
|
|
:param end_time:
|
|
Query end time.
|
|
Please refer to the date and time, UTC date indication
|
|
:type end_time: string
|
|
|
|
:param period_in_second:
|
|
Statistical period.
|
|
Multiples of 60 in seconds (s).
|
|
:type period_in_second: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
scope = compat.convert_to_bytes(scope)
|
|
path = b'/metricdata/batch/%s/%s' % (user_id, scope)
|
|
params = {}
|
|
|
|
if metric_name is not None:
|
|
params[b'metricName[]'] = metric_name
|
|
if dimensions is not None:
|
|
params[b'dimensions[]'] = dimensions
|
|
if statistics is not None:
|
|
params[b'statistics[]'] = statistics
|
|
if start_time is not None:
|
|
params[b'startTime'] = start_time
|
|
if end_time is not None:
|
|
params[b'endTime'] = end_time
|
|
if period_in_second is not None:
|
|
params[b'periodInSecond'] = period_in_second
|
|
|
|
return self._send_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_namespace(self, user_id, name, namespace_alias=None, comment=None, config=None):
|
|
"""
|
|
create a custom namespace for custom monitor
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param name:
|
|
namespace name
|
|
:type name: string
|
|
|
|
:param namespace_alias:
|
|
namespace alias name
|
|
:type namespace_alias: string
|
|
|
|
:param comment:
|
|
namespace comment
|
|
:type user_id: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(name) <= 0:
|
|
raise ValueError('name should not be none or empty string')
|
|
|
|
path = b'/userId/%s/custom/namespaces/create' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"name": name,
|
|
"namespaceAlias": namespace_alias,
|
|
"comment": comment,
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def batch_delete_namespaces(self, user_id, names, config=None):
|
|
"""
|
|
create a custom namespace for custom monitor
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param names:
|
|
namespace name collection
|
|
:type names: string array
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(names) <= 0:
|
|
raise ValueError('names should not be empty')
|
|
|
|
path = b'/userId/%s/custom/namespaces/delete' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"names": names,
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_namespace(self, user_id, name, namespace_alias=None, comment=None, config=None):
|
|
"""
|
|
update a custom namespace for custom monitor
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param name:
|
|
namespace name
|
|
:type name: string
|
|
|
|
:param namespace_alias:
|
|
namespace alias name
|
|
:type namespace_alias: string
|
|
|
|
:param comment:
|
|
namespace comment
|
|
:type user_id: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(name) <= 0:
|
|
raise ValueError('name should not be none or empty string')
|
|
|
|
path = b'/userId/%s/custom/namespaces/update' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"name": name,
|
|
"namespaceAlias": namespace_alias,
|
|
"comment": comment,
|
|
}
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def list_namespaces(self, user_id, name=None, page_no=None, page_size=None, config=None):
|
|
"""
|
|
list custom namespaces
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param name:
|
|
namespace name prefix for query
|
|
:type name: string
|
|
|
|
:param page_no:
|
|
page number
|
|
:type page_no: int
|
|
|
|
:param page_size:
|
|
page size
|
|
:type page_size: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
|
|
path = b'/userId/%s/custom/namespaces/list' % compat.convert_to_bytes(user_id)
|
|
params = {
|
|
b'userId': user_id,
|
|
}
|
|
if name is not None:
|
|
params[b'name'] = name
|
|
if page_no is None:
|
|
params[b'pageNo'] = 1
|
|
else:
|
|
params[b'pageNo'] = page_no
|
|
if page_size is None:
|
|
params[b'pageSize'] = 10
|
|
else:
|
|
params[b'pageSize'] = page_size
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_namespace_metric(self, user_id, namespace, metric_name,
|
|
metric_alias=None, unit=None, cycle=None, dimensions=None, config=None):
|
|
"""
|
|
create custom metric in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param metric_name:
|
|
custom metric name
|
|
:type metric_name: string
|
|
|
|
:param metric_alias:
|
|
custom metric alias
|
|
:type metric_alias: string
|
|
|
|
:param unit:
|
|
custom metric unit
|
|
:type unit: string
|
|
|
|
:param unit:
|
|
custom metric unit
|
|
:type unit: string
|
|
|
|
:param cycle:
|
|
custom metric cycle
|
|
:type cycle: int
|
|
|
|
:param dimensions:
|
|
custom dimension collection
|
|
:type dimensions: CustomDimensionModel array
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
if len(metric_name) <= 0:
|
|
raise ValueError('metric_name should not be none or empty string')
|
|
|
|
path = (b'/userId/%s/custom/namespaces/%s/metrics/create' %
|
|
(compat.convert_to_bytes(user_id), compat.convert_to_bytes(namespace)))
|
|
body = {
|
|
"userId": user_id,
|
|
"namespace": namespace,
|
|
"metricName": metric_name,
|
|
}
|
|
if metric_alias is not None:
|
|
body["metricAlias"] = metric_alias
|
|
if unit is not None:
|
|
body["unit"] = unit
|
|
if cycle is not None:
|
|
body["cycle"] = cycle
|
|
else:
|
|
body["cycle"] = 60
|
|
if dimensions is not None:
|
|
body["dimensions"] = dimensions
|
|
else:
|
|
body["dimensions"] = []
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def batch_delete_namespace_metrics(self, user_id, namespace, ids, config=None):
|
|
"""
|
|
batch delete custom metric in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
custom namespace name
|
|
:type namespace: string
|
|
|
|
:param ids:
|
|
namespace metric id collection
|
|
:type ids: int array
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(ids) <= 0:
|
|
raise ValueError('ids should not be empty')
|
|
|
|
path = (b'/userId/%s/custom/namespaces/%s/metrics/delete' %
|
|
(compat.convert_to_bytes(user_id), compat.convert_to_bytes(namespace)))
|
|
body = {
|
|
"userId": user_id,
|
|
"namespace": namespace,
|
|
"ids": ids,
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_namespace_metric(self, user_id, namespace, metric_name,
|
|
metric_alias=None, unit=None, cycle=None, dimensions=None, config=None):
|
|
"""
|
|
update custom metric in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param metric_name:
|
|
custom metric name
|
|
:type metric_name: string
|
|
|
|
:param metric_alias:
|
|
custom metric alias
|
|
:type metric_alias: string
|
|
|
|
:param unit:
|
|
custom metric unit
|
|
:type unit: string
|
|
|
|
:param unit:
|
|
custom metric unit
|
|
:type unit: string
|
|
|
|
:param cycle:
|
|
custom metric cycle
|
|
:type cycle: int
|
|
|
|
:param dimensions:
|
|
custom dimension collection
|
|
:type dimensions: CustomDimensionModel array
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
if len(metric_name) <= 0:
|
|
raise ValueError('metric_name should not be none or empty string')
|
|
if cycle is None:
|
|
raise ValueError('cycle should not be none')
|
|
|
|
path = (b'/userId/%s/custom/namespaces/%s/metrics/%s' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(namespace),
|
|
compat.convert_to_bytes(metric_name)))
|
|
body = {
|
|
"userId": user_id,
|
|
"namespace": namespace,
|
|
"metricName": metric_name,
|
|
"cycle": cycle,
|
|
}
|
|
if metric_alias is not None:
|
|
body["metricAlias"] = metric_alias
|
|
if unit is not None:
|
|
body["unit"] = unit
|
|
if dimensions is not None:
|
|
body["dimensions"] = dimensions
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def list_namespace_metrics(self, user_id, namespace,
|
|
metric_name=None, metric_alias=None, page_no=None, page_size=None, config=None):
|
|
"""
|
|
list custom metric in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param metric_name:
|
|
custom metric name prefix for query
|
|
:type metric_name: string
|
|
|
|
:param metric_alias:
|
|
custom metric alias prefix for query
|
|
:type metric_alias: string
|
|
|
|
:param page_no:
|
|
page number
|
|
:type page_no: int
|
|
|
|
:param page_size:
|
|
page size
|
|
:type page_size: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
|
|
path = b'/userId/%s/custom/namespaces/metrics' % compat.convert_to_bytes(user_id)
|
|
params = {
|
|
b'userId': user_id,
|
|
b'namespace': namespace,
|
|
}
|
|
if metric_name is not None:
|
|
params[b'metricName'] = metric_name
|
|
if metric_alias is not None:
|
|
params[b'metricAlias'] = metric_alias
|
|
if page_no is None:
|
|
params[b'pageNo'] = 1
|
|
else:
|
|
params[b'pageNo'] = page_no
|
|
if page_size is None:
|
|
params[b'pageSize'] = 10
|
|
else:
|
|
params[b'pageSize'] = page_size
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def get_custom_metric(self, user_id, namespace, metric_name, config=None):
|
|
"""
|
|
get custom metric detail
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param metric_name:
|
|
custom metric name
|
|
:type metric_name: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
if len(metric_name) <= 0:
|
|
raise ValueError('metric_name should not be none or empty string')
|
|
|
|
path = (b'/userId/%s/custom/namespaces/%s/metrics/%s' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(namespace),
|
|
compat.convert_to_bytes(metric_name)))
|
|
params = {}
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_namespace_event(self, user_id, namespace, event_name, event_level,
|
|
event_name_alias=None, comment=None, config=None):
|
|
"""
|
|
create custom event in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param event_level:
|
|
custom event level
|
|
:type event_level: ENUM {'NOTICE', 'WARNING', 'MAJOR', 'CRITICAL'}
|
|
|
|
:param event_name:
|
|
custom event name
|
|
:type event_name: string
|
|
|
|
:param event_name_alias:
|
|
custom event alias
|
|
:type event_name_alias: string
|
|
|
|
:param comment:
|
|
custom event comment
|
|
:type comment: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
if len(event_name) <= 0:
|
|
raise ValueError('event_name should not be none or empty string')
|
|
if not bcm_model.EventLevel.contains(event_level):
|
|
raise ValueError('event_level must be one of %s' % str(bcm_model.EventLevel.all_event_levels()))
|
|
|
|
path = b'/custom/event/configs/create'
|
|
body = {
|
|
"userId": user_id,
|
|
"namespace": namespace,
|
|
"eventName": event_name,
|
|
"eventLevel": event_level,
|
|
}
|
|
if event_name_alias is not None:
|
|
body["eventNameAlias"] = event_name_alias
|
|
if comment is not None:
|
|
body["comment"] = comment
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def batch_delete_namespace_events(self, user_id, namespace, names, config=None):
|
|
"""
|
|
batch delete custom metric in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
custom namespace name
|
|
:type namespace: string
|
|
|
|
:param names:
|
|
namespace event name collection
|
|
:type names: string array
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(names) <= 0:
|
|
raise ValueError('names should not be empty')
|
|
|
|
path = b'/custom/event/configs/delete'
|
|
body = {
|
|
"userId": user_id,
|
|
"namespace": namespace,
|
|
"names": names,
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_namespace_event(self, user_id, namespace, event_name, event_level,
|
|
event_name_alias=None, comment=None, config=None):
|
|
"""
|
|
update custom event in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param event_level:
|
|
custom event level
|
|
:type event_level: ENUM {'NOTICE', 'WARNING', 'MAJOR', 'CRITICAL'}
|
|
|
|
:param event_name:
|
|
custom event name
|
|
:type event_name: string
|
|
|
|
:param event_name_alias:
|
|
custom event alias
|
|
:type event_name_alias: string
|
|
|
|
:param comment:
|
|
custom event comment
|
|
:type comment: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
if len(event_name) <= 0:
|
|
raise ValueError('event_name should not be none or empty string')
|
|
if not bcm_model.EventLevel.contains(event_level):
|
|
raise ValueError('event_level must be one of %s' % str(bcm_model.EventLevel.all_event_levels()))
|
|
|
|
path = b'/custom/event/configs/update'
|
|
body = {
|
|
"userId": user_id,
|
|
"namespace": namespace,
|
|
"eventName": event_name,
|
|
"eventLevel": event_level,
|
|
}
|
|
if event_name_alias is not None:
|
|
body["eventNameAlias"] = event_name_alias
|
|
if comment is not None:
|
|
body["comment"] = comment
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def list_namespace_events(self, user_id, namespace,
|
|
name=None, event_level=None, page_no=None, page_size=None, config=None):
|
|
"""
|
|
list custom event in one namespace
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param name:
|
|
custom metric name prefix for query
|
|
:type name: string
|
|
|
|
:param event_level:
|
|
custom metric level
|
|
:type event_level: None or ENUM {'NOTICE', 'WARNING', 'MAJOR', 'CRITICAL'}
|
|
|
|
:param page_no:
|
|
page number
|
|
:type page_no: int
|
|
|
|
:param page_size:
|
|
page size
|
|
:type page_size: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
if event_level is not None and (not bcm_model.EventLevel.contains(event_level)):
|
|
raise ValueError('event_level must be none or one of %s' % str(bcm_model.EventLevel.all_event_levels()))
|
|
|
|
path = b'/custom/event/configs/list'
|
|
params = {
|
|
b'userId': user_id,
|
|
b'namespace': namespace,
|
|
}
|
|
if name is not None:
|
|
params[b'name'] = name
|
|
if event_level is not None:
|
|
params[b'event_level'] = event_level
|
|
if page_no is None:
|
|
params[b'pageNo'] = 1
|
|
else:
|
|
params[b'pageNo'] = page_no
|
|
if page_size is None:
|
|
params[b'pageSize'] = 10
|
|
else:
|
|
params[b'pageSize'] = page_size
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def get_custom_event(self, user_id, namespace, event_name, config=None):
|
|
"""
|
|
get custom event detail
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/cktnhszhv
|
|
|
|
:param user_id:
|
|
master account id
|
|
:type user_id: string
|
|
|
|
:param namespace:
|
|
namespace name
|
|
:type namespace: string
|
|
|
|
:param event_name:
|
|
custom event name
|
|
:type event_name: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(namespace) <= 0:
|
|
raise ValueError('namespace should not be none or empty string')
|
|
if len(event_name) <= 0:
|
|
raise ValueError('metric_name should not be none or empty string')
|
|
|
|
path = b'/custom/event/configs/detail'
|
|
params = {
|
|
b"userId": user_id,
|
|
b"namespace": namespace,
|
|
b"eventName": event_name,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
@required(page_no=int, page_size=int)
|
|
def list_notify_group(self, page_no, page_size, name=None):
|
|
"""
|
|
:param name: notify name
|
|
:type name: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
headers = {self.content_type_header_key: self.content_type_header_value}
|
|
path = b'/alarm/notify/group/list'
|
|
body = {
|
|
"name": name,
|
|
"pageNo": page_no,
|
|
"pageSize": page_size
|
|
}
|
|
|
|
return self._send_request(http_methods.POST, path, headers=headers, body=json.dumps(body))
|
|
|
|
@required(page_no=int, page_size=int)
|
|
def list_notify_party(self, page_no, page_size, name=None):
|
|
"""
|
|
:param name: notify name
|
|
:type name: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
headers = {self.content_type_header_key: self.content_type_header_value}
|
|
path = b'/alarm/notify/party/list'
|
|
body = {
|
|
"name": name,
|
|
"pageNo": page_no,
|
|
"pageSize": page_size
|
|
}
|
|
|
|
return self._send_request(http_methods.POST, path, headers=headers, body=json.dumps(body))
|
|
|
|
@required(page_no=int, page_size=int, notifications=list, members=list)
|
|
def create_action(self, user_id, notifications, members, alias, disable_times=None, action_callbacks=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param notifications:
|
|
:type notifications: list of bcm_model.Notification
|
|
:param members:
|
|
:type members: list of bcm_model.Member
|
|
:param alias: action's alias
|
|
:type alias: string
|
|
:param disable_times: disable time
|
|
:type disable_times: list of bcm_model.DisableTime
|
|
:param action_callbacks: list of action callback
|
|
:type action_callbacks: list
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if disable_times is None:
|
|
disable_times = []
|
|
if action_callbacks is None:
|
|
action_callbacks = []
|
|
path = b'/userId/%s/action/create' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"notifications": notifications,
|
|
"members": members,
|
|
"alias": alias,
|
|
"disableTimes": disable_times,
|
|
"actionCallBacks": action_callbacks
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def delete_action(self, user_id, name):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param name: action name
|
|
:type name: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/userId/%s/action/delete' % compat.convert_to_bytes(user_id)
|
|
params = {b'name': name}
|
|
return self._send_csm_request(http_methods.DELETE, path, params=params)
|
|
|
|
@required(page_no=int, page_size=int)
|
|
def list_action(self, user_id, page_no, page_size, name=None, order=None):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
:param name: action name
|
|
:type name: string
|
|
:param order: desc or asc
|
|
:type name: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/userId/%s/action/actionList' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"name": name,
|
|
"pageNo": page_no,
|
|
"pageSize": page_size,
|
|
"order": order
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(page_no=int, page_size=int, notifications=list, members=list)
|
|
def update_action(self, user_id, name, notifications, members, alias, disable_times=None,
|
|
action_callbacks=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param name: action name
|
|
:type name: string
|
|
:param notifications:
|
|
:type notifications: list of bcm_model.Notification
|
|
:param members:
|
|
:type members: list of bcm_model.Member
|
|
:param alias: action's alias
|
|
:type alias: string
|
|
:param disable_times: disable time
|
|
:type disable_times: list of bcm_model.DisableTime
|
|
:param action_callbacks: list of action callback
|
|
:type action_callbacks: list
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if disable_times is None:
|
|
disable_times = []
|
|
if action_callbacks is None:
|
|
action_callbacks = []
|
|
path = b'/userId/%s/action/update' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"productName": user_id,
|
|
"name": name,
|
|
"notifications": notifications,
|
|
"members": members,
|
|
"alias": alias,
|
|
"disableTimes": disable_times,
|
|
"actionCallBacks": action_callbacks,
|
|
"source": "USER"
|
|
}
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body))
|
|
|
|
def log_extract(self, user_id, extract_rule, log_example):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param extract_rule: the log extract rule
|
|
:type: string
|
|
:param log_example: log example
|
|
:type: string
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/userId/%s/application/logextract' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"extractRule": extract_rule,
|
|
"logExample": log_example
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body),
|
|
body_parser=bcm_handler.parse_json_list)
|
|
|
|
def query_metric_meta_for_application(self, user_id, app_name, task_name, metric_name, dimension_keys,
|
|
instances=None):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id string
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param task_name: task name
|
|
:type task_name: string
|
|
:param metric_name:
|
|
:type metric_name: string
|
|
:param dimension_keys: multi dimension keys
|
|
:type dimension_keys: list of string
|
|
:param instances: multiple instance names
|
|
:type instances: list of string
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
|
|
path = (b'/userId/%s/application/%s/task/%s/metricMeta' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(app_name),
|
|
compat.convert_to_bytes(task_name)))
|
|
params = {b'metricName': metric_name, b'dimensionKeys': ",".join(dimension_keys)}
|
|
print(params)
|
|
if instances is not None and len(instances) > 0:
|
|
params[b'instances'] = ",".join(instances)
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
def query_metric_data_for_application(self, user_id, app_name, task_name, metric_name, start_time, end_time,
|
|
instances=None, cycle=None, dimensions=None, statistics=None, aggr_data=None):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param task_name: task name
|
|
:type task_name: string
|
|
:param metric_name: metric name
|
|
:type metric_name: string
|
|
:param start_time: start time, such as 2023-12-05T09:54:15Z
|
|
:type start_time: string
|
|
:param end_time: end time, such as 2023-12-05T09:54:15Z
|
|
:type end_time: string
|
|
:param instances: multiple instance names
|
|
:type instances: list of string
|
|
:param cycle: period time
|
|
:type cycle: int
|
|
:param dimensions: dimensions, such as ["httpMethod:POST___GET,path:apipath","httpMethod:POST,path:apipath1]
|
|
:type dimensions: list of string
|
|
:param statistics: statistics, enum: average, maximum, minimum, sum, sampleCount
|
|
:type statistics: list of string
|
|
:param aggr_data: is aggregation data
|
|
:type aggr_data: bool
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/userId/%s/application/%s/task/%s/metricData' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(app_name),
|
|
compat.convert_to_bytes(task_name)))
|
|
params = {b'startTime': start_time, b'endTime': end_time, b'metricName': metric_name}
|
|
if statistics is not None and len(statistics) > 0:
|
|
params[b'statistics'] = ",".join(statistics)
|
|
if cycle is not None and cycle > 0:
|
|
params[b'cycle'] = cycle
|
|
if aggr_data is not None:
|
|
params[b'aggrData'] = aggr_data
|
|
if instances is not None and len(instances) > 0:
|
|
params[b'instances'] = ",".join(instances)
|
|
if dimensions is not None and len(dimensions) > 0:
|
|
params[b'dimensions'] = ",".join(dimensions)
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, body_parser=bcm_handler.parse_json_list)
|
|
|
|
def list_alarm_metrics_for_application(self, user_id, app_name, task_name, search_name=None):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param task_name: task name
|
|
:type task_name: string
|
|
:param search_name: metric name
|
|
:type search_name: string
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/userId/%s/application/%s/%s/alarm/metrics' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(app_name),
|
|
compat.convert_to_bytes(task_name)))
|
|
params = {}
|
|
if search_name is None:
|
|
params[b'searchName'] = search_name
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, body_parser=bcm_handler.parse_json_list)
|
|
|
|
def get_alarm_policy_for_application(self, user_id, alarm_name, app_name):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param alarm_name: alarm name
|
|
:type alarm_name: string
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/userId/%s/application/alarm/%s/config' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(alarm_name)))
|
|
params = {b'appName': app_name}
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
def delete_alarm_policy_for_application(self, user_id, alarm_name, app_name):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param alarm_name: alarm name
|
|
:type alarm_name: string
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/userId/%s/application/alarm/config' % compat.convert_to_bytes(user_id))
|
|
body = {
|
|
'appName': app_name,
|
|
"alarmName": alarm_name
|
|
}
|
|
return self._send_csm_request(http_methods.DELETE, path, body=json.dumps(body))
|
|
|
|
@required(page_no=int, page_size=int)
|
|
def list_alarm_policy_for_application(self, user_id, page_no, page_size=None, app_name=None, alarm_name=None,
|
|
action_enabled=None, src_type=None, task_name=None):
|
|
"""
|
|
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param alarm_name: alarm name
|
|
:type alarm_name: string
|
|
:param action_enabled: is action enabled
|
|
:type action_enabled: bool
|
|
:param src_type: task type, enum: PROC,PORT,LOG,SCR
|
|
:type src_type: string
|
|
:param task_name: task name
|
|
:type task_name: string
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/userId/%s/application/alarm/config/list' % compat.convert_to_bytes(user_id))
|
|
params = {
|
|
b'pageNo': page_no,
|
|
b'pageSize': page_size,
|
|
b'appName': app_name,
|
|
b'alarmName': alarm_name,
|
|
b'actionEnabled': action_enabled,
|
|
b'srcType': src_type,
|
|
b'taskName': task_name,
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
@required(rules=list)
|
|
def create_alarm_policy_for_application(self, user_id, alarm_description, alarm_name, app_name,
|
|
monitor_object_type, monitor_object, src_name, src_type, type, level,
|
|
rules, action_enabled=True, incident_actions=None, resume_actions=None,
|
|
insufficient_actions=None, insufficient_cycle=None, repeat_alarm_cycle=0,
|
|
max_repeat_count=0):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_description: alarm policy comment
|
|
:type alarm_description: string
|
|
:param alarm_name: unique alarm name in user_id
|
|
:type alarm_name: string
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param monitor_object_type: monitor object type, enum: APP, SERVICE
|
|
:type monitor_object_type: string
|
|
:param monitor_object: application monitor object
|
|
:type monitor_object: bcm_model.ApplicationMonitorObject
|
|
:param src_name: task name
|
|
:type src_name: string
|
|
:param src_type: task type, enum: PROC,PORT,LOG,SCR
|
|
:type src_type: string
|
|
:param type: alarm type
|
|
:type type: string
|
|
:param level: alarm level
|
|
:type level: string
|
|
:param rules: list of application alarm rules
|
|
:type rules: list of ApplicationAlarmRule
|
|
:param action_enabled: is alarm action enabled
|
|
:type action_enabled: bool
|
|
:param incident_actions: The action to be taken in the alarm state
|
|
:type incident_actions: list of string
|
|
:param resume_actions: The action to be taken in the alarm resume
|
|
:type resume_actions: list of string
|
|
:param insufficient_actions:
|
|
:type insufficient_actions: list of string
|
|
:param insufficient_cycle: insufficient cycle
|
|
:type insufficient_cycle: int
|
|
:param repeat_alarm_cycle: repeat alarm_cycle
|
|
:type repeat_alarm_cycle: int
|
|
:param max_repeat_count: max repeat count
|
|
:type max_repeat_count: int
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/userId/%s/application/alarm/config/create' % compat.convert_to_bytes(user_id))
|
|
body = {
|
|
"userId": user_id,
|
|
"alarmDescription": alarm_description,
|
|
"appName": app_name,
|
|
"alarmName": alarm_name,
|
|
"monitorObjectType": monitor_object_type,
|
|
"monitorObject": monitor_object,
|
|
"srcName": src_name,
|
|
"srcType": src_type,
|
|
"type": type,
|
|
"level": level,
|
|
"actionEnabled": action_enabled,
|
|
"incidentActions": incident_actions,
|
|
"resumeActions": resume_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"repeatAlarmCycle": repeat_alarm_cycle,
|
|
"maxRepeatCount": max_repeat_count,
|
|
"rules": rules
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(rules=list)
|
|
def update_alarm_policy_for_application(self, user_id, alarm_description, alarm_name, app_name,
|
|
monitor_object_type, monitor_object, src_name, src_type, type, level,
|
|
rules, action_enabled=True, incident_actions=None, resume_actions=None,
|
|
insufficient_actions=None, insufficient_cycle=None, repeat_alarm_cycle=0,
|
|
max_repeat_count=0):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_description: alarm policy comment
|
|
:type alarm_description: string
|
|
:param alarm_name: unique alarm name in user_id
|
|
:type alarm_name: string
|
|
:param app_name: application name
|
|
:type app_name: string
|
|
:param monitor_object_type: monitor object type, enum: APP, SERVICE
|
|
:type monitor_object_type: string
|
|
:param monitor_object: application monitor object
|
|
:type monitor_object: bcm_model.ApplicationMonitorObject
|
|
:param src_name: task name
|
|
:type src_name: string
|
|
:param src_type: task type, enum: PROC,PORT,LOG,SCR
|
|
:type src_type: string
|
|
:param type: alarm type
|
|
:type type: string
|
|
:param level: alarm level
|
|
:type level: string
|
|
:param rules: list of application alarm rules
|
|
:type rules: list of ApplicationAlarmRule
|
|
:param action_enabled: is alarm action enabled
|
|
:type action_enabled: bool
|
|
:param incident_actions: The action to be taken in the alarm state
|
|
:type incident_actions: list of string
|
|
:param resume_actions: The action to be taken in the alarm resume
|
|
:type resume_actions: list of string
|
|
:param insufficient_actions:
|
|
:type insufficient_actions: list of string
|
|
:param insufficient_cycle: insufficient cycle
|
|
:type insufficient_cycle: int
|
|
:param repeat_alarm_cycle: repeat alarm_cycle
|
|
:type repeat_alarm_cycle: int
|
|
:param max_repeat_count: max repeat count
|
|
:type max_repeat_count: int
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/userId/%s/application/alarm/config/update' % compat.convert_to_bytes(user_id))
|
|
body = {
|
|
"userId": user_id,
|
|
"alarmDescription": alarm_description,
|
|
"appName": app_name,
|
|
"alarmName": alarm_name,
|
|
"monitorObjectType": monitor_object_type,
|
|
"monitorObject": monitor_object,
|
|
"srcName": src_name,
|
|
"srcType": src_type,
|
|
"type": type,
|
|
"level": level,
|
|
"actionEnabled": action_enabled,
|
|
"incidentActions": incident_actions,
|
|
"resumeActions": resume_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"repeatAlarmCycle": repeat_alarm_cycle,
|
|
"maxRepeatCount": max_repeat_count,
|
|
"rules": rules
|
|
}
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body))
|
|
|
|
def create_dashboard(self, user_id=None, title=None, configure=None, dashboard_type=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param title:
|
|
Title of the dashboard
|
|
:type title: string
|
|
|
|
:param configure:
|
|
Configure the dashboard
|
|
:type configure:string
|
|
|
|
:param dashboard_type:
|
|
Dashboard type
|
|
:type dashboard_type:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {
|
|
"userId": user_id,
|
|
"title": title,
|
|
"configure": configure,
|
|
"type": dashboard_type
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/dashboard/products/%s/dashboards' % user_id
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard(self, user_id=None, dashboard_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s' % (user_id, dashboard_name)
|
|
return self._send_csm_request(http_methods.GET, path, config=config)
|
|
|
|
def update_dashboard(self, user_id=None, title=None, configure=None,
|
|
dashboard_type=None, dashboard_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param title:
|
|
Title of the dashboard
|
|
:type title: string
|
|
|
|
:param configure:
|
|
Configure the dashboard
|
|
:type configure:string
|
|
|
|
:param dashboard_type:
|
|
Dashboard type
|
|
:type dashboard_type:string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
body = {
|
|
"userId": user_id,
|
|
"title": title,
|
|
"configure": configure,
|
|
"type": dashboard_type
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s' % (user_id, dashboard_name)
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def delete_dashboard(self, user_id=None, dashboard_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s' % (user_id, dashboard_name)
|
|
return self._send_csm_request(http_methods.DELETE, path, config=config)
|
|
|
|
def duplicate_dashboard(self, user_id=None, dashboard_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
body = {
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s/duplicate' % (user_id, dashboard_name)
|
|
return self._send_csm_request(http_methods.POST, path, json.dumps(body), config=config)
|
|
|
|
def create_dashboard_widget(self, user_id=None, dashboard_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
body = {
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s/widgets' % (user_id, dashboard_name)
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard_widget(self, user_id=None, dashboard_name=None, widget_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param widget_name:
|
|
Widget name
|
|
:type widget_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
if len(widget_name) <= 0:
|
|
raise ValueError('widget_name should be none or empty string')
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
widget_name = compat.convert_to_bytes(widget_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s/widgets/%s' % (user_id, dashboard_name, widget_name)
|
|
return self._send_csm_request(http_methods.GET, path, config=config)
|
|
|
|
def delete_dashboard_widget(self, user_id=None, dashboard_name=None, widget_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param widget_name:
|
|
Widget name
|
|
:type widget_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
if len(widget_name) <= 0:
|
|
raise ValueError('widget_name should be none or empty string')
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
widget_name = compat.convert_to_bytes(widget_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s/widgets/%s' % (user_id, dashboard_name, widget_name)
|
|
return self._send_csm_request(http_methods.DELETE, path, config=config)
|
|
|
|
def duplicate_dashboard_widget(self, user_id=None, dashboard_name=None, widget_name=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param widget_name:
|
|
Widget name
|
|
:type widget_name:string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
if len(widget_name) <= 0:
|
|
raise ValueError('widget_name should be none or empty string')
|
|
body = {
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
widget_name = compat.convert_to_bytes(widget_name)
|
|
path = (b'/dashboard/products/%s/dashboards/%s/widgets/%s/duplicate' %
|
|
(user_id, dashboard_name, widget_name))
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_dashboard_widget(self, user_id=None, dashboard_name=None, widget_name=None,
|
|
widget_type=None, title=None, configure=None, config=None):
|
|
"""
|
|
Create a dashboard
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dashboard_name:
|
|
Dashboard name
|
|
:type dashboard_name:string
|
|
|
|
:param widget_name:
|
|
Widget name
|
|
:type widget_name:string
|
|
|
|
:param widget_type:
|
|
Widget type
|
|
:type widget_type:string
|
|
|
|
:param configure:
|
|
Widget configure
|
|
:type configure:object
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(dashboard_name) <= 0:
|
|
raise ValueError('dashboard_name should not be none or empty string')
|
|
if len(widget_name) <= 0:
|
|
raise ValueError('widget_name should be none or empty string')
|
|
body = {
|
|
"title": title,
|
|
"type": widget_type,
|
|
"configure": configure
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
dashboard_name = compat.convert_to_bytes(dashboard_name)
|
|
widget_name = compat.convert_to_bytes(widget_name)
|
|
path = b'/dashboard/products/%s/dashboards/%s/widgets/%s' % (user_id, dashboard_name, widget_name)
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard_report_data(self, data=None, time=None, config=None):
|
|
"""
|
|
Get dashboard report data
|
|
:param data:
|
|
Query data
|
|
:type data: object
|
|
|
|
:param time:
|
|
Query data time
|
|
:type time: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {
|
|
"data": data,
|
|
"time": time
|
|
}
|
|
path = b'/dashboard/metric/report'
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard_trend_data(self, data=None, time=None, config=None):
|
|
"""
|
|
Get dashboard report data
|
|
:param data:
|
|
Query data
|
|
:type data: object
|
|
|
|
:param time:
|
|
Query data time
|
|
:type time: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {
|
|
"data": data,
|
|
"time": time
|
|
}
|
|
path = b'/dashboard/metric/trend'
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard_gauge_chart_data(self, data=None, time=None, config=None):
|
|
"""
|
|
Get dashboard report data
|
|
:param data:
|
|
Query data
|
|
:type data: object
|
|
|
|
:param time:
|
|
Query data time
|
|
:type time: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {
|
|
"data": data,
|
|
"time": time
|
|
}
|
|
path = b'/dashboard/metric/gaugechart'
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard_billboard_data(self, data=None, time=None, config=None):
|
|
"""
|
|
Get dashboard report data
|
|
:param data:
|
|
Query data
|
|
:type data: object
|
|
|
|
:param time:
|
|
Query data time
|
|
:type time: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {
|
|
"data": data,
|
|
"time": time
|
|
}
|
|
path = b'/dashboard/metric/billboard'
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard_trend_senior_data(self, data=None, time=None, config=None):
|
|
"""
|
|
Get dashboard report data
|
|
:param data:
|
|
Query data
|
|
:type data: object
|
|
|
|
:param time:
|
|
Query data time
|
|
:type time: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
body = {
|
|
"data": data,
|
|
"time": time
|
|
}
|
|
path = b'/dashboard/metric/trend/senior'
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_dashboard_dimensions(self, user_id, metric_name, region, service, show_id,
|
|
dimensions=None, config=None):
|
|
"""
|
|
Get dashboard dimensions
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param dimensions:
|
|
dashboard dimensions
|
|
:type dimensions: string
|
|
|
|
:param metric_name:
|
|
dashboard metric_name
|
|
:type metric_name: string
|
|
|
|
:param region:
|
|
dashboard dimensions region
|
|
:type region: string
|
|
|
|
:param service:
|
|
cloud service
|
|
:type service:
|
|
|
|
:param show_id:
|
|
cloud resourceId
|
|
:type show_id:
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(metric_name) <= 0:
|
|
raise ValueError('metric_name should not be none or empty string')
|
|
if len(region) <= 0:
|
|
raise ValueError('region should not be none or empty string')
|
|
if len(service) <= 0:
|
|
raise ValueError('service should not be none or empty string')
|
|
if len(show_id) <= 0:
|
|
raise ValueError('show_id should not be none or empty string')
|
|
params = {
|
|
b'dimensions': dimensions,
|
|
b'userId': user_id,
|
|
b'metricName': metric_name,
|
|
b'region': region,
|
|
b'service': service,
|
|
b'showId': show_id,
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
service = compat.convert_to_bytes(service)
|
|
region = compat.convert_to_bytes(region)
|
|
path = b'/userId/%s/services/%s/region/%s/metric/dimensions' % (user_id, service, region)
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_application_data(self, name, type, user_id, alias=None, description=None, config=None):
|
|
"""
|
|
create application data
|
|
:param name:
|
|
:param type:
|
|
:param user_id:
|
|
:param alias:
|
|
:param description:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(type) <= 0:
|
|
raise ValueError("type should not be null")
|
|
if len(name) <= 0:
|
|
raise ValueError("name should not be null")
|
|
req = {
|
|
"name": name,
|
|
"type": type,
|
|
"userId": user_id,
|
|
}
|
|
if alias is not None:
|
|
req["alias"] = alias
|
|
if description is not None:
|
|
req["description"] = description
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application' % user_id
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(req), config=config)
|
|
|
|
def get_application_data_list(self, user_id, page_no=None, page_size=None, search_name=None, config=None):
|
|
"""
|
|
get_application_data_list
|
|
:param user_id:
|
|
:param page_no:
|
|
:param page_size:
|
|
:param search_name:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if page_no is None:
|
|
page_no = 1
|
|
if page_size is None:
|
|
page_size = 10
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application' % user_id
|
|
params = {
|
|
b'pageSize': page_size,
|
|
b'pageNo': page_no,
|
|
}
|
|
if search_name is not None:
|
|
params[b'searchName'] = search_name
|
|
return self._send_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def update_application_data(self, user_id, id, name, type, alias=None, description=None, config=None):
|
|
"""
|
|
update_application_data
|
|
:param user_id:
|
|
:param id:
|
|
:param name:
|
|
:param type:
|
|
:param alias:
|
|
:param description:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(type) <= 0:
|
|
raise ValueError("type should not be null")
|
|
if len(name) <= 0:
|
|
raise ValueError("name should not be null")
|
|
if len(id) <= 0:
|
|
raise ValueError("id should not be null")
|
|
req = {
|
|
"userId": user_id,
|
|
"id": id,
|
|
"name": name,
|
|
"type": type
|
|
}
|
|
if alias is not None:
|
|
req["alias"] = alias
|
|
if description is not None:
|
|
req["description"] = description
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application' % user_id
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(req), config=config)
|
|
|
|
def delete_application_data(self, user_id, name, config=None):
|
|
"""
|
|
delete_application_data
|
|
:param user_id:
|
|
:param name:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(name) <= 0:
|
|
raise ValueError("name should null be null")
|
|
req = {
|
|
"name": name
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application' % user_id
|
|
return self._send_csm_request(http_methods.DELETE, path, body=json.dumps(req), config=config)
|
|
|
|
def get_application_instance_list(self, user_id, region, app_name, search_name, page_no=None, page_size=None,
|
|
search_value=None, config=None):
|
|
"""
|
|
get_application_instance_list
|
|
:param user_id:
|
|
:param region:
|
|
:param app_name:
|
|
:param search_name:
|
|
:param page_no:
|
|
:param page_size:
|
|
:param search_value:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(region) <= 0:
|
|
raise ValueError("region should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if page_no is None:
|
|
page_no = 1
|
|
if page_size is None:
|
|
page_size = 10
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/instances/all' % user_id
|
|
req = {
|
|
"appName": app_name,
|
|
"region": region,
|
|
"pageNo": page_no,
|
|
"pageSize": page_size,
|
|
"searchName": search_name
|
|
}
|
|
if search_value is not None:
|
|
req["searchValue"] = search_value
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(req), config=config)
|
|
|
|
@required(user_id=value_type,
|
|
app_name=value_type,
|
|
host_list=list)
|
|
def create_application_instance(self, user_id, app_name, host_list, config=None):
|
|
"""
|
|
create_application_instance
|
|
:param user_id:
|
|
:param app_name:
|
|
:param host_list:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(host_list) <= 0:
|
|
raise ValueError("host_list should not be null")
|
|
host_list_json = []
|
|
for host in host_list:
|
|
host_list_json.append(host)
|
|
req = {
|
|
"appName": app_name,
|
|
"userId": user_id,
|
|
"hostList": host_list_json
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/instance/bind' % user_id
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(req), config=config)
|
|
|
|
def get_application_instance_created_list(self, user_id, app_name, region=None, config=None):
|
|
"""
|
|
get_application_instance_created_list
|
|
:param user_id:
|
|
:param app_name:
|
|
:param region:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
app_name = compat.convert_to_bytes(app_name)
|
|
path = b'/userId/%s/application/%s/instance/list' % (user_id, app_name)
|
|
params = None
|
|
if region is not None:
|
|
params = {
|
|
'region': region
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def delete_application_instance(self, user_id, app_name, id, config=None):
|
|
"""
|
|
delete_application_instance
|
|
:param user_id:
|
|
:param app_name:
|
|
:param id:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(id) <= 0:
|
|
raise ValueError("id should not be null")
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/instance' % user_id
|
|
req = {
|
|
"id": id,
|
|
"appName": app_name
|
|
}
|
|
return self._send_csm_request(http_methods.DELETE, path, body=json.dumps(req), config=config)
|
|
|
|
@required(user_id=value_type, app_name=value_type, alias_name=value_type, type=int,
|
|
target=value_type, cycle=int, description=value_type, log_example=value_type,
|
|
match_rule=value_type, rate=int, extract_result=list, metrics=list)
|
|
def create_application_instance_task(self, user_id, app_name, alias_name, type, target,
|
|
cycle=None, description=None, log_example=None, match_rule=None, rate=None,
|
|
extract_result=None, metrics=None, config=None):
|
|
"""
|
|
create_application_instance_task
|
|
:param user_id:
|
|
:param app_name:
|
|
:param alias_name:
|
|
:param type:
|
|
:param target:
|
|
:param cycle:
|
|
:param description:
|
|
:param log_example:
|
|
:param match_rule:
|
|
:param rate:
|
|
:param extract_result:
|
|
:param metrics:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if type is None:
|
|
raise ValueError("type should not be null")
|
|
if len(alias_name) <= 0:
|
|
raise ValueError("alias_name should not be null")
|
|
if len(target) <= 0:
|
|
raise ValueError("target should not be null")
|
|
if cycle is None:
|
|
cycle = 60
|
|
req = {
|
|
"appName": app_name,
|
|
"type": str(type),
|
|
"aliasName": alias_name,
|
|
"target": target,
|
|
"cycle": str(cycle)
|
|
}
|
|
if description is not None:
|
|
req["description"] = description
|
|
if str(type) == "2":
|
|
if log_example is None:
|
|
raise ValueError("log_example should not be null")
|
|
if match_rule is None:
|
|
raise ValueError("match_rule should not be null")
|
|
if rate is None:
|
|
raise ValueError("rate should not be null")
|
|
if extract_result is None:
|
|
raise ValueError("extract_result should not be null")
|
|
if metrics is None:
|
|
raise ValueError("metrics should not be null")
|
|
req["logExample"] = log_example
|
|
req["matchRule"] = match_rule
|
|
req["rate"] = rate
|
|
|
|
extract_result_json = []
|
|
for result in extract_result:
|
|
extract_result_json.append(result)
|
|
req["extractResult"] = extract_result_json
|
|
|
|
metrics_json = []
|
|
for metric in metrics:
|
|
metrics_json.append(metric)
|
|
req["metrics"] = metrics_json
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/task/create' % user_id
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(req), config=config)
|
|
|
|
def get_application_monitor_task_detail(self, user_id, app_name, task_name, config=None):
|
|
"""
|
|
get_application_monitor_task_detail
|
|
:param user_id:
|
|
:param app_name:
|
|
:param task_name:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(task_name) <= 0:
|
|
raise ValueError("task_name should not be null")
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
app_name = compat.convert_to_bytes(app_name)
|
|
task_name = compat.convert_to_bytes(task_name)
|
|
path = b'/userId/%s/application/%s/task/%s' % (user_id, app_name, task_name)
|
|
return self._send_csm_request(http_methods.GET, path, config=config)
|
|
|
|
def get_application_monitor_task_list(self, user_id, app_name, type=None, config=None):
|
|
"""
|
|
get_application_monitor_task_list
|
|
:param user_id:
|
|
:param app_name:
|
|
:param type:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
app_name = compat.convert_to_bytes(app_name)
|
|
path = b'/userId/%s/application/%s/task/list' % (user_id, app_name)
|
|
params = None
|
|
if type is not None:
|
|
params = {
|
|
'type': type
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config,
|
|
body_parser=bcm_handler.parse_json_list)
|
|
|
|
@required(user_id=value_type, app_name=value_type, name=value_type, alias_name=value_type, type=int,
|
|
target=value_type, cycle=int, description=value_type, log_example=value_type,
|
|
match_rule=value_type, rate=int, extract_result=list, metrics=list)
|
|
def update_application_monitor_task(self, user_id, app_name, alias_name, name, type, target,
|
|
cycle=None, description=None, log_example=None, match_rule=None, rate=None,
|
|
extract_result=None, metrics=None, config=None):
|
|
"""
|
|
update application monitor task
|
|
:param user_id:
|
|
:param app_name:
|
|
:param alias_name:
|
|
:param name:
|
|
:param type:
|
|
:param target:
|
|
:param cycle:
|
|
:param description:
|
|
:param log_example:
|
|
:param match_rule:
|
|
:param rate:
|
|
:param extract_result:
|
|
:param metrics:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(name) <= 0:
|
|
raise ValueError("name should not be null")
|
|
if type is None:
|
|
raise ValueError("type should not be null")
|
|
if len(alias_name) <= 0:
|
|
raise ValueError("alias_name should not be null")
|
|
if len(target) <= 0:
|
|
raise ValueError("target should not be null")
|
|
req = {
|
|
"appName": app_name,
|
|
"name": name,
|
|
"type": str(type),
|
|
"aliasName": alias_name,
|
|
"target": target,
|
|
}
|
|
if cycle is not None:
|
|
req["cycle"] = cycle
|
|
if description is not None:
|
|
req["description"] = description
|
|
if str(type) == "2":
|
|
if log_example is None:
|
|
raise ValueError("log_example should not be null")
|
|
if match_rule is None:
|
|
raise ValueError("match_rule should not be null")
|
|
if rate is None:
|
|
raise ValueError("rate should not be null")
|
|
if extract_result is None:
|
|
raise ValueError("extract_result should not be null")
|
|
if metrics is None:
|
|
raise ValueError("metrics should not be null")
|
|
req["logExample"] = log_example
|
|
req["matchRule"] = match_rule
|
|
req["rate"] = rate
|
|
|
|
extract_result_json = []
|
|
for result in extract_result:
|
|
extract_result_json.append(result)
|
|
req["extractResult"] = extract_result_json
|
|
|
|
metrics_json = []
|
|
for metric in metrics:
|
|
metrics_json.append(metric)
|
|
req["metrics"] = metrics_json
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/task/update' % user_id
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(req), config=config)
|
|
|
|
def delete_application_monitor_task(self, user_id, name, app_name, config=None):
|
|
"""
|
|
delete_application_monitor_task
|
|
:param user_id:
|
|
:param name:
|
|
:param app_name:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(name) <= 0:
|
|
raise ValueError("name should not be null")
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/task/delete' % user_id
|
|
req = {
|
|
"name": name,
|
|
"appName": app_name
|
|
}
|
|
return self._send_csm_request(http_methods.DELETE, path, body=json.dumps(req), config=config)
|
|
|
|
def create_application_dimension_table(self, user_id, app_name, table_name, map_content_json, config=None):
|
|
"""
|
|
create_application_dimension_table
|
|
:param user_id:
|
|
:param app_name:
|
|
:param table_name:
|
|
:param map_content_json:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(table_name) <= 0:
|
|
raise ValueError("table_name should not be null")
|
|
if len(map_content_json) <= 0:
|
|
raise ValueError("map_content_json should not be null")
|
|
req = {
|
|
"userId": user_id,
|
|
"appName": app_name,
|
|
"tableName": table_name,
|
|
"mapContentJson": map_content_json
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/dimensionMap/create' % user_id
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(req), config=config)
|
|
|
|
def get_application_dimension_table_list(self, user_id, app_name, search_name=None, config=None):
|
|
"""
|
|
get_application_dimension_table_list
|
|
:param user_id:
|
|
:param app_name:
|
|
:param search_name:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
app_name = compat.convert_to_bytes(app_name)
|
|
path = b'/userId/%s/application/%s/dimensionMap/list' % (user_id, app_name)
|
|
params = None
|
|
if search_name is not None:
|
|
params = {
|
|
'searchName': search_name
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def update_application_dimension_table(self, user_id, app_name, table_name, map_content_json, config=None):
|
|
"""
|
|
update_application_dimension_table
|
|
:param user_id:
|
|
:param app_name:
|
|
:param table_name:
|
|
:param map_content_json:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(table_name) <= 0:
|
|
raise ValueError("table_name should not be null")
|
|
if len(map_content_json) <= 0:
|
|
raise ValueError("map_content_json should not be null")
|
|
req = {
|
|
"userId": user_id,
|
|
"appName": app_name,
|
|
"tableName": table_name,
|
|
"mapContentJson": map_content_json
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/dimensionMap/update' % user_id
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(req), config=config)
|
|
|
|
def delete_application_dimension_table(self, user_id, app_name, table_name, config=None):
|
|
"""
|
|
delete_application_dimension_table
|
|
:param user_id:
|
|
:param app_name:
|
|
:param table_name:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(app_name) <= 0:
|
|
raise ValueError("app_name should not be null")
|
|
if len(table_name) <= 0:
|
|
raise ValueError("table_name should not be null")
|
|
req = {
|
|
"userId": user_id,
|
|
"appName": app_name,
|
|
"tableName": table_name
|
|
}
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/application/dimensionMap/delete' % user_id
|
|
return self._send_csm_request(http_methods.DELETE, path, body=json.dumps(req), config=config)
|
|
|
|
@required(page_no=int, page_size=int, account_id=str, start_time=str, end_time=str)
|
|
def get_cloud_event_data(self, page_no=1, page_size=10, start_time=None, end_time=None, account_id=None,
|
|
ascending=None, scope=None, region=None, event_level=None, event_name=None,
|
|
event_alias=None, resource_type=None, resource_id=None, event_id=None):
|
|
"""
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
:param start_time: start time, such as 2023-12-05T09:54:15Z
|
|
:type start_time: string
|
|
:param end_time: end time, such as 2023-12-05T09:54:15Z
|
|
:type end_time: string
|
|
:param account_id: account id
|
|
:type account_id: string
|
|
:param ascending: ascending
|
|
:type ascending: bool
|
|
:param scope: scope
|
|
:type scope: string
|
|
:param region: region
|
|
:type region: string
|
|
:param event_level: event level
|
|
:type event_level: None or ENUM {'NOTICE', 'WARNING', 'MAJOR', 'CRITICAL'}
|
|
:param event_name: event name
|
|
:type event_name: string
|
|
:param event_alias: event alias
|
|
:type event_alias: string
|
|
:param resource_type: resource type
|
|
:type resource_type: string
|
|
:param resource_id: resource id
|
|
:type resource_id: string
|
|
:param event_id: event id
|
|
:type event_id: string
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/bce-event/list'
|
|
params = {
|
|
b'pageNo': page_no,
|
|
b'pageSize': page_size,
|
|
b'startTime': start_time,
|
|
b'endTime': end_time,
|
|
b'accountId': account_id,
|
|
b'ascending': ascending,
|
|
b'scope': scope,
|
|
b'region': region,
|
|
b'eventLevel': event_level,
|
|
b'eventName': event_name,
|
|
b'eventAlias': event_alias,
|
|
b'resourceType': resource_type,
|
|
b'resourceId': resource_id,
|
|
b'eventId': event_id,
|
|
}
|
|
return self._send_event_request(http_methods.GET, path, params=params)
|
|
|
|
@required(page_no=int, page_size=int, account_id=str, start_time=str, end_time=str)
|
|
def get_platform_event_data(self, page_no=1, page_size=10, start_time=None, end_time=None, account_id=None,
|
|
ascending=None, scope=None, region=None, event_level=None, event_name=None,
|
|
event_alias=None, event_id=None):
|
|
"""
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
:param start_time: start time, such as 2023-12-05T09:54:15Z
|
|
:type start_time: string
|
|
:param end_time: end time, such as 2023-12-05T09:54:15Z
|
|
:type end_time: string
|
|
:param account_id: account id
|
|
:type account_id: string
|
|
:param ascending: ascending
|
|
:type ascending: bool
|
|
:param scope: scope
|
|
:type scope: string
|
|
:param region: region
|
|
:type region: string
|
|
:param event_level: event level
|
|
:type event_level: None or ENUM {'NOTICE', 'WARNING', 'MAJOR', 'CRITICAL'}
|
|
:param event_name: event name
|
|
:type event_name: string
|
|
:param event_alias: event alias
|
|
:type event_alias: string
|
|
:param event_id: event id
|
|
:type event_id: string
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/platform-event/list'
|
|
params = {
|
|
b'pageNo': page_no,
|
|
b'pageSize': page_size,
|
|
b'startTime': start_time,
|
|
b'endTime': end_time,
|
|
b'accountId': account_id,
|
|
b'ascending': ascending,
|
|
b'scope': scope,
|
|
b'region': region,
|
|
b'eventLevel': event_level,
|
|
b'eventName': event_name,
|
|
b'eventAlias': event_alias,
|
|
b'eventId': event_id,
|
|
}
|
|
return self._send_event_request(http_methods.GET, path, params=params)
|
|
|
|
@required(account_id=str, service_name=str, name=str, block_status=str, incident_actions=list)
|
|
def create_event_policy(self, account_id, service_name, name, block_status, event_filter,
|
|
resource, incident_actions):
|
|
"""
|
|
:param account_id: account id
|
|
:type account_id: string
|
|
:param service_name: service name
|
|
:type service_name: string
|
|
:param name: event policy name
|
|
:type name: string
|
|
:param block_status: block status, enum: NORMAL, BLOCKED
|
|
:type block_status: string
|
|
:param event_filter: event filter
|
|
:type event_filter: EventFilter
|
|
:param resource: resource filter
|
|
:type resource: EventResourceFilter
|
|
:param incident_actions: incident actions
|
|
:type incident_actions: list of string
|
|
"""
|
|
if event_filter is None:
|
|
raise ValueError('event_filter should not be none')
|
|
if resource is None:
|
|
raise ValueError('resource should not be none')
|
|
|
|
path = b'/accounts/%s/services/%s/alarm-policies' % (compat.convert_to_bytes(account_id),
|
|
compat.convert_to_bytes(service_name))
|
|
body = {
|
|
"account_id": account_id,
|
|
"service_name": service_name,
|
|
"name": name,
|
|
"blockStatus": block_status,
|
|
"eventFilter": event_filter,
|
|
"resource": resource,
|
|
"incidentActions": incident_actions
|
|
}
|
|
return self._send_event_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(user_id=str, region=str, service_name=str, type_name=str, name=str)
|
|
def create_instance_group(self, user_id, region, service_name, type_name, name, resource_id_list):
|
|
"""
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param region: region
|
|
:type region: string
|
|
:param service_name: service name
|
|
:type service_name: string
|
|
:param type_name: type name
|
|
:type type_name: string
|
|
:param name: instance group name
|
|
:type name: string
|
|
:param resource_id_list: resource id list
|
|
:type resource_id_list: list of MonitorResource
|
|
"""
|
|
path = b'/userId/%s/instance-group' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"region": region,
|
|
"serviceName": service_name,
|
|
"typeName": type_name,
|
|
"name": name,
|
|
"resourceIdList": resource_id_list
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(user_id=str, ig_id=str, region=str, service_name=str, type_name=str, name=str)
|
|
def update_instance_group(self, ig_id, user_id, region, service_name, type_name, name):
|
|
"""
|
|
:param ig_id: instance group id
|
|
:type ig_id: string
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param region: region
|
|
:type region: string
|
|
:param service_name: service name
|
|
:type service_name: string
|
|
:param type_name: type name
|
|
:type type_name: string
|
|
:param name: instance group name
|
|
:type name: string
|
|
"""
|
|
path = b'/userId/%s/instance-group' % compat.convert_to_bytes(user_id)
|
|
body = {
|
|
"id": ig_id,
|
|
"userId": user_id,
|
|
"region": region,
|
|
"serviceName": service_name,
|
|
"typeName": type_name,
|
|
"name": name,
|
|
}
|
|
return self._send_csm_request(http_methods.PATCH, path, body=json.dumps(body))
|
|
|
|
@required(user_id=str, ig_id=str)
|
|
def delete_instance_group(self, user_id, ig_id):
|
|
"""
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param ig_id: instance group id
|
|
:type ig_id: string
|
|
"""
|
|
path = b'/userId/%s/instance-group/%s' % (compat.convert_to_bytes(user_id), compat.convert_to_bytes(ig_id))
|
|
return self._send_csm_request(http_methods.DELETE, path)
|
|
|
|
@required(user_id=str, ig_id=str)
|
|
def get_instance_group(self, user_id, ig_id):
|
|
"""
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param ig_id: instance group id
|
|
:type ig_id: string
|
|
"""
|
|
path = b'/userId/%s/instance-group/%s' % (compat.convert_to_bytes(user_id), compat.convert_to_bytes(ig_id))
|
|
return self._send_csm_request(http_methods.GET, path)
|
|
|
|
@required(user_id=str, page_no=int, page_size=int)
|
|
def list_instance_group(self, user_id, name, service_name, region, type_name, page_no, page_size):
|
|
"""
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param name: instance group name
|
|
:type name: string
|
|
:param service_name: service name
|
|
:type service_name: string
|
|
:param region: region
|
|
:type region: string
|
|
:param type_name: type name
|
|
:type type_name: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
"""
|
|
path = b'/userId/%s/instance-group/list' % compat.convert_to_bytes(user_id)
|
|
params = {
|
|
b"userId": user_id,
|
|
b"name": name,
|
|
b"serviceName": service_name,
|
|
b"region": region,
|
|
b"typeName": type_name,
|
|
b"pageNo": page_no,
|
|
b"pageSize": page_size
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
@required(user_id=str, ig_id=str, resource_id_list=list)
|
|
def add_ig_instance(self, ig_id, user_id, resource_id_list):
|
|
"""
|
|
:param ig_id: instance group id
|
|
:type ig_id: string
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param resource_id_list: resource id list
|
|
:type resource_id_list: list of MonitorResource
|
|
"""
|
|
path = b'/userId/%s/instance-group/%s/instance/add' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(ig_id))
|
|
body = {
|
|
"id": ig_id,
|
|
"userId": user_id,
|
|
"resourceIdList": resource_id_list
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(user_id=str, ig_id=str, resource_id_list=list)
|
|
def remove_ig_instance(self, ig_id, user_id, resource_id_list):
|
|
"""
|
|
:param ig_id: instance group id
|
|
:type ig_id: string
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param resource_id_list: resource id list
|
|
:type resource_id_list: list of MonitorResource
|
|
"""
|
|
path = b'/userId/%s/instance-group/%s/instance/remove' % (compat.convert_to_bytes(user_id),
|
|
compat.convert_to_bytes(ig_id))
|
|
body = {
|
|
"id": ig_id,
|
|
"userId": user_id,
|
|
"resourceIdList": resource_id_list
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(user_id=str, ig_id=str, service_name=str, type_name=str, region=str, view_type=str,
|
|
page_no=int, page_size=int)
|
|
def list_ig_instance(self, user_id, ig_id, service_name, type_name, region, view_type, page_no, page_size):
|
|
"""
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param ig_id: instance group id
|
|
:type ig_id: string
|
|
:param service_name: service name
|
|
:type service_name: string
|
|
:param type_name: type name
|
|
:type type_name: string
|
|
:param region: region
|
|
:type region: string
|
|
:param view_type: view type, enum: LIST_VIEW, DETAIL_VIEW
|
|
:type view_type: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
"""
|
|
path = b'/userId/%s/instance-group/instance/list' % compat.convert_to_bytes(user_id)
|
|
params = {
|
|
b"id": ig_id,
|
|
b"userId": user_id,
|
|
b"serviceName": service_name,
|
|
b"typeName": type_name,
|
|
b"region": region,
|
|
b"viewType": view_type,
|
|
b"pageNo": page_no,
|
|
b"pageSize": page_size
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
@required(user_id=str, service_name=str, type_name=str, region=str, view_type=str, keyword_type=str, keyword=str,
|
|
page_no=int, page_size=int)
|
|
def list_all_instance(self, user_id, service_name, type_name, region, view_type, keyword_type, keyword,
|
|
page_no, page_size):
|
|
"""
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param service_name: service name
|
|
:type service_name: string
|
|
:param type_name: type name
|
|
:type type_name: string
|
|
:param region: region
|
|
:type region: string
|
|
:param view_type: view type, enum: LIST_VIEW, DETAIL_VIEW
|
|
:type view_type: string
|
|
:param keyword_type: keyword type, enum: name, id
|
|
:type keyword_type: string
|
|
:param keyword: keyword
|
|
:type keyword: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
"""
|
|
path = b'/userId/%s/instance/list' % compat.convert_to_bytes(user_id)
|
|
params = {
|
|
b"userId": user_id,
|
|
b"serviceName": service_name,
|
|
b"typeName": type_name,
|
|
b"region": region,
|
|
b"viewType": view_type,
|
|
b"keywordType": keyword_type,
|
|
b"keyword": keyword,
|
|
b"pageNo": page_no,
|
|
b"pageSize": page_size
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
@required(user_id=str, ig_id=str, ig_uuid=str, service_name=str, type_name=str, region=str, view_type=str,
|
|
keyword_type=str, keyword=str, page_no=int, page_size=int)
|
|
def list_filter_instance(self, user_id, ig_id, ig_uuid, service_name, type_name, region, view_type,
|
|
keyword_type, keyword, page_no, page_size):
|
|
"""
|
|
:param user_id: user id
|
|
:type user_id: string
|
|
:param ig_id: instance group id
|
|
:type ig_id: string
|
|
:param ig_uuid: instance group uuid
|
|
:type ig_uuid: string
|
|
:param service_name: service name
|
|
:type service_name: string
|
|
:param type_name: type name
|
|
:type type_name: string
|
|
:param region: region
|
|
:type region: string
|
|
:param view_type: view type, enum: LIST_VIEW, DETAIL_VIEW
|
|
:type view_type: string
|
|
:param keyword_type: keyword type, enum: name, id
|
|
:type keyword_type: string
|
|
:param keyword: keyword
|
|
:type keyword: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
"""
|
|
path = b'/userId/%s/instance/filteredList' % compat.convert_to_bytes(user_id)
|
|
params = {
|
|
b"userId": user_id,
|
|
b"id": ig_id,
|
|
b"uuid": ig_uuid,
|
|
b"serviceName": service_name,
|
|
b"typeName": type_name,
|
|
b"region": region,
|
|
b"viewType": view_type,
|
|
b"keywordType": keyword_type,
|
|
b"keyword": keyword,
|
|
b"pageNo": page_no,
|
|
b"pageSize": page_size
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
def push_metric_data(self, user_id=None, scope=None, metric_data=None, config=None):
|
|
|
|
"""
|
|
:param user_id: user_id
|
|
:type user_id: string
|
|
:param scope: scope
|
|
:type scope: string
|
|
:param metric_data: metric_data
|
|
:type bcm_model.MetricDatum array
|
|
:return:
|
|
"""
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
scope = compat.convert_to_bytes(scope)
|
|
path = b'/metricdata/%s/%s' % (user_id, scope)
|
|
body = {
|
|
"metricData": metric_data
|
|
}
|
|
|
|
return self._send_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def get_custom_metric_data(self, user_id=None, namespaces=None, metric_name=None,
|
|
dimensions=None, statistics=None, start_time=None,
|
|
end_time=None, cycle=None, config=None):
|
|
"""
|
|
Return metric data of product instances owned by the authenticated user.
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/9jwvym3kb
|
|
|
|
:param user_id:
|
|
Master account ID
|
|
:type user_id: string
|
|
|
|
:param namespaces:
|
|
Cloud product namespace, eg: BCE_BCC.
|
|
:type namespaces: string
|
|
|
|
:param metric_name:
|
|
The metric name of baidu cloud monitor, eg: CpuIdlePercent.
|
|
:type metric_name: string
|
|
|
|
:param dimensions:
|
|
Consists of dimensionName: dimensionValue.
|
|
Use semicolons when items have multiple dimensions,
|
|
such as dimensionName: dimensionValue; dimensionName: dimensionValue.
|
|
Only one dimension value can be specified for the same dimension.
|
|
eg: InstanceId:fakeid-2222
|
|
:type dimensions: string
|
|
|
|
:param statistics:
|
|
According to the format of statistics1,statistics2,statistics3,
|
|
the optional values are `average`, `maximum`, `minimum`, `sum`, `sampleCount`
|
|
:type statistics: string
|
|
|
|
:param start_time:
|
|
Query start time.
|
|
Please refer to the date and time, UTC date indication
|
|
:type start_time: string
|
|
|
|
:param end_time:
|
|
Query end time.
|
|
Please refer to the date and time, UTC date indication
|
|
:type end_time: string
|
|
|
|
:param cycle:
|
|
Statistical period.
|
|
Multiples of 60 in seconds (s).
|
|
:type cycle: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
namespaces = compat.convert_to_bytes(namespaces)
|
|
metric_name = compat.convert_to_bytes(metric_name)
|
|
path = b'/userId/%s/custom/namespaces/%s/metrics/%s/data' % (user_id, namespaces, metric_name)
|
|
|
|
body = {
|
|
"statistics": statistics,
|
|
"dimensions": dimensions,
|
|
"startTime": start_time,
|
|
"endTime": end_time,
|
|
"cycle": cycle
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body),
|
|
body_parser=bcm_handler.parse_json_list, config=config)
|
|
|
|
def push_custom_metric_data(self, user_id=None, namespace=None, metric_name=None,
|
|
dimensions=None, value=None,
|
|
timestamp=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param namespace:
|
|
:type namespace: string
|
|
:param metric_name:
|
|
:type metric_name: string
|
|
:param dimensions:
|
|
:type dimensions: bcm_model.Dimension array
|
|
:param value:
|
|
:type value: double
|
|
:param timestamp:
|
|
:type timestamp: string
|
|
:param config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
namespace = compat.convert_to_bytes(namespace)
|
|
path = b'/userId/%s/custom/data' % (user_id)
|
|
body = {
|
|
"namespace": namespace,
|
|
"metricName": metric_name,
|
|
"dimensions": dimensions,
|
|
"value": value,
|
|
"timestamp": timestamp
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def create_site_http_task_config(self, user_id=None, task_name=None, address=None,
|
|
method=None, post_content=None,
|
|
advance_config=None, cycle=None, idc=None, timeout=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param method:
|
|
:type method: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/http/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"method": method,
|
|
"postContent": post_content,
|
|
"advanceConfig": advance_config,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_http_task_config(self, user_id=None, task_id=None, task_name=None, address=None,
|
|
method=None, post_content=None,
|
|
advance_config=None, cycle=None, idc=None, timeout=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param method:
|
|
:type method: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/http/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"method": method,
|
|
"postContent": post_content,
|
|
"advanceConfig": advance_config,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_http_task_config(self, user_id=None, task_id=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/http/detail' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params["taskId"] = task_id
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_site_https_task_config(self, user_id=None, task_name=None, address=None,
|
|
method=None, post_content=None,
|
|
advance_config=None, cycle=None, idc=None, timeout=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param method:
|
|
:type method: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/https/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"method": method,
|
|
"postContent": post_content,
|
|
"advanceConfig": advance_config,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_https_task_config(self, user_id=None, task_id=None, task_name=None, address=None,
|
|
method=None, post_content=None,
|
|
advance_config=None, cycle=None, idc=None, timeout=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param method:
|
|
:type method: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/https/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"method": method,
|
|
"postContent": post_content,
|
|
"advanceConfig": advance_config,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_https_task_config(self, user_id=None, task_id=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/https/detail' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params["taskId"] = task_id
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_site_ping_task_config(self, user_id=None, task_name=None, address=None,
|
|
packet_count=None, packet_loss_rate=None, cycle=None, idc=None,
|
|
timeout=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param packet_count:
|
|
:type packet_count: int
|
|
:param packet_loss_rate:
|
|
:type packet_loss_rate: int
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/ping/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"packetCount": packet_count,
|
|
"packetLossRate": packet_loss_rate,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_ping_task_config(self, user_id=None, task_id=None, task_name=None, address=None,
|
|
packet_count=None, packet_loss_rate=None, cycle=None, idc=None,
|
|
timeout=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param packet_count:
|
|
:type packet_count: int
|
|
:param packet_loss_rate:
|
|
:type packet_loss_rate: int
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/ping/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"packetCount": packet_count,
|
|
"packetLossRate": packet_loss_rate,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_ping_task_config(self, user_id=None, task_id=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/ping/detail' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params["taskId"] = task_id
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_site_tcp_task_config(self, user_id=None, task_name=None, address=None,
|
|
port=None, advance_config=None, cycle=None, idc=None, timeout=None,
|
|
input_type=None, output_type=None, input=None, expected_output=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param method:
|
|
:type method: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/tcp/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"port": port,
|
|
"advanceConfig": advance_config,
|
|
"inputType": input_type,
|
|
"outputType": output_type,
|
|
"input": input,
|
|
"expectedOutput": expected_output,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_tcp_task_config(self, user_id=None, task_id=None, task_name=None, address=None,
|
|
port=None, advance_config=None, cycle=None, idc=None, timeout=None,
|
|
input_type=None, output_type=None, input=None, expected_output=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param port:
|
|
:type port: int
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param input_type:
|
|
:type input_type: int
|
|
:param output_type:
|
|
:type output_type: int
|
|
:param input:
|
|
:type input: string
|
|
:param expected_output:
|
|
:type expected_output: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/tcp/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"port": port,
|
|
"advanceConfig": advance_config,
|
|
"inputType": input_type,
|
|
"outputType": output_type,
|
|
"input": input,
|
|
"expectedOutput": expected_output,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_tcp_task_config(self, user_id=None, task_id=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/tcp/detail' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params["taskId"] = task_id
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_site_udp_task_config(self, user_id=None, task_name=None, address=None,
|
|
port=None, advance_config=None, cycle=None, idc=None, timeout=None,
|
|
input_type=None, output_type=None, input=None, expected_output=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param method:
|
|
:type method: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/udp/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"port": port,
|
|
"advanceConfig": advance_config,
|
|
"inputType": input_type,
|
|
"outputType": output_type,
|
|
"input": input,
|
|
"expectedOutput": expected_output,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_udp_task_config(self, user_id=None, task_id=None, task_name=None, address=None,
|
|
port=None, advance_config=None, cycle=None, idc=None, timeout=None,
|
|
input_type=None, output_type=None, input=None, expected_output=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param port:
|
|
:type port: int
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param advance_config:
|
|
:type advance_config: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param input_type:
|
|
:type input_type: int
|
|
:param output_type:
|
|
:type output_type: int
|
|
:param input:
|
|
:type input: string
|
|
:param expected_output:
|
|
:type expected_output: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/udp/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"port": port,
|
|
"advanceConfig": advance_config,
|
|
"inputType": input_type,
|
|
"outputType": output_type,
|
|
"input": input,
|
|
"expectedOutput": expected_output,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_udp_task_config(self, user_id=None, task_id=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/udp/detail' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params["taskId"] = task_id
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_site_ftp_task_config(self, user_id=None, task_name=None, address=None,
|
|
port=None, anonymous_login=None, cycle=None, idc=None, timeout=None,
|
|
user_name=None, password=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param port:
|
|
:type port: int
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param anonymous_login:
|
|
:type anonymous_login: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param user_name:
|
|
:type user_name: string
|
|
:param password:
|
|
:type password: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/ftp/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"port": port,
|
|
"anonymousLogin": anonymous_login,
|
|
"userName": user_name,
|
|
"password": password,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_ftp_task_config(self, user_id=None, task_id=None, task_name=None, address=None,
|
|
port=None, anonymous_login=None, cycle=None, idc=None, timeout=None,
|
|
user_name=None, password=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param port:
|
|
:type port: int
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param anonymous_login:
|
|
:type anonymous_login: bool
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param user_name:
|
|
:type user_name: string
|
|
:param password:
|
|
:type password: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/ftp/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"port": port,
|
|
"anonymousLogin": anonymous_login,
|
|
"userName": user_name,
|
|
"password": password,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_ftp_task_config(self, user_id=None, task_id=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/ftp/detail' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params["taskId"] = task_id
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_site_dns_task_config(self, user_id=None, task_name=None, address=None,
|
|
cycle=None, idc=None, timeout=None,
|
|
server=None, resolve_type=None, kidnap_white=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param server:
|
|
:type server: string
|
|
:param resolve_type:
|
|
:type resolve_type: ENUM {'RECURSION', 'ITERATION'}
|
|
:param kidnap_white:
|
|
:type kidnap_white: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/dns/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"server": server,
|
|
"resolveType": resolve_type,
|
|
"kidnapWhite": kidnap_white,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_dns_task_config(self, user_id=None, task_id=None, task_name=None, address=None,
|
|
cycle=None, idc=None, timeout=None,
|
|
server=None, resolve_type=None, kidnap_white=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param task_name:
|
|
:type task_name: string
|
|
:param address:
|
|
:type address: string
|
|
:param post_content:
|
|
:type post_content: string
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param idc:
|
|
:type idc: string
|
|
:param timeout:
|
|
:type timeout: int
|
|
:param server:
|
|
:type server: string
|
|
:param resolve_type:
|
|
:type resolve_type: ENUM {'RECURSION', 'ITERATION'}
|
|
:param kidnap_white:
|
|
:type kidnap_white: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/dns/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"taskName": task_name,
|
|
"address": address,
|
|
"server": server,
|
|
"resolveType": resolve_type,
|
|
"kidnapWhite": kidnap_white,
|
|
"cycle": cycle,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_dns_task_config(self, user_id=None, task_id=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/dns/detail' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params["taskId"] = task_id
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def get_site_task_config_list(self, user_id=None, query=None, type=None, page_no=None, page_size=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param query:
|
|
:type query: string
|
|
:param type:
|
|
:type type: string
|
|
:param page_no:
|
|
:type page_no: int
|
|
:param page_size:
|
|
:type page_size: int
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/list' % (user_id)
|
|
if query is None:
|
|
query = "NAME:"
|
|
params = {
|
|
b'query': query,
|
|
b'type': type,
|
|
}
|
|
|
|
if page_no is None:
|
|
params[b'pageNo'] = 1
|
|
else:
|
|
params[b'pageNo'] = page_no
|
|
if page_size is None:
|
|
params[b'pageSize'] = 10
|
|
else:
|
|
params[b'pageSize'] = page_size
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def delete_site_task_config(self, user_id=None, task_id=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_Id:
|
|
:type task_Id: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/delete' % (user_id)
|
|
params = {
|
|
b'taskId': task_id,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.DELETE, path, params=params, config=config)
|
|
|
|
def get_site_task_config_info(self, user_id=None, task_id=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_Id:
|
|
:type task_Id: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
task_id = compat.convert_to_bytes(task_id)
|
|
path = b'/userId/%s/site/%s' % (user_id, task_id)
|
|
|
|
return self._send_csm_request(http_methods.GET, path, config=config)
|
|
|
|
def create_site_alarm_config(self, user_id=None, task_id=None, comment=None, alias_name=None,
|
|
level=None, action_enabled=None, resume_actions=None, insufficient_actions=None,
|
|
incident_action=None, insufficient_cycle=None, rules=None, region=None,
|
|
callback_url=None, method=None, site_monitor=None, tag=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param comment:
|
|
:type comment: string
|
|
:param alias_name:
|
|
:type alias_name: string
|
|
:param level:
|
|
:type level: ENUM {'NOTICE', 'WARNING', 'CRITICAL', 'MAJOR', 'CUSTOM'}
|
|
:param action_enabled:
|
|
:type action_enabled: bool
|
|
:param resume_actions:
|
|
:type :type user_id: string: string
|
|
:param insufficient_actions:
|
|
:type insufficient_actions: string
|
|
:param incident_action:
|
|
:type incident_action: string
|
|
:param insufficient_cycle:
|
|
:type insufficient_cycle: int
|
|
:param rules:
|
|
:type rules: list of SiteAlarmRule
|
|
:param region:
|
|
:type region: string
|
|
:param callback_url:
|
|
:type callback_url: string
|
|
:param method:
|
|
:type method: string
|
|
:param site_monitor:
|
|
:type site_monitor: string
|
|
:param tag:
|
|
:type tag: string
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/alarm/config/create' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"comment": comment,
|
|
"aliasName": alias_name,
|
|
"level": level,
|
|
"actionEnabled": action_enabled,
|
|
"resumeActions": resume_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"incidentAction": incident_action,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"rules": rules,
|
|
"region": region,
|
|
"callbackUrl": callback_url,
|
|
"method": method,
|
|
"siteMonitor": site_monitor,
|
|
"tag": tag
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config)
|
|
|
|
def delete_site_alarm_config(self, user_id=None, alarm_names=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_names:
|
|
:type alarm_names: list
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/alarm/config/delete' % (user_id)
|
|
body = {
|
|
"alarmNames": alarm_names
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.DELETE, path, body=json.dumps(body), config=config)
|
|
|
|
def update_site_alarm_config(self, user_id=None, task_id=None, alarm_name=None, comment=None, alias_name=None,
|
|
level=None, action_enabled=None, resume_actions=None, insufficient_actions=None,
|
|
incident_action=None, insufficient_cycle=None, rules=None, region=None,
|
|
callback_url=None, method=None, site_monitor=None, tag=None, config=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param alarm_name:
|
|
:type alarm_name: string
|
|
:param comment:
|
|
:type comment: string
|
|
:param alias_name:
|
|
:type alias_name: string
|
|
:param level:
|
|
:type level: ENUM {'NOTICE', 'WARNING', 'CRITICAL', 'MAJOR', 'CUSTOM'}
|
|
:param action_enabled:
|
|
:type action_enabled: bool
|
|
:param resume_actions:
|
|
:type :type user_id: string: string
|
|
:param insufficient_actions:
|
|
:type insufficient_actions: string
|
|
:param incident_action:
|
|
:type incident_action: string
|
|
:param insufficient_cycle:
|
|
:type insufficient_cycle: int
|
|
:param rules:
|
|
:type rules: list of SiteAlarmRule
|
|
:param region:
|
|
:type region: string
|
|
:param callback_url:
|
|
:type callback_url: string
|
|
:param method:
|
|
:type method: string
|
|
:param site_monitor:
|
|
:type site_monitor: string
|
|
:param tag:
|
|
:type tag: string
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/alarm/config/update' % (user_id)
|
|
body = {
|
|
"userId": user_id,
|
|
"taskId": task_id,
|
|
"alarmName": alarm_name,
|
|
"comment": comment,
|
|
"aliasName": alias_name,
|
|
"level": level,
|
|
"actionEnabled": action_enabled,
|
|
"resumeActions": resume_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"incidentAction": incident_action,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"rules": rules,
|
|
"region": region,
|
|
"callbackUrl": callback_url,
|
|
"method": method,
|
|
"siteMonitor": site_monitor,
|
|
"tag": tag
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config)
|
|
|
|
def get_site_alarm_config_detail(self, user_id=None, alarm_name=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_name:
|
|
:type alarm_name: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/alarm/config/detail' % (user_id)
|
|
params = {
|
|
b'alarmName': alarm_name,
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def get_site_alarm_config_list(self, user_id=None, task_id=None, alarm_name=None,
|
|
action_enabled=None, page_no=None, page_size=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param alarm_name:
|
|
:type alarm_name: string
|
|
:param action_enabled:
|
|
:type action_enabled: bool
|
|
:param page_no:
|
|
:type page_no: int
|
|
:param page_size:
|
|
:type page_size: int
|
|
:param config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/alarm/config/list' % (user_id)
|
|
params = {}
|
|
|
|
if task_id is not None:
|
|
params[b'taskId'] = task_id
|
|
if alarm_name is not None:
|
|
params[b'alarmName'] = alarm_name
|
|
if action_enabled is not None:
|
|
params[b'actionEnabled'] = action_enabled
|
|
|
|
if page_no is None:
|
|
params[b'pageNo'] = 1
|
|
else:
|
|
params[b'pageNo'] = page_no
|
|
if page_size is None:
|
|
params[b'pageSize'] = 10
|
|
else:
|
|
params[b'pageSize'] = page_size
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def block_site_alarm_config(self, user_id=None, alarm_name=None, namespace=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_name:
|
|
:type alarm_name: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/alarm/config/block' % (user_id)
|
|
params = {
|
|
"alarmName": alarm_name,
|
|
"namespace": namespace
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, params=params, config=config)
|
|
|
|
def unblock_site_alarm_config(self, user_id=None, alarm_name=None, namespace=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_name:
|
|
:type alarm_name: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/alarm/config/unblock' % (user_id)
|
|
params = {
|
|
"alarmName": alarm_name,
|
|
"namespace": namespace
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.POST, path, params=params, config=config)
|
|
|
|
def get_site_metric_data(self, user_id=None, task_id=None, metric_name=None, statistics=None,
|
|
start_time=None, end_time=None, cycle=None,
|
|
dimensions=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param metric_name:
|
|
:type metric_name: string
|
|
:param statistics:
|
|
:type statistics: list
|
|
:param start_time:
|
|
:type start_time: string
|
|
:param end_time:
|
|
:type end_time: string
|
|
:param cycle:
|
|
:type cycle: int
|
|
:param dimensions:
|
|
:type dimensions: string
|
|
:param config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/metricSiteData' % (user_id)
|
|
params = {
|
|
"taskId": task_id,
|
|
}
|
|
|
|
if metric_name is not None:
|
|
params[b'metricName'] = metric_name
|
|
if dimensions is not None:
|
|
params[b'dimensions'] = dimensions
|
|
if statistics is not None and len(statistics) > 0:
|
|
params[b'statistics'] = ",".join(statistics)
|
|
if start_time is not None:
|
|
params[b'startTime'] = start_time
|
|
if end_time is not None:
|
|
params[b'endTime'] = end_time
|
|
if cycle is not None:
|
|
params[b'cycle'] = cycle
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params,
|
|
body_parser=bcm_handler.parse_json_list, config=config)
|
|
|
|
def get_site_overall_view(self, user_id=None, task_id=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/idc/overallView' % (user_id)
|
|
params = {
|
|
"taskId": task_id
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params,
|
|
body_parser=bcm_handler.parse_json_list, config=config)
|
|
|
|
def get_site_provincial_view(self, user_id=None, task_id=None, isp=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param isp:
|
|
:type isp: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/idc/provincialView' % (user_id)
|
|
params = {
|
|
"taskId": task_id,
|
|
"isp": isp
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params,
|
|
body_parser=bcm_handler.parse_json_list, config=config)
|
|
|
|
def get_site_agent(self, user_id=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/agent/list' % (user_id)
|
|
|
|
return self._send_csm_request(http_methods.GET, path, body_parser=bcm_handler.parse_json_list, config=config)
|
|
|
|
def get_site_agent_for_task(self, user_id=None, task_id=None, config=None):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param task_id:
|
|
:type task_id: string
|
|
:param config:
|
|
:type config:
|
|
:return:
|
|
"""
|
|
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
path = b'/userId/%s/site/agent/idcIsp' % (user_id)
|
|
params = {
|
|
"taskId": task_id
|
|
}
|
|
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def create_alarm_config(self, user_id, alias_name, scope, level, region, monitor_object, alarm_actions, rules,
|
|
src_type="INSTANCE", ok_actions=None, insufficient_actions=None, config_type="NORMAL",
|
|
insufficient_cycle=0, max_repeat_count=0, repeat_alarm_cycle=0, callback_url="",
|
|
callback_token="", description="", config=None):
|
|
"""
|
|
create alarm config
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alias_name: alarm config alias name
|
|
:type alias_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param level: alarm level
|
|
:type level: string
|
|
|
|
:param region: alarm region
|
|
:type region: string
|
|
|
|
:param monitor_object: monitor object
|
|
:type monitor_object: MonitorObject
|
|
|
|
:param alarm_actions: alarm actions
|
|
:type alarm_actions: string array
|
|
|
|
:param rules: alarm rules
|
|
:type rules: AlarmRule double dimensional array
|
|
|
|
:param src_type: src type
|
|
:type src_type: string
|
|
|
|
:param ok_actions: ok actions
|
|
:type ok_actions: string array
|
|
|
|
:param insufficient_actions: insufficient actions
|
|
:type insufficient_actions: string array
|
|
|
|
:param config_type: alarm config type
|
|
:type config_type: string
|
|
|
|
:param insufficient_cycle: insufficient cycle
|
|
:type insufficient_cycle: int
|
|
|
|
:param max_repeat_count: max repeat count
|
|
:type max_repeat_count: int
|
|
|
|
:param repeat_alarm_cycle: repeat alarm cycle
|
|
:type repeat_alarm_cycle: int
|
|
|
|
:param callback_url: callback url
|
|
:type callback_url: string
|
|
|
|
:param callback_token: callback token
|
|
:type callback_token: string
|
|
|
|
:param description: description
|
|
:type description: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alias_name) <= 0:
|
|
raise ValueError('alias_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
if len(region) <= 0:
|
|
raise ValueError('region should not be none or empty string')
|
|
if len(level) <= 0:
|
|
raise ValueError('level should not be none or empty string')
|
|
if monitor_object is None:
|
|
raise ValueError('monitor_object should not be none')
|
|
if len(alarm_actions) <= 0:
|
|
raise ValueError('alarm_actions should not be empty')
|
|
if len(rules) <= 0:
|
|
raise ValueError('rules should not be empty')
|
|
if insufficient_actions is None:
|
|
insufficient_actions = []
|
|
if ok_actions is None:
|
|
ok_actions = []
|
|
|
|
path = b'/services/alarm/config/create'
|
|
body = {
|
|
"alarmDescription": description,
|
|
"aliasName": alias_name,
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"region": region,
|
|
"level": level,
|
|
"monitorObject": monitor_object,
|
|
"alarmActions": alarm_actions,
|
|
"okActions": ok_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"srcType": src_type,
|
|
"type": config_type,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"maxRepeatCount": max_repeat_count,
|
|
"repeatAlarmCycle": repeat_alarm_cycle,
|
|
"callbackUrl": callback_url,
|
|
"callbackToken": callback_token,
|
|
"rules": rules,
|
|
}
|
|
self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def update_alarm_config(self, user_id, alarm_name, alias_name, scope, level, region,
|
|
monitor_object, alarm_actions, rules,
|
|
src_type="INSTANCE", ok_actions=None, insufficient_actions=None, config_type="NORMAL",
|
|
insufficient_cycle=0, max_repeat_count=0, repeat_alarm_cycle=0, callback_url="",
|
|
callback_token="", description="", config=None):
|
|
"""
|
|
update alarm config
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param alias_name: alarm config alias name
|
|
:type alias_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param level: alarm level
|
|
:type level: string
|
|
|
|
:param region: alarm region
|
|
:type region: string
|
|
|
|
:param monitor_object: monitor object
|
|
:type monitor_object: MonitorObject
|
|
|
|
:param alarm_actions: alarm actions
|
|
:type alarm_actions: string array
|
|
|
|
:param rules: alarm rules
|
|
:type rules: AlarmRule double dimensional array
|
|
|
|
:param src_type: src type
|
|
:type src_type: string
|
|
|
|
:param ok_actions: ok actions
|
|
:type ok_actions: string array
|
|
|
|
:param insufficient_actions: insufficient actions
|
|
:type insufficient_actions: string array
|
|
|
|
:param config_type: alarm config type
|
|
:type config_type: string
|
|
|
|
:param insufficient_cycle: insufficient cycle
|
|
:type insufficient_cycle: int
|
|
|
|
:param max_repeat_count: max repeat count
|
|
:type max_repeat_count: int
|
|
|
|
:param repeat_alarm_cycle: repeat alarm cycle
|
|
:type repeat_alarm_cycle: int
|
|
|
|
:param callback_url: callback url
|
|
:type callback_url: string
|
|
|
|
:param callback_token: callback token
|
|
:type callback_token: string
|
|
|
|
:param description: description
|
|
:type description: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alias_name) <= 0:
|
|
raise ValueError('alias_name should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
if len(region) <= 0:
|
|
raise ValueError('region should not be none or empty string')
|
|
if len(level) <= 0:
|
|
raise ValueError('level should not be none or empty string')
|
|
if monitor_object is None:
|
|
raise ValueError('monitor_object should not be none')
|
|
if len(alarm_actions) <= 0:
|
|
raise ValueError('alarm_actions should not be empty')
|
|
if len(rules) <= 0:
|
|
raise ValueError('rules should not be empty')
|
|
if insufficient_actions is None:
|
|
insufficient_actions = []
|
|
if ok_actions is None:
|
|
ok_actions = []
|
|
|
|
path = b'/services/alarm/config/update'
|
|
body = {
|
|
"alarmDescription": description,
|
|
"alarmName": alarm_name,
|
|
"aliasName": alias_name,
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"region": region,
|
|
"level": level,
|
|
"monitorObject": monitor_object,
|
|
"alarmActions": alarm_actions,
|
|
"okActions": ok_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"srcType": src_type,
|
|
"type": config_type,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"maxRepeatCount": max_repeat_count,
|
|
"repeatAlarmCycle": repeat_alarm_cycle,
|
|
"callbackUrl": callback_url,
|
|
"callbackToken": callback_token,
|
|
"rules": rules,
|
|
}
|
|
self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def delete_alarm_config(self, user_id, alarm_name, scope, config=None):
|
|
"""
|
|
delete alarm config
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/services/alarm/config/delete'
|
|
params = {
|
|
b"alarmName": alarm_name,
|
|
b"userId": user_id,
|
|
b"scope": scope,
|
|
}
|
|
self._send_csm_request(http_methods.POST, path, params=params, config=config)
|
|
|
|
def block_alarm_config(self, user_id, alarm_name, scope, config=None):
|
|
"""
|
|
block alarm config
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/services/alarm/config/block'
|
|
params = {
|
|
b"alarmName": alarm_name,
|
|
b"userId": user_id,
|
|
b"scope": scope,
|
|
}
|
|
self._send_csm_request(http_methods.POST, path, params=params, config=config)
|
|
|
|
def unblock_alarm_config(self, user_id, alarm_name, scope, config=None):
|
|
"""
|
|
unblock alarm config
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/services/alarm/config/unblock'
|
|
params = {
|
|
b"alarmName": alarm_name,
|
|
b"userId": user_id,
|
|
b"scope": scope,
|
|
}
|
|
self._send_csm_request(http_methods.POST, path, params=params, config=config)
|
|
|
|
def get_alarm_config_detail(self, user_id, alarm_name, scope, config=None):
|
|
"""
|
|
get alarm config detail
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/services/alarm/config'
|
|
params = {
|
|
b"alarmName": alarm_name,
|
|
b"userId": user_id,
|
|
b"scope": scope,
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def get_single_instance_alarm_configs(self, user_id, scope, page_no, page_size,
|
|
region="bj", alarm_name_prefix="", action_enabled=None, dimensions="",
|
|
order="desc", config=None):
|
|
"""
|
|
get alarm config detail
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param region: region
|
|
:type region: string
|
|
|
|
:param page_no: page no
|
|
:type page_no: int
|
|
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
|
|
:param alarm_name_prefix: alarm name prefix
|
|
:type alarm_name_prefix: string
|
|
|
|
:param action_enabled: action enable flag
|
|
:type action_enabled: bool
|
|
|
|
:param dimensions: dimensions
|
|
:type dimensions: string
|
|
|
|
:param order: order
|
|
:type order: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
if page_no <= 0:
|
|
raise ValueError('page_no should be greater than 0')
|
|
if page_size <= 0:
|
|
raise ValueError('page_size should be greater than 0')
|
|
|
|
path = b'/services/alarm/config/list'
|
|
params = {
|
|
b"region": region,
|
|
b"userId": user_id,
|
|
b"scope": scope,
|
|
b"pageNo": page_no,
|
|
b"pageSize": page_size,
|
|
b"dimensions": dimensions,
|
|
b"order": order,
|
|
b"alarmNamePrefix": alarm_name_prefix,
|
|
}
|
|
if action_enabled is not None:
|
|
if action_enabled:
|
|
params["actionEnabled"] = "true"
|
|
else:
|
|
params["actionEnabled"] = "false"
|
|
return self._send_csm_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
def get_alarm_metrics(self, user_id, scope, region="bj", dimensions="", metric_type="", locale="", config=None):
|
|
"""
|
|
get alarm config detail
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/Vks8iqqnx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param region: region
|
|
:type region: string
|
|
|
|
:param dimensions: dimensions
|
|
:type dimensions: string
|
|
|
|
:param metric_type: metric type
|
|
:type metric_type: string
|
|
|
|
:param locale: locale
|
|
:type locale: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/services/alarm/config/metrics'
|
|
params = {
|
|
b"region": region,
|
|
b"userId": user_id,
|
|
b"scope": scope,
|
|
b"dimensions": dimensions,
|
|
b"type": metric_type,
|
|
b"locale": locale,
|
|
}
|
|
return self._send_csm_request(http_methods.GET, path, params=params,
|
|
body_parser=bcm_handler.parse_json_list, config=config)
|
|
|
|
def create_alarm_config_v2(self, user_id, alias_name, scope, target_type, level, region, actions, policies,
|
|
target_instances=None, insufficient_period=0,
|
|
alarm_repeat_interval=0, alarm_repeat_count=0,
|
|
callback_url="", callback_token="", target_instance_tags=None,
|
|
target_instance_groups=None, resource_type="Instance", config=None):
|
|
"""
|
|
get alarm config detail
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/blhrp7kdx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alias_name: alarm config alias name
|
|
:type alias_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param target_type: alarm config target type
|
|
:type target_type: string
|
|
|
|
:param level: alarm level
|
|
:type level: string
|
|
|
|
:param region: alarm config region
|
|
:type region: string
|
|
|
|
:param actions: alarm actions
|
|
:type actions: AlarmAction array
|
|
|
|
:param policies: alarm config policies
|
|
:type policies: AlarmConfigPolicy array
|
|
|
|
:param target_instances: alarm config target instances
|
|
:type target_instances: TargetInstance array
|
|
|
|
:param insufficient_period: insufficient data pending period
|
|
:type insufficient_period: int
|
|
|
|
:param alarm_repeat_interval: alarm repeat interval
|
|
:type alarm_repeat_interval: int
|
|
|
|
:param alarm_repeat_count: alarm repeat count
|
|
:type alarm_repeat_count: int
|
|
|
|
:param callback_url: callback url
|
|
:type callback_url: string
|
|
|
|
:param callback_token: callback token
|
|
:type callback_token: string
|
|
|
|
:param target_instance_tags: target instance tags
|
|
:type target_instance_tags: KV array
|
|
|
|
:param target_instance_groups: target instance groups
|
|
:type target_instance_groups: string array
|
|
|
|
:param resource_type: resource type
|
|
:type resource_type: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
if len(alias_name) <= 0:
|
|
raise ValueError('alias_name should not be none or empty string')
|
|
if len(target_type) <= 0:
|
|
raise ValueError('target_type should not be none or empty string')
|
|
if len(level) <= 0:
|
|
raise ValueError('level should not be none or empty string')
|
|
if len(region) <= 0:
|
|
raise ValueError('region should not be none or empty string')
|
|
if len(actions) <= 0:
|
|
raise ValueError('actions should not be empty')
|
|
if len(policies) <= 0:
|
|
raise ValueError('policies should not be empty')
|
|
if target_type == "TARGET_TYPE_MULTI_INSTANCES" and len(target_instances) <= 0:
|
|
raise ValueError('target_instances should not be empty')
|
|
if target_type == "TARGET_TYPE_INSTANCE_GROUP" and len(target_instance_groups) <= 0:
|
|
raise ValueError('target_instance_groups should not be empty')
|
|
if target_type == "TARGET_TYPE_INSTANCE_TAGS" and len(target_instance_tags) <= 0:
|
|
raise ValueError('target_instance_tags should not be empty')
|
|
if target_instance_groups is None:
|
|
target_instance_groups = []
|
|
if target_instance_tags is None:
|
|
target_instance_tags = []
|
|
if target_instances is None:
|
|
target_instances = []
|
|
|
|
path = b'/userId/%s/services/%s/alarm/config/create' % (user_id, scope)
|
|
body = {
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"aliasName": alias_name,
|
|
"targetType": target_type,
|
|
"resourceType": resource_type,
|
|
"alarmLevel": level,
|
|
"targetInstanceGroups": target_instance_groups,
|
|
"targetInstanceTags": target_instance_tags,
|
|
"callbackUrl": callback_url,
|
|
"callbackToken": callback_token,
|
|
"insufficientDataPendingPeriod": insufficient_period,
|
|
"alarmRepeatInterval": alarm_repeat_interval,
|
|
"alarmRepeatCount": alarm_repeat_count,
|
|
"policies": policies,
|
|
"targetInstances": target_instances,
|
|
"actions": actions,
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body), config=config,
|
|
version=BcmClient.version_v2)
|
|
|
|
def update_alarm_config_v2(self, user_id, alarm_name, alias_name, scope, target_type, level, region,
|
|
actions, policies, target_instances=None, insufficient_period=0,
|
|
alarm_repeat_interval=0, alarm_repeat_count=0,
|
|
callback_url="", callback_token="", target_instance_tags=None,
|
|
target_instance_groups=None, resource_type="Instance", config=None):
|
|
"""
|
|
get alarm config detail
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/blhrp7kdx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param alias_name: alarm config alias name
|
|
:type alias_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param target_type: alarm config target type
|
|
:type target_type: string
|
|
|
|
:param level: alarm level
|
|
:type level: string
|
|
|
|
:param region: alarm config region
|
|
:type region: string
|
|
|
|
:param actions: alarm actions
|
|
:type actions: AlarmAction array
|
|
|
|
:param policies: alarm config policies
|
|
:type policies: AlarmConfigPolicy array
|
|
|
|
:param target_instances: alarm config target instances
|
|
:type target_instances: TargetInstance array
|
|
|
|
:param insufficient_period: insufficient data pending period
|
|
:type insufficient_period: int
|
|
|
|
:param alarm_repeat_interval: alarm repeat interval
|
|
:type alarm_repeat_interval: int
|
|
|
|
:param alarm_repeat_count: alarm repeat count
|
|
:type alarm_repeat_count: int
|
|
|
|
:param callback_url: callback url
|
|
:type callback_url: string
|
|
|
|
:param callback_token: callback token
|
|
:type callback_token: string
|
|
|
|
:param target_instance_tags: target instance tags
|
|
:type target_instance_tags: KV array
|
|
|
|
:param target_instance_groups: target instance groups
|
|
:type target_instance_groups: string array
|
|
|
|
:param resource_type: resource type
|
|
:type resource_type: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(alias_name) <= 0:
|
|
raise ValueError('alias_name should not be none or empty string')
|
|
if len(target_type) <= 0:
|
|
raise ValueError('target_type should not be none or empty string')
|
|
if len(level) <= 0:
|
|
raise ValueError('level should not be none or empty string')
|
|
if len(region) <= 0:
|
|
raise ValueError('region should not be none or empty string')
|
|
if len(actions) <= 0:
|
|
raise ValueError('actions should not be empty')
|
|
if len(policies) <= 0:
|
|
raise ValueError('policies should not be empty')
|
|
if target_type == "TARGET_TYPE_MULTI_INSTANCES" and len(target_instances) <= 0:
|
|
raise ValueError('target_instances should not be empty')
|
|
if target_type == "TARGET_TYPE_INSTANCE_GROUP" and len(target_instance_groups) <= 0:
|
|
raise ValueError('target_instance_groups should not be empty')
|
|
if target_type == "TARGET_TYPE_INSTANCE_TAGS" and len(target_instance_tags) <= 0:
|
|
raise ValueError('target_instance_tags should not be empty')
|
|
if target_instance_tags is None:
|
|
target_instance_tags = []
|
|
if target_instance_groups is None:
|
|
target_instance_groups = []
|
|
if target_instances is None:
|
|
target_instances = []
|
|
|
|
path = b'/userId/%s/services/%s/alarm/config/update' % (user_id, scope)
|
|
body = {
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"aliasName": alias_name,
|
|
"alarmName": alarm_name,
|
|
"targetType": target_type,
|
|
"resourceType": resource_type,
|
|
"alarmLevel": level,
|
|
"targetInstanceGroups": target_instance_groups,
|
|
"targetInstanceTags": target_instance_tags,
|
|
"callbackUrl": callback_url,
|
|
"callbackToken": callback_token,
|
|
"insufficientDataPendingPeriod": insufficient_period,
|
|
"alarmRepeatInterval": alarm_repeat_interval,
|
|
"alarmRepeatCount": alarm_repeat_count,
|
|
"policies": policies,
|
|
"targetInstances": target_instances,
|
|
"actions": actions,
|
|
}
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body), config=config,
|
|
version=BcmClient.version_v2)
|
|
|
|
def block_alarm_config_v2(self, user_id, alarm_name, scope, config=None):
|
|
"""
|
|
block alarm config v2
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/blhrp7kdx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/userId/%s/services/%s/alarm/config/block' % (user_id, scope)
|
|
params = {
|
|
b"alarmName": alarm_name
|
|
}
|
|
self._send_csm_request(http_methods.POST, path, params=params, config=config,
|
|
version=BcmClient.version_v2)
|
|
|
|
def unblock_alarm_config_v2(self, user_id, alarm_name, scope, config=None):
|
|
"""
|
|
unblock alarm config v2
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/blhrp7kdx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/userId/%s/services/%s/alarm/config/unblock' % (user_id, scope)
|
|
params = {
|
|
b"alarmName": alarm_name
|
|
}
|
|
self._send_csm_request(http_methods.POST, path, params=params, config=config,
|
|
version=BcmClient.version_v2)
|
|
|
|
def get_alarm_config_detail_v2(self, user_id, alarm_name, scope, config=None):
|
|
"""
|
|
get alarm config detail v2
|
|
|
|
This site may help you: https://cloud.baidu.com/doc/BCM/s/blhrp7kdx
|
|
|
|
:param user_id: master account id
|
|
:type user_id: string
|
|
|
|
:param alarm_name: alarm config name
|
|
:type alarm_name: string
|
|
|
|
:param scope: scope
|
|
:type scope: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError('user_id should not be none or empty string')
|
|
if len(alarm_name) <= 0:
|
|
raise ValueError('alarm_name should not be none or empty string')
|
|
if len(scope) <= 0:
|
|
raise ValueError('scope should not be none or empty string')
|
|
|
|
path = b'/userId/%s/services/%s/alarm/config' % (user_id, scope)
|
|
params = {
|
|
b"alarmName": alarm_name
|
|
}
|
|
self._send_csm_request(http_methods.GET, path, params=params, config=config, version=BcmClient.version_v2)
|
|
|
|
@required(rules=list, insufficientActions=int, repeatAlarmCycle=int, maxRepeatCount=int)
|
|
def create_custom_alarm_policy(self, user_id, alarm_name, namespace, level, comment="",
|
|
action_enabled=True, policy_enabled=None, alarm_actions=None, ok_actions=None,
|
|
insufficient_actions=None, insufficient_cycle=None, rules=None, region=None,
|
|
callback_url=None, callback_token=None, tag="", repeat_alarm_cycle=0,
|
|
max_repeat_count=0):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_name: alarm name
|
|
:type alarm_name: string
|
|
:param namespace: custom namespace
|
|
:type namespace: string
|
|
:param level: level
|
|
:type level: string enum: NOTICE, NOTICE, CRITICAL, MAJOR
|
|
:param comment: comment
|
|
:type comment: string
|
|
:param action_enabled: is action enabled
|
|
:type action_enabled: bool
|
|
:param policy_enabled: is policy enabled
|
|
:type policy_enabled: bool
|
|
:param alarm_actions: alarm actions
|
|
:type alarm_actions: list
|
|
:param ok_actions: ok actions
|
|
:type ok_actions: list of string
|
|
:param insufficient_actions: insufficient actions
|
|
:type insufficient_actions: list of string
|
|
:param insufficient_cycle: insufficient cycle
|
|
:type insufficient_cycle: int
|
|
:param rules: rules
|
|
:type rules: list of CustomAlarmRule
|
|
:param region: region
|
|
:type region: string
|
|
:param callback_url: callback url
|
|
:type callback_url: string
|
|
:param callback_token: callback token
|
|
:type callback_token: string
|
|
:param tag: tag
|
|
:type tag: string
|
|
:param repeat_alarm_cycle: repeat alarm cycle
|
|
:type repeat_alarm_cycle: int
|
|
:param max_repeat_count: max repeat count
|
|
:type max_repeat_count: int
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/custom/alarm/configs/create'
|
|
body = {
|
|
"userId": user_id,
|
|
"alarmName": alarm_name,
|
|
"namespace": namespace,
|
|
"level": level,
|
|
"comment": comment,
|
|
"actionEnabled": action_enabled,
|
|
"policyEnabled": policy_enabled,
|
|
"alarmActions": alarm_actions,
|
|
"okActions": ok_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"rules": rules,
|
|
"region": region,
|
|
"callbackUrl": callback_url,
|
|
"callbackToken": callback_token,
|
|
"repeatAlarmCycle": repeat_alarm_cycle,
|
|
"maxRepeatCount": max_repeat_count,
|
|
"tag": tag
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(custom_alarm_list=list)
|
|
def delete_custom_alarm_policy(self, custom_alarm_list):
|
|
"""
|
|
:param custom_alarm_list:
|
|
:type custom_alarm_list: list of custom alarm
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = (b'/custom/alarm/configs/delete')
|
|
body = {
|
|
"customAlarmList": [
|
|
]
|
|
}
|
|
for custom_alarm in custom_alarm_list:
|
|
body["customAlarmList"].append({
|
|
"scope": custom_alarm["scope"],
|
|
"userId": custom_alarm["userId"],
|
|
"alarmName": custom_alarm["alarmName"]
|
|
})
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
@required(rules=list, insufficientActions=int, repeatAlarmCycle=int, maxRepeatCount=int)
|
|
def update_custom_alarm_policy(self, user_id, alarm_name, namespace, level, comment="",
|
|
action_enabled=True, policy_enabled=None, alarm_actions=None, ok_actions=None,
|
|
insufficient_actions=None, insufficient_cycle=None, rules=None, region=None,
|
|
callback_url=None, callback_token=None, tag="", repeat_alarm_cycle=0,
|
|
max_repeat_count=0):
|
|
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param alarm_name: alarm name
|
|
:type alarm_name: string
|
|
:param namespace: custom namespace
|
|
:type namespace: string
|
|
:param level: level
|
|
:type level: string enum: NOTICE, NOTICE, CRITICAL, MAJOR
|
|
:param comment: comment
|
|
:type comment: string
|
|
:param action_enabled: is action enabled
|
|
:type action_enabled: bool
|
|
:param policy_enabled: is policy enabled
|
|
:type policy_enabled: bool
|
|
:param alarm_actions: alarm actions
|
|
:type alarm_actions: list
|
|
:param ok_actions: ok actions
|
|
:type ok_actions: list of string
|
|
:param insufficient_actions: insufficient actions
|
|
:type insufficient_actions: list of string
|
|
:param insufficient_cycle: insufficient cycle
|
|
:type insufficient_cycle: int
|
|
:param rules: rules
|
|
:type rules: list of CustomAlarmRule
|
|
:param region: region
|
|
:type region: string
|
|
:param callback_url: callback url
|
|
:type callback_url: string
|
|
:param callback_token: callback token
|
|
:type callback_token: string
|
|
:param tag: tag
|
|
:type tag: string
|
|
:param repeat_alarm_cycle: repeat alarm cycle
|
|
:type repeat_alarm_cycle: int
|
|
:param max_repeat_count: max repeat count
|
|
:type max_repeat_count: int
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
if alarm_actions is None:
|
|
alarm_actions = []
|
|
if ok_actions is None:
|
|
alarm_actions = []
|
|
if insufficient_actions is None:
|
|
insufficient_actions = []
|
|
|
|
path = b'/custom/alarm/configs/update'
|
|
body = {
|
|
"userId": user_id,
|
|
"alarmName": alarm_name,
|
|
"namespace": namespace,
|
|
"level": level,
|
|
"comment": comment,
|
|
"actionEnabled": action_enabled,
|
|
"policyEnabled": policy_enabled,
|
|
"alarmActions": alarm_actions,
|
|
"okActions": ok_actions,
|
|
"insufficientActions": insufficient_actions,
|
|
"insufficientCycle": insufficient_cycle,
|
|
"rules": rules,
|
|
"region": region,
|
|
"callbackUrl": callback_url,
|
|
"callbackToken": callback_token,
|
|
"repeatAlarmCycle": repeat_alarm_cycle,
|
|
"maxRepeatCount": max_repeat_count,
|
|
"tag": tag
|
|
}
|
|
return self._send_csm_request(http_methods.PUT, path, body=json.dumps(body))
|
|
|
|
def list_custom_policy(self, user_id, page_no, page_size, alarm_name=None, namespace=None, action_enabled=None):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param page_no: page number
|
|
:type page_no: int
|
|
:param page_size: page size
|
|
:type page_size: int
|
|
:param alarm_name: alarm name
|
|
:type alarm_name: string
|
|
:param namespace: namespace
|
|
:type namespace: string
|
|
:param action_enabled: is action enabled
|
|
:type action_enabled: bool
|
|
|
|
:return
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {
|
|
b'pageNo': page_no,
|
|
b'pageSize': page_size,
|
|
b'userId': user_id,
|
|
b'alarmName': alarm_name,
|
|
b'actionEnabled': action_enabled,
|
|
b'namespace': namespace
|
|
}
|
|
path = b'/custom/alarm/configs/list'
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
def detail_custom_policy(self, user_id, namespace, alarm_name):
|
|
"""
|
|
:param user_id:
|
|
:type user_id: string
|
|
:param namespace: namespace
|
|
:type namespace: string
|
|
:param alarm_name: alarm name
|
|
:type alarm_name: string
|
|
|
|
:return: Returns detailed information about a custom policy.
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {
|
|
b'userId': user_id,
|
|
b'alarmName': alarm_name,
|
|
b'namespace': namespace
|
|
}
|
|
path = b'/custom/alarm/configs/detail'
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
def block_custom_policy(self, user_id, namespace, alarm_name):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: string
|
|
:param namespace: Namespace
|
|
:type namespace: string
|
|
:param alarm_name: Alarm name
|
|
:type alarm_name: string
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {
|
|
b'userId': user_id,
|
|
b'alarmName': alarm_name,
|
|
b'namespace': namespace
|
|
}
|
|
path = b'/custom/alarm/configs/block'
|
|
return self._send_csm_request(http_methods.POST, path, params=params)
|
|
|
|
def unblock_custom_policy(self, user_id, namespace, alarm_name):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param namespace: Namespace
|
|
:type namespace: str
|
|
:param alarm_name: Alarm name
|
|
:type alarm_name: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
params = {
|
|
b'userId': user_id,
|
|
b'alarmName': alarm_name,
|
|
b'namespace': namespace
|
|
}
|
|
path = b'/custom/alarm/configs/unblock'
|
|
return self._send_csm_request(http_methods.POST, path, params=params)
|
|
|
|
def create_site_once_task(self, site_once_type, user_id, address, idc, timeout, protocol_type, once_config,
|
|
task_type="NET_QUAILTY", ip_type="ipv4", advanced_flag=False,
|
|
advanced_config=None, group_id=None):
|
|
"""
|
|
:param site_once_type: Type of site
|
|
:type site_once_type: str
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param address: Address
|
|
:type address: str
|
|
:param idc: IDC
|
|
:type idc: str
|
|
:param timeout: Timeout
|
|
:type timeout: int
|
|
:param protocol_type: Protocol type
|
|
:type protocol_type: str
|
|
:param once_config: Configuration for once
|
|
:type once_config: dict
|
|
:param task_type: Task type
|
|
:type task_type: str
|
|
:param ip_type: IP type
|
|
:type ip_type: str
|
|
:param advanced_flag: Advanced flag
|
|
:type advanced_flag: bool
|
|
:param advanced_config: Advanced configuration
|
|
:type advanced_config: dict
|
|
:param group_id: Group identifier
|
|
:type group_id: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
types = ["HTTP", "HTTPS", "PING", "FTP", "TCP", "UDP", "DNS"]
|
|
if site_once_type is not None and site_once_type not in types:
|
|
raise ValueError('site_once_type must be none or one of %s' % str(types))
|
|
path = (b'/site/once/%s/taskCreate' % compat.convert_to_bytes(site_once_type))
|
|
if advanced_config is None:
|
|
advanced_config = {}
|
|
body = {
|
|
"userId": user_id,
|
|
"address": address,
|
|
"idc": idc,
|
|
"timeout": timeout,
|
|
"protocolType": protocol_type,
|
|
"onceConfig": once_config,
|
|
"taskType": task_type,
|
|
"ipType": ip_type,
|
|
"advancedFlag": advanced_flag,
|
|
"advancedConfig": advanced_config,
|
|
"groupId": group_id
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def list_site_once_records(self, user_id=None, url=None, page_no=1, page_size=10,
|
|
order=None, order_by=None, group_id=None):
|
|
"""
|
|
:param user_id: User's identifier, defaults to None
|
|
:type user_id: str
|
|
:param url: URL
|
|
:type url: str
|
|
:param page_no: Page number
|
|
:type page_no: int
|
|
:param page_size: Page size
|
|
:type page_size: int
|
|
:param order: Order
|
|
:type order: str
|
|
:param order_by: Order by
|
|
:type order_by: str
|
|
:param group_id: Group identifier
|
|
:type group_id: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/site/once/taskList'
|
|
body = {
|
|
"userId": user_id,
|
|
"url": url,
|
|
"pageNo": page_no,
|
|
"pageSize": page_size,
|
|
"order": order,
|
|
"orderBy": order_by,
|
|
"groupId": group_id
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def delete_site_once_record(self, user_id, site_id):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param site_id: Site identifier
|
|
:type site_id: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/site/once/taskDelete'
|
|
body = {
|
|
"userId": user_id,
|
|
"siteId": site_id,
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def detail_site_once_result(self, user_id, site_id, page_no=1, page_size=10, order=None, order_by=None,
|
|
filter_area=None, filter_isp=None):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param site_id: Site identifier
|
|
:type site_id: str
|
|
:param page_no: Page number
|
|
:type page_no: int
|
|
:param page_size: Page size
|
|
:type page_size: int
|
|
:param order: Order
|
|
:type order: str
|
|
:param order_by: Order by
|
|
:type order_by: str
|
|
:param filter_area: Filter area
|
|
:type filter_area: str
|
|
:param filter_isp: Filter ISP
|
|
:type filter_isp: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/site/once/loadData'
|
|
body = {
|
|
"userId": user_id,
|
|
"siteId": site_id,
|
|
"pageNo": page_no,
|
|
"pageSize": page_size,
|
|
"order": order,
|
|
"orderBy": order_by,
|
|
"filterArea": filter_area,
|
|
"filterIsp": filter_isp
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def detail_site_once(self, user_id, site_id=None, site_ids=None, group_id=None, page_no=1, page_size=10,
|
|
order=None, order_by=None, filter_area=None, filter_isp=None):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param site_id: Site identifier
|
|
:type site_id: str
|
|
:param site_ids: List of site identifiers
|
|
:type site_ids: list
|
|
:param group_id: Group identifier
|
|
:type group_id: str
|
|
:param page_no: Page number
|
|
:type page_no: int
|
|
:param page_size: Page size
|
|
:type page_size: int
|
|
:param order: Order
|
|
:type order: str
|
|
:param order_by: Order by
|
|
:type order_by: str
|
|
:param filter_area: Filter area
|
|
:type filter_area: str
|
|
:param filter_isp: Filter ISP
|
|
:type filter_isp: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/site/once/groupTask'
|
|
body = {
|
|
"userId": user_id,
|
|
"siteId": site_id,
|
|
"siteIds": site_ids,
|
|
"groupId": group_id,
|
|
"pageNo": page_no,
|
|
"pageSize": page_size,
|
|
"order": order,
|
|
"orderBy": order_by,
|
|
"filterArea": filter_area,
|
|
"filterIsp": filter_isp
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def again_exec_site_once(self, user_id, site_id):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param site_id: Site identifier
|
|
:type site_id: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/site/once/createFromTask'
|
|
body = {
|
|
"userId": user_id,
|
|
"siteId": site_id
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def list_site_once_history(self, user_id="", site_id="", group_id=""):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param site_id: Site identifier
|
|
:type site_id: str
|
|
:param group_id: group identifier
|
|
:type group_id: str
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/site/once/groupTaskList'
|
|
body = {
|
|
"userId": user_id,
|
|
"groupId": group_id,
|
|
"siteId": site_id
|
|
}
|
|
return self._send_csm_request(http_methods.POST, path, body=json.dumps(body))
|
|
|
|
def get_site_once_agent(self, user_id, ip_type="ipv4"):
|
|
"""
|
|
:param user_id: User's identifier
|
|
:type user_id: str
|
|
:param ip_type: the type of ip, enum: ipv4, ipv6
|
|
:type ip_type: str
|
|
|
|
:return:
|
|
:rtype: baidubce.bce_response.BceResponse
|
|
"""
|
|
types = ["ipv4", "ipv6"]
|
|
if ip_type is not None and ip_type not in types:
|
|
raise ValueError('ip_type must be none or one of %s' % str(types))
|
|
params = {
|
|
b'userId': user_id,
|
|
b'ipType': ip_type,
|
|
}
|
|
path = b'/site/once/siteAgent'
|
|
return self._send_csm_request(http_methods.GET, path, params=params)
|
|
|
|
@required(user_id=str, scope=str, region=str, resource_type=str, dimensions=list,
|
|
metric_names=list, timestamp=str, statistics=list, cycle=int)
|
|
def get_multi_dimension_latest_metrics(self, user_id, scope, region=None, resource_type=None, dimensions=None,
|
|
metric_names=None, timestamp=None, statistics=None, cycle=None):
|
|
"""
|
|
:param user_id: str
|
|
:param scope: str
|
|
:param region: str
|
|
:param resource_type: str
|
|
:param dimensions: list
|
|
:param metric_names: list
|
|
:param timestamp: str
|
|
:param statistics: list
|
|
:param cycle: int
|
|
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(scope) <= 0:
|
|
raise ValueError("scope should not be null")
|
|
if metric_names is None:
|
|
raise ValueError("metric_names should not be null")
|
|
if len(dimensions) > MAX_INSTANCE_NUMBER:
|
|
raise ValueError("dimensions size cannot more than " + MAX_INSTANCE_NUMBER)
|
|
if cycle is None:
|
|
cycle = 60
|
|
body = {
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"cycle": cycle
|
|
}
|
|
metric_names_req = []
|
|
for res in metric_names:
|
|
metric_names_req.append(res)
|
|
body["metricNames"] = metric_names_req
|
|
if region is not None:
|
|
body["region"] = region
|
|
if resource_type is not None:
|
|
body["resourceType"] = resource_type
|
|
if dimensions is not None:
|
|
dimensions_res = []
|
|
for res in dimensions:
|
|
dimensions_res.append(res)
|
|
body["dimensions"] = dimensions_res
|
|
if timestamp is not None:
|
|
body["timestamp"] = timestamp
|
|
if statistics is not None:
|
|
body["statistics"] = statistics
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
scope = compat.convert_to_bytes(scope)
|
|
path = b'/userId/%s/services/%s/data/metricData/latest/batch' % (user_id, scope)
|
|
return self._send_csm_request(http_methods.POST, path, version=b'/v2', body=json.dumps(body))
|
|
|
|
|
|
def get_metrics_by_partial_dimensions(self, user_id, scope, statistics, metric_name, start_time, end_time,
|
|
region=None, resource_type=None, dimensions=None, cycle=None,
|
|
pageNo=None, pageSize=None):
|
|
"""
|
|
:param user_id: str
|
|
:param scope: str
|
|
:param statistics: list
|
|
:param metric_name: str
|
|
:param start_time: str
|
|
:param end_time: str
|
|
:param region: str
|
|
:param resource_type: str
|
|
:param dimensions: list
|
|
:param cycle: int
|
|
:param pageNo: int
|
|
:param pageSize: int
|
|
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(scope) <= 0:
|
|
raise ValueError("scope should not be null")
|
|
if len(metric_name) <= 0:
|
|
raise ValueError("metric_name should not be null")
|
|
if len(start_time) <= 0:
|
|
raise ValueError("start_time should not be null")
|
|
if len(end_time) <= 0:
|
|
raise ValueError("end_time should not be null")
|
|
if len(statistics) <= 0:
|
|
raise ValueError("statistics should not be null")
|
|
if len(dimensions) > MAX_INSTANCE_NUMBER:
|
|
raise ValueError("dimensions size cannot more than " + MAX_INSTANCE_NUMBER)
|
|
body = {
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"startTime": start_time,
|
|
"endTime": end_time,
|
|
"statistics": statistics,
|
|
"metricName": metric_name
|
|
}
|
|
if region is not None:
|
|
body["region"] = region
|
|
if resource_type is not None:
|
|
body["resourceType"] = resource_type
|
|
if dimensions is not None:
|
|
dimensions_res = []
|
|
for res in dimensions:
|
|
dimensions_res.append(res)
|
|
body["dimensions"] = dimensions_res
|
|
if cycle is not None:
|
|
body["cycle"] = cycle
|
|
if pageNo is not None:
|
|
body["pageNo"] = pageNo
|
|
if pageSize is not None:
|
|
body["pageSize"] = pageSize
|
|
user_id = compat.convert_to_bytes(user_id)
|
|
scope = compat.convert_to_bytes(scope)
|
|
path = b'/userId/%s/services/%s/data/metricData/PartialDimension' % (user_id, scope)
|
|
return self._send_csm_request(http_methods.POST, path, version=b'/v2', body=json.dumps(body))
|
|
|
|
def get_all_data_metrics_v2(self, user_id, scope, region, dimensions, metric_names, statistics,
|
|
start_time, end_time, type="Instance", cycle=60):
|
|
|
|
"""
|
|
:param user_id: user_id
|
|
:type string
|
|
|
|
:param scope: scope
|
|
:type string
|
|
|
|
:param region: region
|
|
:type string
|
|
|
|
:param type: resource type
|
|
:type string
|
|
|
|
:param dimensions: dimensions
|
|
:type double string array
|
|
|
|
:param metric_names: metric names
|
|
:type string array
|
|
|
|
:param statistics: statistics
|
|
:type string array
|
|
|
|
:param cycle: cycle
|
|
:type int
|
|
|
|
:param start_time: start time
|
|
:type string
|
|
|
|
:param end_time: end time
|
|
:type string
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(scope) <= 0:
|
|
raise ValueError("scope should not be null")
|
|
if len(region) <= 0:
|
|
raise ValueError("region should not be null")
|
|
if metric_names is None:
|
|
raise ValueError("metric_names should not be null")
|
|
if dimensions is None:
|
|
raise ValueError("dimensions should not be null")
|
|
if statistics is None:
|
|
raise ValueError("statistics should not be null")
|
|
if len(dimensions) > MAX_INSTANCE_NUMBER:
|
|
raise ValueError("dimensions size cannot more than " + MAX_INSTANCE_NUMBER)
|
|
body = {
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"cycle": cycle,
|
|
"region": region,
|
|
"startTime": start_time,
|
|
"endTime": end_time,
|
|
"metricNames": metric_names,
|
|
"dimensions": dimensions,
|
|
"statistics": statistics
|
|
}
|
|
if type is not None:
|
|
body["type"] = type
|
|
|
|
path = b'/data/metricAllData'
|
|
return self._send_csm_request(http_methods.POST, path, version=b'/v2', body=json.dumps(body))
|
|
|
|
def batch_get_all_data_metrics_v2(self, user_id, scope, region, dimensions, metric_names, statistics,
|
|
start_time, end_time, type="Instance", cycle=60):
|
|
|
|
"""
|
|
:param user_id: user_id
|
|
:type string
|
|
|
|
:param scope: scope
|
|
:type string
|
|
|
|
:param region: region
|
|
:type string
|
|
|
|
:param dimensions: dimensions
|
|
:type double dimensional dict array
|
|
|
|
:param metric_names: metric names
|
|
:type string array
|
|
|
|
:param statistics: statistics
|
|
:type string array
|
|
|
|
:param start_time: start time
|
|
:type string
|
|
|
|
:param end_time: end time
|
|
:type string
|
|
|
|
:param type: type
|
|
:type string
|
|
|
|
:param cycle: cycle
|
|
:type int
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(scope) <= 0:
|
|
raise ValueError("scope should not be null")
|
|
if len(region) <= 0:
|
|
raise ValueError("region should not be null")
|
|
if len(metric_names) <= 0:
|
|
raise ValueError("metric_names should not be null")
|
|
if len(dimensions) <= 0:
|
|
raise ValueError("dimensions should not be null")
|
|
if len(statistics) <= 0:
|
|
raise ValueError("statistics should not be null")
|
|
if len(dimensions) > MAX_INSTANCE_NUMBER:
|
|
raise ValueError("dimensions size cannot more than " + MAX_INSTANCE_NUMBER)
|
|
body = {
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"cycle": cycle,
|
|
"region": region,
|
|
"startTime": start_time,
|
|
"endTime": end_time,
|
|
"metricNames": metric_names,
|
|
"dimensions": dimensions,
|
|
"statistics": statistics
|
|
}
|
|
if type is not None:
|
|
body["type"] = type
|
|
|
|
path = b'/data/metricAllData/batch'
|
|
return self._send_csm_request(http_methods.POST, path, version=b'/v2', body=json.dumps(body))
|
|
|
|
|
|
def get_metric_dimension_top(self, user_id, scope, region, dimensions, metric_name, statistics, labels,
|
|
start_time, end_time, order="top", topNum=10):
|
|
|
|
"""
|
|
:param user_id: user_id
|
|
:type string
|
|
|
|
:param scope: scope
|
|
:type string
|
|
|
|
:param region: region
|
|
:type string
|
|
|
|
:param dimensions: dimensions
|
|
:type map
|
|
|
|
:param metric_name: metric_name
|
|
:type string
|
|
|
|
:param statistics: statistics
|
|
:type string
|
|
|
|
:param labels: labels
|
|
:type set
|
|
|
|
:param start_time: start_time
|
|
:type string
|
|
|
|
:param end_time: end_time
|
|
:type string
|
|
|
|
:param order: order default top
|
|
:type string
|
|
|
|
:param topNum: topNum default 10
|
|
:type int
|
|
|
|
:return:
|
|
"""
|
|
if len(user_id) <= 0:
|
|
raise ValueError("user_id should not be null")
|
|
if len(scope) <= 0:
|
|
raise ValueError("scope should not be null")
|
|
if len(region) <= 0:
|
|
raise ValueError("region should not be null")
|
|
if len(metric_name) <= 0:
|
|
raise ValueError("metric_name should not be null")
|
|
if len(dimensions) <= 0:
|
|
raise ValueError("dimensions should not be null")
|
|
if len(labels) <= 0:
|
|
raise ValueError("lables should not be null")
|
|
if len(statistics) <= 0:
|
|
raise ValueError("statistics should not be null")
|
|
if len(start_time) <= 0:
|
|
raise ValueError("start_time should not be null")
|
|
if len(end_time) <= 0:
|
|
raise ValueError("end_time should not be null")
|
|
|
|
body = {
|
|
"userId": user_id,
|
|
"scope": scope,
|
|
"region": region,
|
|
"startTime": start_time,
|
|
"endTime": end_time,
|
|
"metricName": metric_name,
|
|
"dimensions": dimensions,
|
|
"statistics": statistics,
|
|
"labels": labels,
|
|
"order": order,
|
|
"topNum": topNum,
|
|
}
|
|
|
|
path = b'/dimensions/top'
|
|
return self._send_csm_request(http_methods.POST, path, version=b'/v2', body=json.dumps(body))
|
|
|
|
|