530 lines
19 KiB
Python
530 lines
19 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 IPv6Gateway.
|
|
"""
|
|
|
|
import copy
|
|
import json
|
|
import logging
|
|
import uuid
|
|
import sys
|
|
|
|
from baidubce import bce_base_client
|
|
from baidubce.auth import bce_v1_signer
|
|
from baidubce.http import bce_http_client
|
|
from baidubce.http import handler
|
|
from baidubce.http import http_methods
|
|
from baidubce.services.ipv6gateway import ipv6gateway_model
|
|
from baidubce import utils
|
|
from baidubce.utils import required
|
|
from baidubce import compat
|
|
|
|
if sys.version < '3':
|
|
reload(sys)
|
|
sys.setdefaultencoding('utf-8')
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
default_billing_to_purchase_created = ipv6gateway_model.Billing('Postpaid')
|
|
default_billing_to_purchase_reserved = ipv6gateway_model.Billing()
|
|
|
|
|
|
class IPv6GatewayClient(bce_base_client.BceBaseClient):
|
|
"""
|
|
IPv6Gateway sdk client
|
|
"""
|
|
version = b'/v1'
|
|
|
|
def __init__(self, config=None):
|
|
bce_base_client.BceBaseClient.__init__(self, config)
|
|
|
|
def _merge_config(self, config=None):
|
|
"""
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
"""
|
|
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
|
|
if headers is None:
|
|
headers = {b'Accept': b'*/*', b'Content-Type':
|
|
b'application/json;charset=utf-8'}
|
|
return bce_http_client.send_request(
|
|
config, bce_v1_signer.sign, [handler.parse_error, body_parser],
|
|
http_method, path, body, headers, params)
|
|
|
|
@required(name=(bytes, str),
|
|
vpc_id=(bytes, str),
|
|
bandwidthInMbps=(bytes, int))
|
|
def create_ipv6_gateway(self, name, vpc_id, bandwidthInMbps, billing=None,
|
|
client_token=None, config=None):
|
|
"""
|
|
Create a ipv6-gateway with the specified options.
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if client token is provided.
|
|
:type client_token: string
|
|
|
|
:param name:
|
|
The name of ipv6-gateway that will be created.
|
|
:type name: string
|
|
|
|
:param vpc_id:
|
|
The id of VPC.
|
|
:type vpc_id: string
|
|
|
|
:param bandwidthInMbps:
|
|
The number of bandwidth.
|
|
:type bandwidthInMbps: int
|
|
|
|
:param billing:
|
|
Billing information.
|
|
:type billing: nat_model.Billing
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway')
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {b'clientToken': client_token}
|
|
if billing is None:
|
|
billing = default_billing_to_purchase_created
|
|
body = {
|
|
'name': compat.convert_to_string(name),
|
|
'vpcId': compat.convert_to_string(vpc_id),
|
|
'bandwidthInMbps': compat.convert_to_string(bandwidthInMbps),
|
|
'billing': billing.__dict__
|
|
}
|
|
return self._send_request(http_methods.POST,
|
|
path, body=json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(vpc_id=(bytes, str))
|
|
def list_ipv6_gateways(self, vpc_id, config=None):
|
|
"""
|
|
Return a list of ipv6-gateways, according to the VPC ID,
|
|
will return a full list of ipv6 gateways in VPC.
|
|
|
|
:param vpc_id:
|
|
The id of VPC.
|
|
:type vpc_id: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway')
|
|
params = {b'vpcId': vpc_id}
|
|
return self._send_request(http_methods.GET, path,
|
|
params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str))
|
|
def delete_ipv6_gateway(self, gateway_id, client_token=None, config=None):
|
|
"""
|
|
delete a specified ipv6-gateway.
|
|
|
|
:param gateway_id:
|
|
The id of specified ipv6-gateway.
|
|
:type gateway_id: string
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if clientToken is provided.
|
|
If the clientToken is not specified by user,
|
|
a random String generated by default algorithm will be used.
|
|
:type client_token: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id)
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {
|
|
b'clientToken': client_token
|
|
}
|
|
|
|
return self._send_request(http_methods.DELETE,
|
|
path, params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str),
|
|
bandwidthInMbps=(bytes, int))
|
|
def resize_ipv6_gateway(self, gateway_id, bandwidthInMbps, client_token=None, config=None):
|
|
"""
|
|
resize a specified ipv6-gateway bandwidth.
|
|
|
|
:param gateway_id:
|
|
The id of specified ipv6-gateway.
|
|
:type gateway_id: string
|
|
|
|
:param bandwidthInMbps:
|
|
The number of bandwidth.
|
|
:type bandwidthInMbps: int
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if clientToken is provided.
|
|
If the clientToken is not specified by user,
|
|
a random String generated by default algorithm will be used.
|
|
:type client_token: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id)
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {
|
|
b'resize': None,
|
|
b'clientToken': client_token
|
|
}
|
|
body = {
|
|
'bandwidthInMbps': compat.convert_to_string(bandwidthInMbps)
|
|
}
|
|
|
|
return self._send_request(http_methods.PUT,
|
|
path, body=json.dumps(body), params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str),
|
|
cidr=(bytes, str))
|
|
def create_ipv6_gateway_egress_only_rule(self, gateway_id, cidr,
|
|
client_token=None, config=None):
|
|
"""
|
|
Create a ipv6-gateway egress only rule with the specified options.
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if client token is provided.
|
|
:type client_token: string
|
|
|
|
:param gateway_id:
|
|
The id of ipv6 gateway.
|
|
:type gateway_id: string
|
|
|
|
:param cidr:
|
|
The cidr of egress only rule.
|
|
:type cidr: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id, 'egressOnlyRule')
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {b'clientToken': client_token}
|
|
body = {
|
|
'cidr': compat.convert_to_string(cidr),
|
|
}
|
|
return self._send_request(http_methods.POST,
|
|
path, body=json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str))
|
|
def list_ipv6_gateway_egress_only_rules(self, gateway_id, marker=None, max_keys=None, config=None):
|
|
"""
|
|
Return a list of ipv6-gateway egress only rules, according to the ipv6 gateway ID,
|
|
will return a full list of ipv6 gateway egress only rules in ipv6 gateway.
|
|
|
|
:param gateway_id:
|
|
The id of ipv6 gateway.
|
|
:type gateway_id: string
|
|
|
|
:param marker:
|
|
The optional parameter marker specified in the original
|
|
request to specify where in the results to begin listing.
|
|
Together with the marker, specifies the list result which
|
|
listing should begin. If the marker is not specified,
|
|
the list result will listing from the first one.
|
|
:type marker: string
|
|
|
|
:param max_keys:
|
|
The optional parameter to specifies the max number of list
|
|
result to return.
|
|
The default value is 1000.
|
|
:type max_keys: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id, 'egressOnlyRule')
|
|
params = {}
|
|
if marker is not None:
|
|
params[b'marker'] = marker
|
|
if max_keys is not None:
|
|
params[b'maxKeys'] = max_keys
|
|
return self._send_request(http_methods.GET, path,
|
|
params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str),
|
|
egress_only_rule_id=(bytes, str))
|
|
def delete_ipv6_gateway_egress_only_rule(self, gateway_id, egress_only_rule_id, client_token=None, config=None):
|
|
"""
|
|
delete a specified ipv6-gateway egress only rule.
|
|
|
|
:param gateway_id:
|
|
The id of specified ipv6-gateway.
|
|
:type gateway_id: string
|
|
|
|
:param egress_only_rule_id:
|
|
The id of specified ipv6-gateway egress only rule.
|
|
:type egress_only_rule_id: string
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if clientToken is provided.
|
|
If the clientToken is not specified by user,
|
|
a random String generated by default algorithm will be used.
|
|
:type client_token: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id, 'egressOnlyRule', egress_only_rule_id)
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {
|
|
b'clientToken': client_token
|
|
}
|
|
|
|
return self._send_request(http_methods.DELETE,
|
|
path, params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str),
|
|
ipv6_address=(bytes, str),
|
|
ingress_bandwidthInMbps=(bytes, int),
|
|
egress_bandwidthInMbps=(bytes, int))
|
|
def create_ipv6_gateway_rate_limit_rule(self, gateway_id, ipv6_address,
|
|
ingress_bandwidthInMbps, egress_bandwidthInMbps,
|
|
client_token=None, config=None):
|
|
"""
|
|
Create a ipv6-gateway rate limit rule with the specified options.
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if client token is provided.
|
|
:type client_token: string
|
|
|
|
:param gateway_id:
|
|
The id of ipv6 gateway.
|
|
:type gateway_id: string
|
|
|
|
:param ipv6_address:
|
|
The ipv6 addrss of rate limit rule.
|
|
:type ipv6_address: string
|
|
|
|
:param ingress_bandwidthInMbps:
|
|
The ingress bandwidth of rate limit rule.
|
|
:type ingress_bandwidthInMbps: int
|
|
|
|
:param egress_bandwidthInMbps:
|
|
The egress bandwidth of rate limit rule.
|
|
:type egress_bandwidthInMbps: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id, 'rateLimitRule')
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {b'clientToken': client_token}
|
|
body = {
|
|
'ipv6Address': compat.convert_to_string(ipv6_address),
|
|
'ingressBandwidthInMbps': compat.convert_to_string(ingress_bandwidthInMbps),
|
|
'egressBandwidthInMbps': compat.convert_to_string(egress_bandwidthInMbps),
|
|
}
|
|
return self._send_request(http_methods.POST,
|
|
path, body=json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str))
|
|
def list_ipv6_gateway_rate_limit_rules(self, gateway_id, marker=None, max_keys=None, config=None):
|
|
"""
|
|
Return a list of ipv6-gateway rate limit rules, according to the ipv6 gateway ID,
|
|
will return a full list of ipv6 gateway rate limit rules in ipv6 gateway.
|
|
|
|
:param gateway_id:
|
|
The id of ipv6 gateway.
|
|
:type gateway_id: string
|
|
|
|
:param marker:
|
|
The optional parameter marker specified in the original
|
|
request to specify where in the results to begin listing.
|
|
Together with the marker, specifies the list result which
|
|
listing should begin. If the marker is not specified,
|
|
the list result will listing from the first one.
|
|
:type marker: string
|
|
|
|
:param max_keys:
|
|
The optional parameter to specifies the max number of list
|
|
result to return.
|
|
The default value is 1000.
|
|
:type max_keys: int
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id, 'rateLimitRule')
|
|
params = {}
|
|
if marker is not None:
|
|
params[b'marker'] = marker
|
|
if max_keys is not None:
|
|
params[b'maxKeys'] = max_keys
|
|
return self._send_request(http_methods.GET, path,
|
|
params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str),
|
|
rate_limit_rule_id=(bytes, str))
|
|
def delete_ipv6_gateway_rate_limit_rule(self, gateway_id, rate_limit_rule_id, client_token=None, config=None):
|
|
"""
|
|
delete a specified ipv6-gateway rate limit rule.
|
|
|
|
:param gateway_id:
|
|
The id of specified ipv6-gateway.
|
|
:type gateway_id: string
|
|
|
|
:param rate_limit_rule_id:
|
|
The id of specified ipv6-gateway rate limit rule.
|
|
:type rate_limit_rule_id: string
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if clientToken is provided.
|
|
If the clientToken is not specified by user,
|
|
a random String generated by default algorithm will be used.
|
|
:type client_token: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id, 'rateLimitRule', rate_limit_rule_id)
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {
|
|
b'clientToken': client_token
|
|
}
|
|
|
|
return self._send_request(http_methods.DELETE,
|
|
path, params=params, config=config)
|
|
|
|
@required(gateway_id=(bytes, str),
|
|
rate_limit_rule_id=(bytes, str),
|
|
ingress_bandwidthInMbps=(bytes, int),
|
|
egress_bandwidthInMbps=(bytes, int))
|
|
def update_ipv6_gateway_rate_limit_rule(self, gateway_id, rate_limit_rule_id,
|
|
ingress_bandwidthInMbps, egress_bandwidthInMbps,
|
|
client_token=None, config=None):
|
|
"""
|
|
update a specified ipv6-gateway rate limit rule.
|
|
|
|
:param gateway_id:
|
|
The id of specified ipv6-gateway.
|
|
:type gateway_id: string
|
|
|
|
:param rate_limit_rule_id:
|
|
The id of specified ipv6-gateway rate limit rule.
|
|
:type rate_limit_rule_id: string
|
|
|
|
:param ingress_bandwidthInMbps:
|
|
The ingress bandwidth of rate limit rule.
|
|
:type ingress_bandwidthInMbps: int
|
|
|
|
:param egress_bandwidthInMbps:
|
|
The egress bandwidth of rate limit rule.
|
|
:type egress_bandwidthInMbps: int
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if clientToken is provided.
|
|
If the clientToken is not specified by user,
|
|
a random String generated by default algorithm will be used.
|
|
:type client_token: string
|
|
|
|
:param config:
|
|
:type config: baidubce.BceClientConfiguration
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = utils.append_uri(self.version, 'IPv6Gateway', gateway_id, 'rateLimitRule', rate_limit_rule_id)
|
|
if client_token is None:
|
|
client_token = generate_client_token()
|
|
params = {
|
|
b'clientToken': client_token
|
|
}
|
|
body = {
|
|
'ingressBandwidthInMbps': compat.convert_to_string(ingress_bandwidthInMbps),
|
|
'egressBandwidthInMbps': compat.convert_to_string(egress_bandwidthInMbps),
|
|
}
|
|
|
|
return self._send_request(http_methods.PUT,
|
|
path, body=json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
|
|
def generate_client_token_by_uuid():
|
|
"""
|
|
The default method to generate the random string for client_token
|
|
if the optional parameter client_token is not specified by the user.
|
|
|
|
:return:
|
|
:rtype string
|
|
"""
|
|
return str(uuid.uuid4())
|
|
|
|
|
|
generate_client_token = generate_client_token_by_uuid
|