1120 lines
38 KiB
Python
1120 lines
38 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 BBC.
|
|
"""
|
|
import copy
|
|
import json
|
|
import logging
|
|
import random
|
|
import string
|
|
import uuid
|
|
|
|
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.utils import aes128_encrypt_16char_key
|
|
from baidubce.utils import required
|
|
from baidubce.services.bbc import bbc_model
|
|
from baidubce import compat
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
default_billing_to_purchase_created = bbc_model.Billing('Postpaid')
|
|
|
|
|
|
|
|
class BbcClient(bce_base_client.BceBaseClient):
|
|
"""
|
|
Bbc client sdk
|
|
"""
|
|
|
|
prefix_v2 = b'/v2'
|
|
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, api_version=b'/v1'):
|
|
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, api_version + path, body, headers, params)
|
|
|
|
|
|
|
|
@required(flavor_id = (bytes, str), image_id = (bytes, str), raid_id = (bytes, str))
|
|
def create_instance(self, flavor_id, image_id, raid_id, root_disk_size_in_gb=20, purchase_count=1,
|
|
zone_name=None, subnet_id=None, billing=None, name=None, admin_pass=None,
|
|
auto_renew_time_unit=None, auto_renew_time=0, deploy_set_id=None, enable_ht=False,
|
|
security_group_id=None, client_token=None, config=None, tags=None):
|
|
|
|
"""
|
|
Create a bbc instance with the specified options.
|
|
You must fill the field of clientToken, which is especially for keeping idempotent.
|
|
This is an asynchronous interface.
|
|
|
|
:param flavor_id:
|
|
The id of flavor, list all available flavors in BbcClient.list_flavors.
|
|
:type flavor_id: string
|
|
|
|
:param image_id:
|
|
The id of image, list all available images in BbcClient.list_images.
|
|
:type image_id: string
|
|
|
|
:param raid_id:
|
|
The id of raid, list all available raids in BbcClient.get_flavor_raid.
|
|
:type raid_id: string
|
|
|
|
:param root_disk_size_in_gb:
|
|
System disk size of the physical machine to be created
|
|
:type root_disk_size_in_gb: int
|
|
|
|
:param purchase_count:
|
|
The number of instances to buy, the default value is 1.
|
|
:type purchase_count: int
|
|
|
|
:param zone_name:
|
|
The optional parameter to specify the available zone for the instance.
|
|
See more detail through list_zones method
|
|
:type zone_name: string
|
|
|
|
:param subnet_id:
|
|
The optional parameter to specify the id of subnet from vpc, optional param
|
|
default value is default subnet from default vpc
|
|
:type subnet_id: string
|
|
|
|
:param billing:
|
|
Billing information.
|
|
:type billing: bbc_model.Billing
|
|
|
|
:param name:
|
|
The optional parameter to desc the instance that will be created.
|
|
:type name: string
|
|
|
|
:param enable_ht:
|
|
The optional parameter to enable instance hyperthread.
|
|
:type name: bool
|
|
|
|
:param admin_pass:
|
|
The optional parameter to specify the password for the instance.
|
|
If specify the adminPass,the adminPass must be a 8-16 characters String
|
|
which must contains letters, numbers and symbols.
|
|
The symbols only contains "!@#$%^*()".
|
|
The adminPass will be encrypted in AES-128 algorithm
|
|
with the substring of the former 16 characters of user SecretKey.
|
|
If not specify the adminPass, it will be specified by an random string.
|
|
See more detail on
|
|
https://cloud.baidu.com/doc/BBC/s/3jwvxu9iz#%E5%AF%86%E7%A0%81%E5%8A%A0%E5%AF%86%E4%BC%A0%E8%BE%93%E8%A7%84%E8%8C%83
|
|
:type admin_pass: string
|
|
|
|
:param auto_renew_time_unit
|
|
The parameter to specify the unit of the auto renew time.
|
|
The auto renew time unit can be "month" or "year".
|
|
The default value is "month".
|
|
:type auto_renew_time_unit: string
|
|
|
|
:param auto_renew_time
|
|
The parameter to specify the auto renew time, the default value is 0.
|
|
:type auto_renew_time: string
|
|
|
|
:deploy_set_id:
|
|
The id of the deploy set
|
|
:type deploy_set_id: string
|
|
|
|
:param security_group_id:
|
|
The optional parameter to specify the securityGroupId of the instance
|
|
vpcId of the securityGroupId must be the same as the vpcId of subnetId
|
|
:type security_group_id: string
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if client token is provided.
|
|
If the clientToken is not specified by the user,
|
|
a random String generated by default algorithm will be used.
|
|
See more detail at
|
|
https://bce.baidu.com/doc/BCC/API.html#.E5.B9.82.E7.AD.89.E6.80.A7
|
|
:type client_token: string
|
|
|
|
:param tags:
|
|
List of tags to be bind
|
|
:type tags: list
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/instance'
|
|
params = {}
|
|
if client_token is None:
|
|
params['clientToken'] = generate_client_token()
|
|
else:
|
|
params['clientToken'] = client_token
|
|
|
|
|
|
if root_disk_size_in_gb == 0:
|
|
root_disk_size_in_gb = 20
|
|
if purchase_count < 1:
|
|
purchase_count = 1
|
|
|
|
if billing is None:
|
|
billing = default_billing_to_purchase_created
|
|
|
|
body = {
|
|
'flavorId': flavor_id,
|
|
'imageId': image_id,
|
|
'raidId': raid_id,
|
|
'rootDiskSizeInGb': root_disk_size_in_gb,
|
|
'purchaseCount': purchase_count,
|
|
'billing': billing.__dict__
|
|
}
|
|
if zone_name is not None:
|
|
body['zoneName'] = zone_name
|
|
if subnet_id is not None:
|
|
body['subnetId'] = subnet_id
|
|
if security_group_id is not None:
|
|
body['securityGroupId'] = security_group_id
|
|
if name is not None:
|
|
body['name'] = name
|
|
if deploy_set_id is not None:
|
|
body['deploySetId'] = deploy_set_id
|
|
if enable_ht:
|
|
body['enableHt'] = True
|
|
if admin_pass is not None:
|
|
secret_access_key = self.config.credentials.secret_access_key
|
|
cipher_admin_pass = aes128_encrypt_16char_key(admin_pass, secret_access_key)
|
|
body['adminPass'] = cipher_admin_pass
|
|
if auto_renew_time_unit is None:
|
|
body['autoRenewTimeUnit'] = "month"
|
|
else:
|
|
body['autoRenewTimeUnit'] = auto_renew_time_unit
|
|
if auto_renew_time != 0:
|
|
body['autoRenewTime'] = auto_renew_time
|
|
if tags is not None:
|
|
body['tags'] = tags
|
|
return self._send_request(http_methods.POST, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
|
|
def list_instances(self, marker=None, max_keys=1000, internal_ip=None, config=None):
|
|
"""
|
|
Return a list of instances owned by the authenticated user.
|
|
|
|
:param marker:
|
|
The optional parameter marker specified in the original request to specify
|
|
where in the results to begin listing.
|
|
Together with the marker, specify 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 specify the max number of list result to return.
|
|
The default value is 1000.
|
|
:type max_keys: int
|
|
|
|
:param internal_ip:
|
|
The identified internal ip of instance.
|
|
:type internal_ip: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
|
|
path = b'/instance'
|
|
params = {}
|
|
|
|
if marker is not None:
|
|
params['marker'] = marker
|
|
if max_keys is not None:
|
|
params['maxKeys'] = max_keys
|
|
if internal_ip is not None:
|
|
params['internalIp'] = internal_ip
|
|
|
|
return self._send_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
|
|
|
|
@required(instance_id=(bytes, str))
|
|
def get_instance(self, instance_id, contains_failed=False, config=None):
|
|
"""
|
|
Get the detailed information of specified instance.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param contains_failed:
|
|
The optional parameters to get the failed message.If true, it means get the failed message.
|
|
:type contains_failed: boolean
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
params = {}
|
|
if contains_failed:
|
|
params['containsFailed'] = contains_failed
|
|
return self._send_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str))
|
|
def start_instance(self, instance_id, config=None):
|
|
"""
|
|
Starting the instance owned by the user.
|
|
You can start the instance only when the instance is Stopped,
|
|
otherwise, it's will get 409 errorCode.
|
|
This is an asynchronous interface.
|
|
|
|
:param instance_id: id of instance proposed to start
|
|
:type instance_id: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
params = {
|
|
'start': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str))
|
|
def stop_instance(self, instance_id, force_stop=False, config=None):
|
|
"""
|
|
Stopping the instance owned by the user.
|
|
You can stop the instance only when the instance is Running,
|
|
otherwise, it's will get 409 errorCode.
|
|
This is an asynchronous interface.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param force_stop:
|
|
The optional parameter to stop the instance forcibly.If true,
|
|
it will stop the instance just like power off immediately
|
|
and it may result in losing important data which have not been written to disk.
|
|
:type force_stop: boolean
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
body = {
|
|
'forceStop': force_stop
|
|
}
|
|
params = {
|
|
'stop': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str))
|
|
def reboot_instance(self, instance_id, force_stop=False, config=None):
|
|
"""
|
|
Rebooting the instance owned by the user.
|
|
You can reboot the instance only when the instance is Running,
|
|
otherwise, it's will get 409 errorCode.
|
|
This is an asynchronous interface.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param force_stop:
|
|
The optional parameter to stop the instance forcibly.If true,
|
|
it will stop the instance just like power off immediately
|
|
and it may result in losing important data which have not been written to disk.
|
|
:type force_stop: boolean
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
body = {
|
|
'forceStop': force_stop
|
|
}
|
|
params = {
|
|
'reboot': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=str)
|
|
def batch_add_ip(self, instance_id, private_ips=None, secondary_private_ip_address_count=None, config=None):
|
|
"""
|
|
batch_add_ip
|
|
:param instance_id:
|
|
:param private_ips:
|
|
:param secondary_private_ip_address_count:
|
|
:param config:
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/instance/batchAddIp'
|
|
body = {
|
|
'instanceId': instance_id,
|
|
}
|
|
if private_ips is not None:
|
|
body['privateIps'] = private_ips
|
|
if secondary_private_ip_address_count is not None:
|
|
body['secondaryPrivateIpAddressCount'] = secondary_private_ip_address_count
|
|
params = {
|
|
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=str, private_ips=list)
|
|
def batch_delete_ip(self, instance_id, private_ips, config=None):
|
|
"""
|
|
:param instance_id:
|
|
:param private_ips:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
path = b'/instance/batchDelIp'
|
|
body = {
|
|
'instanceId': instance_id,
|
|
'privateIps': private_ips,
|
|
}
|
|
params = {
|
|
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str),
|
|
renew_time_unit=(bytes, str),
|
|
renew_time=int)
|
|
def create_auto_renew_rules(self, instance_id, renew_time_unit, renew_time, config=None):
|
|
"""
|
|
Creating auto renew rules for the bbc.
|
|
It only works for the prepaid bbc.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param renew_time_unit
|
|
The parameter to specify the unit of the renew time.
|
|
The renew time unit can be "month" or "year".
|
|
:type renew_time_unit: string
|
|
|
|
:param renew_time
|
|
The parameter to specify the renew time.
|
|
:type renew_time: int
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/batchCreateAutoRenewRules'
|
|
body = {
|
|
'instanceId': instance_id,
|
|
'renewTimeUnit': renew_time_unit,
|
|
'renewTime': renew_time
|
|
}
|
|
params = {
|
|
|
|
}
|
|
return self._send_request(http_methods.POST, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str))
|
|
def delete_auto_renew_rules(self, instance_id, config=None):
|
|
"""
|
|
Deleting auto renew rules for the bbc.
|
|
It only works for the prepaid bbc.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/batchDeleteAutoRenewRules'
|
|
body = {
|
|
'instanceId': instance_id
|
|
}
|
|
params = {
|
|
|
|
}
|
|
return self._send_request(http_methods.POST, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
def describe_regions(self, region, config=None):
|
|
"""
|
|
List all region's endpoint information with the specific parameters.
|
|
Use global endpoint bbc.baidubce.com to get BBC's endpoint.
|
|
|
|
:param region:
|
|
The id of region.
|
|
:type region: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
|
|
path = b'/region/describeRegions'
|
|
body = {
|
|
'region': region
|
|
}
|
|
params = {}
|
|
return self._send_request(http_methods.POST, path, json.dumps(body),
|
|
params=params, config=config, api_version=self.prefix_v2)
|
|
|
|
@required(instance_id=(bytes, str),
|
|
name=(bytes, str))
|
|
def modify_instance_name(self, instance_id, name, config=None):
|
|
"""
|
|
Modifying the name of the instance.
|
|
You can modify the instance name only when the instance is Running or Stopped ,
|
|
otherwise, it's will get 409 errorCode.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param name:
|
|
The new value for instance's name.
|
|
:type name: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
body = {
|
|
'name': name
|
|
}
|
|
params = {
|
|
'rename': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
|
|
|
|
def modify_instance_desc(self, instance_id, desc, config=None):
|
|
"""
|
|
Modifying the description of the instance.
|
|
You can modify the description only when the instance is Running or Stopped ,
|
|
otherwise, it's will get 409 errorCode.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param desc:
|
|
The new description of the instance.
|
|
:type name: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
body = {
|
|
'desc': desc
|
|
}
|
|
params = {
|
|
'updateDesc': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str),
|
|
image_id=(bytes, str),
|
|
admin_pass=(bytes, str))
|
|
def rebuild_instance(self, instance_id, image_id, admin_pass,
|
|
is_preserve_data=True, raid_id=None, sys_root_size=20, config=None):
|
|
"""
|
|
Rebuilding the instance owned by the user.
|
|
After rebuilding the instance,
|
|
all of snapshots created from original instance system disk will be deleted,
|
|
all of customized images will be saved for using in the future.
|
|
This is an asynchronous interface
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param image_id:
|
|
The id of the image which is used to rebuild the instance.
|
|
:type image_id: string
|
|
|
|
:param admin_pass:
|
|
The admin password to login the instance.
|
|
The admin password will be encrypted in AES-128 algorithm
|
|
with the substring of the former 16 characters of user SecretKey.
|
|
See more detail on
|
|
https://cloud.baidu.com/doc/BBC/s/3jwvxu9iz#%E5%AF%86%E7%A0%81%E5%8A%A0%E5%AF%86%E4%BC%A0%E8%BE%93%E8%A7%84%E8%8C%83
|
|
:type admin_pass: string
|
|
|
|
:param is_preserve_data:
|
|
Whether or not to retain data, the default is true. The raid_id and
|
|
sys_root_size fields do not take effect when the value is true
|
|
:type is_preserve_data: bool
|
|
|
|
:param raid_id:
|
|
The id of raid. See more details on
|
|
https://cloud.baidu.com/doc/BBC/s/Bjwvxu9ul#%E6%9F%A5%E8%AF%A2raid
|
|
:type raid_id: string
|
|
|
|
:param sys_root_size:
|
|
System root partition size, default is 20G, value range is 20-100
|
|
:type sys_root_size: int
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
secret_access_key = self.config.credentials.secret_access_key
|
|
cipher_admin_pass = aes128_encrypt_16char_key(admin_pass, secret_access_key)
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
body = {
|
|
'imageId': image_id,
|
|
'adminPass': cipher_admin_pass,
|
|
'isPreserveData': is_preserve_data,
|
|
'raidId': raid_id,
|
|
'sysRootSize': sys_root_size
|
|
}
|
|
params = {
|
|
'rebuild': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str))
|
|
def release_instance(self, instance_id, config=None):
|
|
"""
|
|
Releasing the instance owned by the user.
|
|
Only the Postpaid instance or Prepaid which is expired can be released.
|
|
After releasing the instance,
|
|
all of the data will be deleted.
|
|
all of snapshots created from original instance system disk will be deleted,
|
|
all of customized images created from original instance system disk will be reserved.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
api_version = b'/v2'
|
|
path = b'/instance/%s' % instance_id
|
|
return self._send_request(http_methods.DELETE, path, config=config, api_version=api_version)
|
|
|
|
@required(instance_id=(bytes, str),
|
|
admin_pass=(bytes, str))
|
|
def modify_instance_password(self, instance_id, admin_pass, config=None):
|
|
"""
|
|
Modifying the password of the instance.
|
|
You can change the instance password only when the instance is Running or Stopped ,
|
|
otherwise, it's will get 409 errorCode.
|
|
This is an asynchronous interface.
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param admin_pass:
|
|
The new password to update.
|
|
The adminPass will be encrypted in AES-128 algorithm
|
|
with the substring of the former 16 characters of user SecretKey.
|
|
:type admin_pass: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
secret_access_key = self.config.credentials.secret_access_key
|
|
cipher_admin_pass = aes128_encrypt_16char_key(admin_pass, secret_access_key)
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s' % instance_id
|
|
body = {
|
|
'adminPass': cipher_admin_pass
|
|
}
|
|
params = {
|
|
'changePass': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(bbc_ids = list)
|
|
def get_vpc_subnet(self, bbc_ids, config=None):
|
|
"""
|
|
Query VPC / Subnet information by BBC instance id
|
|
|
|
:param bbc_ids:
|
|
List of BBC instance IDs that need to query VPC / Subnet information
|
|
:type bbc_ids: list
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/vpcSubnet'
|
|
body = {
|
|
'bbcIds': bbc_ids
|
|
}
|
|
|
|
return self._send_request(http_methods.POST, path, body=json.dumps(body), config = config)
|
|
|
|
@required(instance_id=(bytes, str), change_tags = list)
|
|
def unbind_tags(self, instance_id, change_tags, config=None):
|
|
"""
|
|
Unbind the tags of existing instances
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param change_tags:
|
|
List of tags to be unbind
|
|
:type change_tags: list
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s/tag' % instance_id
|
|
|
|
params = {
|
|
'unbind': None
|
|
}
|
|
|
|
body = {
|
|
'changeTags': change_tags
|
|
}
|
|
|
|
return self._send_request(http_methods.PUT, path, body=json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
@required(instance_id=(bytes, str), change_tags = list)
|
|
def bind_tags(self, instance_id, change_tags, config=None):
|
|
"""
|
|
bind the tags of existing instances
|
|
|
|
:param instance_id:
|
|
The id of instance.
|
|
:type instance_id: string
|
|
|
|
:param change_tags:
|
|
List of tags to be bind
|
|
:type change_tags: list
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
|
|
"""
|
|
instance_id = compat.convert_to_bytes(instance_id)
|
|
path = b'/instance/%s/tag' % instance_id
|
|
|
|
params = {
|
|
'bind': None
|
|
}
|
|
|
|
body = {
|
|
'changeTags': change_tags
|
|
}
|
|
|
|
return self._send_request(http_methods.PUT, path, body=json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
|
|
@required(reserved_instance_ids=list,
|
|
tags=list)
|
|
def bind_reserved_instance_to_tags(self, reserved_instance_ids, tags, config=None):
|
|
"""
|
|
:param reserved_instance_ids:
|
|
:param tags:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
path = b'/bbc/reserved/tag'
|
|
tag_list = [tag.__dict__ for tag in tags]
|
|
body = {
|
|
'changeTags': tag_list,
|
|
'reservedInstanceIds': reserved_instance_ids
|
|
}
|
|
params = {
|
|
'bind': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config, api_version=self.prefix_v2)
|
|
|
|
@required(reserved_instance_ids=list,
|
|
tags=list)
|
|
def unbind_reserved_instance_from_tags(self, reserved_instance_ids, tags, config=None):
|
|
"""
|
|
:param reserved_instance_ids:
|
|
:param tags:
|
|
:param config:
|
|
:return:
|
|
"""
|
|
path = b'/bbc/reserved/tag'
|
|
tag_list = [tag.__dict__ for tag in tags]
|
|
body = {
|
|
'changeTags': tag_list,
|
|
'reservedInstanceIds': reserved_instance_ids
|
|
}
|
|
params = {
|
|
'unbind': None
|
|
}
|
|
return self._send_request(http_methods.PUT, path, json.dumps(body),
|
|
params=params, config=config, api_version=self.prefix_v2)
|
|
|
|
def list_flavors(self, config=None):
|
|
"""
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
|
|
"""
|
|
path = b'/flavor'
|
|
return self._send_request(http_methods.GET, path, config = config)
|
|
|
|
@required(flavor_id = (bytes, str))
|
|
def get_flavor(self, flavor_id, config=None):
|
|
"""
|
|
:param flavor_id:
|
|
The id of flavor.
|
|
:type flavor_id: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
|
|
"""
|
|
flavor_id = compat.convert_to_bytes(flavor_id)
|
|
path = b'/flavor/%s' % flavor_id
|
|
return self._send_request(http_methods.GET, path, config=config)
|
|
|
|
@required(flavor_id=(bytes, str))
|
|
def get_flavor_raid(self, flavor_id, config=None):
|
|
"""
|
|
:param flavor_id:
|
|
The id of flavor.
|
|
:type flavor_id: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
flavor_id = compat.convert_to_bytes(flavor_id)
|
|
path = b'/flavorRaid/%s' % flavor_id
|
|
return self._send_request(http_methods.GET, path, config=config)
|
|
|
|
@required(image_name=(bytes, str),
|
|
instance_id=(bytes, str))
|
|
def create_image_from_instance_id(self,
|
|
image_name,
|
|
instance_id,
|
|
client_token=None,
|
|
config=None):
|
|
"""
|
|
Creating a customized image which can be used for creating instance.
|
|
You can create an image from an instance with this method.
|
|
While creating an image from an instance, the instance must be Running or Stopped,
|
|
otherwise, it's will get 409 errorCode.
|
|
This is an asynchronous interface.
|
|
|
|
:param image_name:
|
|
The name for the image that will be created.
|
|
The name length from 1 to 65,only contains letters,digital and underline.
|
|
:type image_name: string
|
|
|
|
:param instance_id:
|
|
The optional parameter specify the id of the instance which will be used to create the new image.
|
|
When instanceId and snapshotId are specified ,only instanceId will be used.
|
|
:type instance_id: string
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if client token is provided.
|
|
If the clientToken is not specified by the user,
|
|
a random String generated by default algorithm will be used.
|
|
See more detail at
|
|
https://bce.baidu.com/doc/BCC/API.html#.E5.B9.82.E7.AD.89.E6.80.A7
|
|
:type client_token: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/image'
|
|
params = None
|
|
if client_token is None:
|
|
params = {
|
|
'clientToken': generate_client_token()
|
|
}
|
|
else:
|
|
params = {
|
|
'clientToken': client_token
|
|
}
|
|
body = {
|
|
'imageName': image_name,
|
|
'instanceId': instance_id
|
|
}
|
|
|
|
return self._send_request(http_methods.POST, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
def list_images(self, image_type='All', marker=None, max_keys=1000, config=None):
|
|
"""
|
|
Listing images owned by the authenticated user.
|
|
|
|
:param image_type:
|
|
The optional parameter to filter image to list.
|
|
See more detail at
|
|
https://bce.baidu.com/doc/BCC/API.html#ImageType"
|
|
:type image_type: menu{'All', System', 'Custom', 'Integration'}
|
|
|
|
: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 specify the max number of list result to return.
|
|
The default value is 1000.
|
|
:type max_keys: int
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/image'
|
|
params = {
|
|
'imageType': image_type
|
|
}
|
|
if marker is not None:
|
|
params['marker'] = marker
|
|
if max_keys is not None:
|
|
params['maxKeys'] = max_keys
|
|
|
|
return self._send_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
@required(image_id=(bytes, str))
|
|
def get_image(self, image_id, config=None):
|
|
"""
|
|
Get the detail information of specified image.
|
|
|
|
:param image_id:
|
|
The id of image.
|
|
:type image_id: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
image_id = compat.convert_to_bytes(image_id)
|
|
path = b'/image/%s' % image_id
|
|
return self._send_request(http_methods.GET, path, config=config)
|
|
|
|
@required(image_id=(bytes, str))
|
|
def delete_image(self, image_id, config=None):
|
|
"""
|
|
Deleting the specified image.
|
|
Only the customized image can be deleted,
|
|
otherwise, it's will get 403 errorCode.
|
|
|
|
:param image_id:
|
|
The id of image.
|
|
:type image_id: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
image_id = compat.convert_to_bytes(image_id)
|
|
path = b'/image/%s' % image_id
|
|
return self._send_request(http_methods.DELETE, path, config=config)
|
|
|
|
def get_operation_log(self, marker=None, max_keys=100, start_time=None, end_time=None, config=None):
|
|
"""
|
|
Querying information about physical machine operation logs
|
|
|
|
: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 specify the max number of list result to return.
|
|
The default value is 1000.
|
|
:type max_keys: int
|
|
|
|
:param start_time:
|
|
The start time of the physical machine operation (UTC time),
|
|
the format is yyyy-MM-dd'T'HH: mm: ss'Z ', if it is empty, query the operation log of the day
|
|
:type start_time: string
|
|
|
|
:params end_time
|
|
The end time of the physical machine operation (UTC time),
|
|
the format is yyyy-MM-dd'T'HH: mm: ss'Z ', if it is empty, query the operation log of the day
|
|
:type end_time: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/operationLog'
|
|
params = {}
|
|
if marker is not None:
|
|
params['marker'] = marker
|
|
if max_keys is not None:
|
|
params['maxKeys'] = max_keys
|
|
if start_time is not None:
|
|
params['startTime'] = start_time
|
|
if end_time is not None:
|
|
params['endTime'] = end_time
|
|
|
|
return self._send_request(http_methods.GET, path, params=params, config=config)
|
|
|
|
@required(concurrency=int, strategy=(bytes, str))
|
|
def create_deploy_set(self, concurrency, strategy, name=None, desc=None, client_token=None, config=None):
|
|
"""
|
|
Create a deploy set based on a specified policy and concurrency
|
|
|
|
:param concurrency:
|
|
Deployment set concurrency, range [1,5]
|
|
:type concurrency: int
|
|
|
|
:param strategy:
|
|
Deployment set strategy, currently BBC strategy only supports: "tor_ha", "host_ha"
|
|
:type strategy: string
|
|
|
|
:param name:
|
|
Deployment set name, supports uppercase and lowercase letters, numbers,
|
|
Chinese, and -_ /. Special characters, must start with a letter, length 1-65
|
|
:type name: string
|
|
|
|
:param desc:
|
|
Deployment set description
|
|
:type desc: string
|
|
|
|
:param client_token:
|
|
An ASCII string whose length is less than 64.
|
|
The request will be idempotent if client token is provided.
|
|
If the clientToken is not specified by the user,
|
|
a random String generated by default algorithm will be used.
|
|
See more detail at
|
|
https://bce.baidu.com/doc/BCC/API.html#.E5.B9.82.E7.AD.89.E6.80.A7
|
|
:type client_token: string
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/deployset'
|
|
params = {}
|
|
if client_token is None:
|
|
params['clientToken'] = generate_client_token()
|
|
else:
|
|
params['clientToken'] = client_token
|
|
body = {
|
|
"strategy": strategy,
|
|
"concurrency": concurrency
|
|
}
|
|
if name is not None:
|
|
body["name"] = name
|
|
if desc is not None:
|
|
body['desc'] = desc
|
|
return self._send_request(http_methods.POST, path, json.dumps(body),
|
|
params=params, config=config)
|
|
|
|
def list_deploy_sets(self, config=None):
|
|
"""
|
|
List all deploy sets
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
path = b'/deployset'
|
|
return self._send_request(http_methods.GET, path, config=config)
|
|
|
|
@required(deploy_set_ids=(bytes, str))
|
|
def get_deploy_set(self, deploy_set_id, config=None):
|
|
"""
|
|
Get the specified deploy set
|
|
|
|
:param deploy_set_id:
|
|
The id of the deploy set
|
|
:type deploy_set_id: String
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
deploy_set_id = compat.convert_to_bytes(deploy_set_id)
|
|
path = b'/deployset/%s' % deploy_set_id
|
|
return self._send_request(http_methods.GET, path, config=config)
|
|
|
|
@required(deploy_set_ids=(bytes, str))
|
|
def delete_deploy_set(self, deploy_set_id, config=None):
|
|
"""
|
|
Delete the specified deploy sets
|
|
|
|
:param deploy_set_ids:
|
|
The ids of the deploy sets you want to delete
|
|
:type deploy_set_ids: list
|
|
|
|
:return:
|
|
:rtype baidubce.bce_response.BceResponse
|
|
"""
|
|
deploy_set_id = compat.convert_to_bytes(deploy_set_id)
|
|
path = b'/deployset/%s' % deploy_set_id
|
|
return self._send_request(http_methods.DELETE, path, 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())
|
|
|
|
|
|
def generate_client_token_by_random():
|
|
"""
|
|
The alternative method to generate the random string for client_token
|
|
if the optional parameter client_token is not specified by the user.
|
|
:return:
|
|
:rtype string
|
|
"""
|
|
client_token = ''.join(random.sample(string.ascii_letters + string.digits, 36))
|
|
return client_token
|
|
|
|
|
|
generate_client_token = generate_client_token_by_uuid
|
|
|
|
|
|
|