def create_s2_shared_target(self,
s2_server_id,
export_name,
target_type,
description=None,
volumes=None,
initiator_names=None,
**ignore):
""" Create S2 shared target
:param s2_server_id: the ID of s2 server.
:param export_name: the name of shared target.
:param target_type: valid values includes 'ISCSI', 'FCoE','NFS' and 'SMB'.
:param description: the detailed description of the resource.
:param volumes: the IDs of volumes will be attached as backstore.
:param initiator_names: specify client IQN, available in vsan.
"""
action = const.ACTION_CREATE_S2_SHARED_TARGET
valid_keys = [
's2_server_id', 'export_name', 'target_type',
'description', 'volumes', 'initiator_names',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=['volumes', 'initiator_names'],
):
return None
return self.conn.send_request(action, body)
def create_s2_account(self,
account_type,
account_name=None,
smb_name=None,
smb_passwd=None,
nfs_ipaddr=None,
s2_groups=None,
opt_parameters=None,
description=None,
**ignore):
""" Create S2 account
:param account_type: valid values is NFS or SMB.
:param account_name: the name of account.
:param smb_name: the user name of smb.
:param smb_passwd: the password of smb.
:param nfs_ipaddr: ip address available in NFS.
:param s2_groups: the JSON form of groups. e.g. '[{"group_id":"s2g-xxxx", "rw_flag": "rw"}]'
:param opt_parameters: options parameters for NFS.
:param description: the detailed description of the resource.
"""
action = const.ACTION_CREATE_S2_ACCOUNT
valid_keys = [
'account_type', 'account_name', 'smb_name', 'smb_passwd',
'nfs_ipaddr', 's2_groups', 'opt_parameters', 'description',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=["s2_groups"],
):
return None
return self.conn.send_request(action, body)
def reset_instances(self, instances,
login_mode=None,
login_passwd=None,
login_keypair=None,
need_newsid=False,
**ignore):
""" Reset one or monre instances to its initial state.
@param login_mode: login mode, only supported for linux instance, valid values are "keypair", "passwd".
param login_passwd: if login_mode is "passwd", should be specified.
@param login_keypair: if login_mode is "keypair", should be specified.
@param instances : an array of instance ids you want to reset.
@param need_newsid: Whether to generate new SID for the instance (True) or not
(False). Only valid for Windows instance; Silently ignored
for Linux instance.
"""
action = const.ACTION_RESET_INSTANCES
valid_keys = ['instances', 'login_mode',
'login_passwd', 'login_keypair', 'need_newsid']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=['instances'],
integer_params=['need_newsid'],
list_params=['instances']
):
return None
return self.conn.send_request(action, body)
def describe_vxnets(self, vxnets=None,
search_word=None,
verbose=0,
owner=None,
limit=None,
offset=None,
tags=None,
vxnet_type=None,
mode=None,
**ignore):
""" Describe vxnets filtered by condition.
@param vxnets: the IDs of vxnets you want to describe.
@param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
@param tags : the array of IDs of tags.
@param vxnet_type: the vxnet of type you want to describe.
@param mode: the vxnet mode. 0: gre+ovs, 1: vxlan+bridge.
"""
action = const.ACTION_DESCRIBE_VXNETS
valid_keys = ['vxnets', 'search_word', 'verbose', 'limit', 'offset',
'tags', 'vxnet_type', 'owner', 'mode']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
'limit', 'offset', 'verbose',
'vxnet_type', 'mode',
],
list_params=['vxnets', 'tags']
):
return None
return self.conn.send_request(action, body)
def describe_security_groups(self, security_groups=None,
security_group_name=None,
search_word=None,
owner=None,
verbose=0,
offset=None,
limit=None,
tags=None,
**ignore):
""" Describe security groups filtered by condition
@param security_groups: IDs of the security groups you want to describe.
@param security_group_name: the name of the security group.
@param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
@param tags : the array of IDs of tags.
"""
action = const.ACTION_DESCRIBE_SECURITY_GROUPS
valid_keys = ['security_groups', 'security_group_name', 'search_word',
'verbose', 'offset', 'limit', 'tags', 'owner']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
'offset', 'limit', 'verbose'],
list_params=[
'security_groups', 'tags']
):
return None
return self.conn.send_request(action, body)
def create_s2_server(self,
vxnet,
service_type,
s2_server_name=None,
s2_server_type=None,
private_ip=None,
description=None,
s2_class=None,
**ignore):
""" Create S2 server
:param vxnet: the ID of vxnet.
:param service_type: valid values is vsan or vnas.
:param s2_server_name: the name of s2 server.
:param s2_server_type: valid values includes 0, 1, 2, 3.
:param private_ip: you may specify the ip address of this server.
:param description: the detailed description of the resource.
:param s2_class: valid values includes 0, 1.
"""
action = const.ACTION_CREATE_S2_SERVER
valid_keys = [
'vxnet', 'service_type', 's2_server_name', 's2_server_type',
'private_ip', 'description', 's2_class',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=["s2_server_type", "s2_class"],
):
return None
return self.conn.send_request(action, body)
def describe_clusters(self, clusters=None,
role=None,
status=None,
verbose=1,
search_word=None,
owner=None,
offset=None,
limit=None,
tags=None,
**ignore):
""" Describe clusters filtered by condition.
@param clusters: the array of cluster IDs.
@param status: pending, active, stopped, deleted, suspended, ceased
@param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
@param search_word: search word column.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
@param tags : the array of IDs of tags.
"""
action = const.ACTION_DESCRIBE_CLUSTERS
valid_keys = ['clusters', 'status', 'verbose', 'search_word',
'owner', 'offset', 'limit', 'tags', 'role']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
'offset', 'limit'],
list_params=[
'clusters', 'status', 'tags']
):
return None
return self.conn.send_request(action, body)
def describe_instance_groups(self, instance_groups=[],
relation=None,
tags=None,
owner=None,
verbose=0,
offset=0,
limit=20,
**ignore):
""" Describe the instance groups filtered by conditions.
@param instance_groups: If this param was given, only return the group(s) info in this given list.
@param relation: Filter by the relation type.
@param tags: Filter by the tag id.
@param owner: Filter by the owner id.
@param verbose: Whether return the verbose information.
@param offset: The offset of the item cursor and its default value is 0.
@param limit: The number of items that will be displayed. Default is 20, maximum is 100.
"""
action = const.ACTION_DESCRIBE_INSTANCE_GROUPS
valid_keys = ['instance_groups', 'relation', 'tags', 'owner',
'verbose', 'offset', 'limit']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
list_params=['instance_groups', 'tags'],
integer_params=['limit', 'verbose', 'offset']
):
return None
return self.conn.send_request(action, body)
def resize_instances(self, instances,
instance_type=None,
cpu=None,
memory=None,
os_disk_size=None,
**ignore):
""" Resize one or more instances
@param instances: the IDs of the instances you want to resize.
@param instance_type: defined by qingcloud.
See: https://docs.qingcloud.com/api/common/includes/instance_type.html
@param cpu: cpu core number.
@param memory: memory size in MB.
@param os_disk_size: operation system disk size in GB.
"""
action = const.ACTION_RESIZE_INSTANCES
valid_keys = ['instances', 'instance_type', 'cpu', 'memory', 'os_disk_size']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=['instances'],
integer_params=['cpu', 'memory', 'os_disk_size'],
list_params=['instances']
):
return None
return self.conn.send_request(action, body)
def create_loadbalancer(self,
eips=None,
loadbalancer_name=None,
security_group=None,
node_count=None,
loadbalancer_type=const.LB_TYPE_MAXCONN_5k,
vxnet=None,
private_ip=None,
target_user=None,
**ignore):
""" Create new load balancer.
@param eips: the IDs of the eips that will be associated to load balancer.
@param loadbalancer_name: the name of the loadbalancer.
@param security_group: the id of the security_group you want to apply to loadbalancer,
use `default security` group as default.
@param target_user: ID of user who will own this resource, should be one of your sub-accounts
"""
action = const.ACTION_CREATE_LOADBALANCER
valid_keys = ['eips', 'loadbalancer_name', 'loadbalancer_type',
'security_group', 'node_count', 'vxnet', 'private_ip',
'target_user',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=['node_count'],
list_params=['eips']
):
return None
return self.conn.send_request(action, body)
def modify_alarm_policy_rule_attributes(self, alarm_policy_rule,
condition_type,
thresholds=None,
alarm_policy_rule_name=None,
data_processor=None,
consecutive_periods=None,
**ignore):
""" Modify alarm policy rule attributes.
@param alarm_policy_rule: the ID of the alarm policy rule whose content you
want to update.
@param condition_type: gt for greater than, lt for less than.
@param thresholds: the thresholds of alarm.
@param alarm_policy_rule_name: the name of the alarm policy rule.
@param data_processor: raw for use the monitoring data raw value, percent only for IP bandwidth monitoring.
@param consecutive_periods: during several consecutive inspection periods, the monitoring data reaches the alarm threshold,
then will trigger the alarm behavior.
"""
action = const.ACTION_MODIFY_ALARM_POLICY_RULE_ATTRIBUTES
valid_keys = ['alarm_policy_rule', 'condition_type', 'thresholds',
'alarm_policy_rule_name', 'data_processor', 'consecutive_periods']
body = filter_out_none(locals(), valid_keys)
if not self.req_checker.check_params(body,
required_params=['alarm_policy_rule', 'condition_type']
):
return None
return self.send_request(action, body)
def describe_loadbalancer_policies(self, loadbalancer_policies=None,
verbose=0,
offset=None,
limit=None,
**ignore):
""" Describe load balancer policies.
@param loadbalancer_policies: filter by load balancer policy ID.
@param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_LOADBALANCER_POLICIES
valid_keys = ['loadbalancer_policies',
'verbose', 'offset', 'limit']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=['offset', 'limit'],
list_params=['loadbalancer_policies']
):
return None
return self.conn.send_request(action, body)
def modify_loadbalancer_backend_attributes(self, loadbalancer_backend,
loadbalancer_backend_name=None,
port=None,
weight=None,
disabled=None,
**ignore):
""" Modify load balancer backend attributes.
@param loadbalancer_backend: the ID of backend.
@param loadbalancer_backend_name: the name of the backend.
@param port: backend server listen port.
@param weight: backend server weight, valid range is from 1 to 100.
"""
action = const.ACTION_MODIFY_LOADBALANCER_BACKEND_ATTRIBUTES
valid_keys = ['loadbalancer_backend', 'loadbalancer_backend_name',
'port', 'weight', 'disabled']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[
'loadbalancer_backend'],
integer_params=[
'port', 'weight', 'disabled'],
list_params=[]
):
return None
if 'port' in body:
self.conn.req_checker.check_lb_backend_port(body['port'])
if 'weight' in body:
self.conn.req_checker.check_lb_backend_weight(body['weight'])
return self.conn.send_request(action, body)
def attach_tags(self, resource_tag_pairs, **ignore):
""" Attach one or more tags to resources.
@param resource_tag_pairs: the pair of resource and tag.
it's a list-dict, such as:
[{
'tag_id': 'tag-hp55o9i5',
'resource_type': 'instance',
'resource_id': 'i-5yn6js06'
}]
"""
action = const.ACTION_ATTACH_TAGS
valid_keys = ['resource_tag_pairs']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[
'resource_tag_pairs'],
list_params=['resource_tag_pairs']):
return None
for pair in resource_tag_pairs:
if not isinstance(pair, dict):
return None
for key in ['tag_id', 'resource_id', 'resource_type']:
if key not in pair:
return None
return self.conn.send_request(action, body)
def modify_security_group_attributes(self, security_group,
security_group_name=None,
description=None,
**ignore):
""" Modify security group attributes.
@param security_group: the ID of the security group whose content you
want to update.
@param security_group_name: the new group name you want to update.
@param description: The detailed description of the resource.
"""
action = const.ACTION_MODIFY_SECURITY_GROUP_ATTRIBUTES
valid_keys = ['security_group', 'security_group_name', 'description']
body = filter_out_none(locals(), valid_keys)
body['security_group'] = security_group
if not self.conn.req_checker.check_params(body,
required_params=[
'security_group'],
integer_params=[],
list_params=[]
):
return None
if not self.conn.req_checker.check_sg_rules(body.get('rules', [])):
return None
return self.conn.send_request(action, body)
def describe_security_group_ipsets(self,
security_group_ipsets=None,
ipset_type=None,
security_group_ipset_name=None,
offset=None,
limit=None,
**ignore):
""" Describe security group ipsets filtered by condition.
@param security_group_ipsets: the ID of the security group ipsets.
@param ipset_type: 0 for ip; 1 for port
@param security_group_ipset_name: filter by name
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_SECURITY_GROUP_IPSETS
valid_keys = ['security_group_ipsets', 'ipset_type',
'security_group_ipset_name',
'offset', 'limit']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
'ipset_type', 'offset', 'limit'],
list_params=[
'security_group_rules']
):
return None
return self.conn.send_request(action, body)
def describe_s2_accounts(self,
s2_accounts=None,
account_types=None,
account_name=None,
search_word=None,
verbose=None,
offset=None,
limit=None,
**ignore):
""" Describe S2 accounts
:param s2_accounts: the IDs of accounts.
:param account_types: valid values is NFS or SMB.
:param account_name: the name of account.
:param search_word: you may use this field to search from id, account_name nfs_ipaddr or smb_name.
:param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
:param offset: the starting offset of the returning results.
:param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_S2_ACCOUNTS
valid_keys = [
's2_accounts', 'account_types', 'account_name', 'search_word',
'verbose', 'offset', 'limit',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=["limit", "offset", "verbose"],
list_params=["s2_accounts", "account_types"],
):
return None
return self.conn.send_request(action, body)
def describe_security_group_rules(self, security_group=None,
security_group_rules=None,
direction=None,
offset=None,
limit=None,
**ignore):
""" Describe security group rules filtered by condition.
@param security_group: the ID of the security group whose rules you want to describe.
@param security_group_rules: the IDs of the security group rules you want to describe.
@param direction: 0 for inbound; 1 for outbound
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_SECURITY_GROUP_RULES
valid_keys = ['security_group', 'security_group_rules', 'direction',
'offset', 'limit']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
'direction', 'offset', 'limit'],
list_params=[
'security_group_rules']
):
return None
return self.conn.send_request(action, body)
def describe_s2_groups(self,
s2_groups=None,
group_types=None,
group_name=None,
search_word=None,
verbose=None,
offset=None,
limit=None,
**ignore):
""" Describe S2 groups
:param s2_groups: the IDs of s2 groups.
:param group_types: valid values is NFS_GROUP or SMB_GROUP.
:param group_name: the name of group.
:param search_word: you may use this field to search from id or name.
:param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
:param offset: the starting offset of the returning results.
:param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_S2_GROUPS
valid_keys = [
's2_groups', 'group_types', 'account_name', 'search_word',
'verbose', 'offset', 'limit',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=['offset', 'limit', 'verbose'],
list_params=['s2_groups', 'group_types'],
):
return None
return self.conn.send_request(action, body)
def describe_s2_servers(self,
s2_servers=None,
service_types=None,
status=None,
search_word=None,
tags=None,
verbose=None,
offset=None,
limit=None,
**ignore):
""" Describe S2 servers
:param s2_servers: the IDs of s2 server you want to describe.
:param service_types: the type of service, valid value is 'vsan' or 'vnas'.
:param status: valid values include pending, active, poweroffed, suspended, deleted, ceased.
:param search_word: you may use this field to search from id, name and description.
:param tags: the array of IDs of tags.
:param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
:param offset: the starting offset of the returning results.
:param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_S2_SERVERS
valid_keys = [
's2_servers', 'service_types', 'status', 'search_word',
'tags', 'verbose', 'offset', 'limit',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=["offset", "limit", "verbose"],
list_params=["s2_servers", "service_types", "tags", "status"],
):
return None
return self.conn.send_request(action, body)
def modify_s2_group(self,
s2_group,
group_name=None,
s2_accounts=None,
description=None,
**ignore):
""" Modify S2 group
:param s2_group: the ID of group.
:param group_name: the name of group.
:param s2_accounts: the IDs of accounts.
:param description: the new value of description.
"""
action = const.ACTION_MODIFY_S2_GROUP
valid_keys = [
's2_group', 'group_name', 's2_accounts', 'description',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=['s2_accounts'],
):
return None
return self.conn.send_request(action, body)
def modify_s2_shared_target_attributes(self,
shared_target,
operation,
parameters=None,
initiator_names=None,
s2_group=None,
export_name=None,
**ignore):
""" Modify S2 shared target attributes
:param shared_target: the ID of shared target.
:param operation: valid values includes add, modify, delete, set.
:param parameters: please refer https://docs.qingcloud.com/api/s2/describle_s2_default_parameters.html
:param initiator_names: client IQN.
:param s2_group: the ID of permission group.
:param export_name: the name of shared target, available in vnas.
"""
action = const.ACTION_MODIFY_S2_SHARED_TARGET
valid_keys = [
'shared_target', 'operation', 'parameters',
'initiator_names', 's2_group', 'export_name',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=["initiator_names", "parameters"],
):
return None
return self.conn.send_request(action, body)
def describe_s2_default_parameters(self,
service_type=None,
target_type=None,
offset=None,
limit=None,
**ignore):
""" Describe S2 default parameters
:param service_type: valid values is vsan or vnas.
:param target_type: valid values is ISCSI, FCoE, NFS or SMB.
:param offset: the starting offset of the returning results.
:param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_S2_DEFAULT_PARAMETERS
valid_keys = [
'service_type', 'target_type', 'offset', 'limit',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=['offset', 'limit'],
):
return None
return self.conn.send_request(action, body)
def modify_security_group_ipset_attributes(self,
security_group_ipset,
security_group_ipset_name=None,
description=None,
val=None,
**ignore):
""" Modify security group ipset attributes.
@param security_group_ipset: the ID of the security group ipset whose attributes you
want to update.
@param security_group_ipset_name: name of the ipset.
@param description: The detailed description of the resource.
@param val1: for "ip", this field is like: 192.168.1.0/24
for "port", this field is like: 10000-15000
"""
action = const.ACTION_MODIFY_SECURITY_GROUP_IPSET_ATTRIBUTES
valid_keys = ['security_group_ipset', 'security_group_ipset_name',
'description', 'val']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[
'security_group_ipset'],
integer_params=[],
list_params=[]
):
return None
return self.conn.send_request(action, body)
def describe_s2_shared_targets(self,
shared_targets=None,
target_types=None,
s2_server_id=None,
export_name=None,
search_word=None,
verbose=None,
offset=None,
limit=None,
**ignore):
""" Describe S2 servers
:param shared_targets: the IDs of shared targets.
:param target_types: valid values includes 'ISCSI', 'FCoE','NFS' and 'SMB'.
:param s2_server_id: the ID of s2 server.
:param export_name: the name of shared target.
:param search_word: you may use this field to search from export_name or description.
:param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
:param offset: the starting offset of the returning results.
:param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_S2_SHARED_TARGETS
valid_keys = [
'shared_targets', 'target_types', 's2_server_id', 'export_name',
'search_word', 'verbose', 'offset', 'limit',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=["limit", "offset", "verbose"],
list_params=["shared_targets", "target_types"],
):
return None
return self.conn.send_request(action, body)
def describe_alarms(self, alarms=None,
policy=None,
status=None,
resource=None,
offset=None,
limit=None,
**ignore):
""" Describe alarms filtered by condition.
@param alarms: an array including IDs of the alarms you want to list.
@param policy: the ID of alarm policy.
@param status: ok stand for normal, alarm stand for alarming, insufficient stand for monitoring data cannot be collected.
@param resource: The ID of resource which associated with the alarm.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_ALARMS
valid_keys = ['alarms', 'policy', 'status', 'resource', 'offset', 'limit']
body = filter_out_none(locals(), valid_keys)
if not self.req_checker.check_params(body,
integer_params=['offset', 'limit'],
list_params=['alarms']
):
return None
return self.send_request(action, body)
def describe_vxnet_instances(self, vxnet,
instances=None,
image=None,
instance_type=None,
status=None,
limit=None,
offset=None,
**ignore):
""" Describe instances in vxnet.
@param vxnet: the ID of vxnet whose instances you want to describe.
@param image: filter by image ID.
@param instances: filter by instance ID.
@param instance_type: filter by instance type
See: https://docs.qingcloud.com/api/common/includes/instance_type.html
@param status: filter by status
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_VXNET_INSTANCES
valid_keys = ['vxnet', 'instances', 'image', 'instance_type', 'status',
'limit', 'offset']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=['vxnet'],
integer_params=[
'limit', 'offset'],
list_params=['instances']
):
return None
return self.conn.send_request(action, body)
def add_security_group_rules(self, security_group,
rules,
target_user=None,
**ignore):
""" Add rules to security group.
@param security_group: the ID of the security group whose rules you
want to add.
@param rules: a list of rules you want to add,
can be created by SecurityGroupRuleFactory.
@param target_user: ID of user who will own this resource, should be one of your sub-accounts
"""
action = const.ACTION_ADD_SECURITY_GROUP_RULES
valid_keys = ['security_group', 'rules', 'target_user']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[
'security_group', 'rules'],
integer_params=[],
list_params=['rules']
):
return None
if not self.conn.req_checker.check_sg_rules(body.get('rules', [])):
return None
return self.conn.send_request(action, body)
def modify_s2_account(self,
s2_account,
opt_parameters=None,
account_name=None,
smb_passwd=None,
nfs_ipaddr=None,
description=None,
**ignore):
""" Modify S2 account
:param s2_account: the ID of account.
:param opt_parameters: the options parameters.
:param account_name: the new value of account name.
:param smb_passwd: the new password.
:param nfs_ipaddr: the new ip address.
:param description: the new value of description.
"""
action = const.ACTION_MODIFY_S2_ACCOUNT
valid_keys = [
's2_account', 'opt_parameters', 'account_name', 'smb_passwd',
'nfs_ipaddr', 'description',
]
body = filter_out_none(locals(), valid_keys)
return self.conn.send_request(action, body)
def describe_volumes(self, volumes=None,
volume_type=None,
instance_id=None,
status=None,
owner=None,
search_word=None,
verbose=0,
offset=None,
limit=None,
tags=None,
**ignore):
""" Describe volumes filtered by conditions
@param volumes : the array of IDs of volumes.
@param volume_type : the type of volume, 0 is high performance, 1 is high capacity
@param instance_id: ID of the instance that volume is currently attached to, if has.
@param status: pending, available, in-use, deleted.
@param search_word: the combined search column.
@param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
@param tags : the array of IDs of tags.
"""
valid_keys = ['volumes', 'instance_id', 'status', 'search_word',
'volume_type', 'verbose', 'offset', 'limit', 'tags', 'owner']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
'offset', 'limit', 'verbose'],
list_params=[
'volumes', 'status', 'tags']
):
return None
return self.conn.send_request(const.ACTION_DESCRIBE_VOLUMES, body)
def modify_alarm_policy_action_attributes(self,
alarm_policy_action,
trigger_action=None,
trigger_status=None,
**ignore):
""" Modify alarm policy action attributes.
@param alarm_policy_action: the ID of the alarm policy action whose content you
want to update.
@param trigger_action: the ID of the trigger action.
@param trigger_status: when the monitor alarm state becomes 'ok' or 'alarm', the message will be sent to this trigger list.
"""
action = const.ACTION_MODIFY_ALARM_POLICY_ACTION_ATTRIBUTES
valid_keys = [
'alarm_policy_action', 'trigger_action', 'trigger_status'
]
body = filter_out_none(locals(), valid_keys)
if not self.req_checker.check_params(
body, required_params=['alarm_policy_action']):
return None
return self.send_request(action, body)
def modify_image_attributes(self, image,
image_name=None,
description=None,
**ignore):
""" Modify image attributes.
@param image: the ID of image whose attributes you want to modify.
@param image_name: Name of the image. It's a short name for the image
that more meaningful than image id.
@param description: The detailed description of the image.
"""
action = const.ACTION_MODIFY_IMAGE_ATTRIBUTES
valid_keys = ['image', 'image_name', 'description']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=['image'],
integer_params=[],
list_params=[]
):
return None
return self.conn.send_request(action, body)
def create_snapshots(self,
resources,
snapshot_name=None,
is_full=0,
**ignore):
""" Create snapshots.
@param resources: the IDs of resources you want to create snapshot for, the supported resource types are instance/volume.
@param snapshot_name: the name of the snapshot.
@param is_full: whether to create a full snapshot. 0: determined by the system. 1: should create full snapshot.
"""
action = const.ACTION_CREATE_SNAPSHOTS
valid_keys = ['resources', 'snapshot_name', 'is_full']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=["resources"],
integer_params=["is_full"],
list_params=["resources"]):
return None
return self.conn.send_request(action, body)
def associate_s2_account_group(self,
s2_group,
s2_accounts,
**ignore):
""" Associate S2 account group
:param s2_group: the ID of group.
:param s2_accounts: the JSON form of accounts. e.g. '[{"account_id": "s2a-xxxx", "rw_flag": "rw"}]'
"""
action = const.ACTION_ASSOCIATE_S2_ACCOUNT_GROUP
valid_keys = [
's2_group', 's2_accounts',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=['s2_accounts'],
):
return None
return self.conn.send_request(action, body)
def dissociate_s2_account_group(self,
s2_groups,
s2_accounts,
**ignore):
""" Dissociate S2 account group
:param s2_groups: the IDs of groups.
:param s2_accounts: the IDs of accounts.
"""
action = const.ACTION_DISSOCIATE_S2_ACCOUNT_GROUP
valid_keys = [
's2_groups', 's2_accounts',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=['s2_groups', 's2_accounts'],
):
return None
return self.conn.send_request(action, body)
def detach_from_s2_shared_target(self,
shared_target,
volumes,
**ignore):
""" Detach from s2 shared target
:param shared_target: the ID of shared target.
:param volumes: the IDs of volumes.
"""
action = const.ACTION_DETACH_FROM_S2_SHARED_TARGET
valid_keys = [
'shared_target', 'volumes',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=['volumes'],
):
return None
return self.conn.send_request(action, body)
def modify_nic_attributes(self,
nic,
nic_name=None,
private_ip=None,
**ignore):
""" Modify one nic's attributes
@param nic: the ID of nic you want to modify.
@param nic_name: the new name of nic.
@param private_ip: the new ip address for this nic.
"""
action = const.ACTION_MODIFY_NIC_ATTRIBUTES
valid_keys = ["nic", "nic_name", "private_ip"]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=["nic"],
):
return None
return self.conn.send_request(action, body)
def associate_alarm_policy(self,
alarm_policy,
resources,
related_resource=None,
**ignore):
""" Associate an alarm_policy on one or more resources.
@param alarm_policy: The id of alarm policy you want to associate with resources.
@param resources: the id of resources you want to associate alarm policy.
@param related_resource: when the network load balancer is bound,
related_resource needs to specify a public network IP ID associated with this load balancer.
"""
action = const.ACTION_ASSOCIATE_ALARM_POLICY
valid_keys = ['alarm_policy', 'resources', 'related_resource']
body = filter_out_none(locals(), valid_keys)
if not self.req_checker.check_params(
body,
required_params=['alarm_policy', 'resources'],
list_params=['resources']):
return None
return self.send_request(action, body)
def modify_border_attributes(self,
border,
border_name=None,
description=None,
**params):
""" Action: ModifyBorderAttributes
@param border: border id.
@param border_name: the short name of borders.
@param description: the description of borders.
"""
action = const.ACTION_MODIFY_BORDER_ATTRIBUTES
valid_keys = ['border', 'border_name', 'description']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=['border'],
):
return None
return self.conn.send_request(action, body)
def create_s2_account(self,
account_type,
account_name=None,
smb_name=None,
smb_passwd=None,
nfs_ipaddr=None,
s2_groups=None,
opt_parameters=None,
description=None,
**ignore):
""" Create S2 account
:param account_type: valid values is NFS or SMB.
:param account_name: the name of account.
:param smb_name: the user name of smb.
:param smb_passwd: the password of smb.
:param nfs_ipaddr: ip address available in NFS.
:param s2_groups: the JSON form of groups. e.g. '[{"group_id":"s2g-xxxx", "rw_flag": "rw"}]'
:param opt_parameters: options parameters for NFS.
:param description: the detailed description of the resource.
"""
action = const.ACTION_CREATE_S2_ACCOUNT
valid_keys = [
'account_type',
'account_name',
'smb_name',
'smb_passwd',
'nfs_ipaddr',
's2_groups',
'opt_parameters',
'description',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
list_params=["s2_groups"],
):
return None
return self.conn.send_request(action, body)
def delete_vpc_borders(self,
vpc_borders=None,
unlease=1,
project_id=None,
**params):
""" Action: DeleteVpcBorders
@param vpc_borders: IDs of vpc_borders you want to delete border.
@param unlease: whether to unlease before terminate.
@param project_id: the project ID of vpc borders.
"""
action = const.ACTION_DELETE_VPC_BORDERS
valid_keys = ['vpc_borders', 'unlease', 'project_id']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=['vpc_borders'],
integer_params=['unlease'],
):
return None
return self.conn.send_request(action, body)
def describe_snapshots(self, snapshots=None,
resource_id=None,
snapshot_type=None,
root_id=None,
owner=None,
status=None,
verbose=0,
search_word=None,
offset=None,
limit=None,
tags=None,
**ignore):
""" Describe snapshots filtered by condition.
@param snapshots: an array including IDs of the snapshots you want to list.
No ID specified means list all.
@param resource_id: filter by resource ID.
@param snapshot_type: filter by snapshot type. 0: incremantal snapshot, 1: full snapshot.
@param root_id: filter by snapshot root ID.
@param status: valid values include pending, available, suspended, deleted, ceased.
@param verbose: the number to specify the verbose level,
larger the number, the more detailed information will be returned.
@param search_word: the search word.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
@param tags : the array of IDs of tags.
"""
action = const.ACTION_DESCRIBE_SNAPSHOTS
valid_keys = ['snapshots', 'resource_id', 'snapshot_type', 'root_id', 'status',
'verbose', 'search_word', 'offset', 'limit', 'tags', 'owner']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
"offset", "limit", "verbose", "snapshot_type"],
list_params=["snapshots", "tags"]
):
return None
return self.conn.send_request(action, body)
def modify_alarm_policy_attributes(self,
alarm_policy,
alarm_policy_name=None,
period=None,
description=None,
**ignore):
""" Modify alarm policy attributes.
@param alarm_policy : the ID of alarm_policy.
@param alarm_policy_name : the name of alarm_policy.
@param period: the check period of alarm_policy.
@param description: the description of alarm_policy.
"""
action = const.ACTION_MODIFY_ALARM_POLICY_ATTRIBUTES
valid_keys = [
'alarm_policy', 'alarm_policy_name', 'period', 'description'
]
body = filter_out_none(locals(), valid_keys)
if not self.req_checker.check_params(body,
required_params=['alarm_policy']):
return None
return self.send_request(action, body)
def create_loadbalancer(self,
eips=None,
loadbalancer_name=None,
security_group=None,
node_count=None,
loadbalancer_type=const.LB_TYPE_MAXCONN_5k,
vxnet=None,
private_ip=None,
target_user=None,
mode=0,
**ignore):
""" Create new load balancer.
@param eips: the IDs of the eips that will be associated to load balancer.
@param loadbalancer_name: the name of the loadbalancer.
@param security_group: the id of the security_group you want to apply to loadbalancer,
use `default security` group as default.
@param target_user: ID of user who will own this resource, should be one of your sub-accounts
"""
action = const.ACTION_CREATE_LOADBALANCER
valid_keys = [
'eips',
'loadbalancer_name',
'loadbalancer_type',
'mode',
'security_group',
'node_count',
'vxnet',
'private_ip',
'target_user',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=[],
integer_params=['node_count', 'mode'],
list_params=['eips']):
return None
return self.conn.send_request(action, body)
def modify_security_group_rule_attributes(self,
security_group_rule,
priority=None,
security_group_rule_name=None,
rule_action=None,
direction=None,
protocol=None,
val1=None,
val2=None,
val3=None,
**ignore):
""" Modify security group rule attributes.
@param security_group_rule: the ID of the security group rule whose attributes you
want to update.
@param priority: priority [0 - 100].
@param security_group_rule_name: name of the rule.
@param rule_action: "accept" or "drop".
@param direction: 0 for inbound; 1 for outbound.
@param protocol: supported protocols are "icmp", "tcp", "udp", "gre".
@param val1: for "icmp" protocol, this field is "icmp type";
for "tcp/udp", it's "start port", empty means all.
@param val2: for "icmp" protocol, this field is "icmp code";
for "tcp/udp", it's "end port", empty means all.
@param val3: ip network, e.g "1.2.3.0/24"
"""
action = const.ACTION_MODIFY_SECURITY_GROUP_RULE_ATTRIBUTES
valid_keys = [
'security_group_rule', 'priority', 'security_group_rule_name',
'rule_action', 'direction', 'protocol', 'val1', 'val2', 'val3'
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=['security_group_rule'],
integer_params=['priority'],
list_params=[]):
return None
return self.conn.send_request(action, body)
def describe_alarm_history(self,
alarm,
history_type=None,
offset=None,
limit=None,
**ignore):
""" Describe alarm history filtered by condition.
@param alarm: the ID of the resource alarm entity.
@param history_type: the types including trigger_action, status_change, config_update.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_ALARM_HISTORY
valid_keys = ['alarm', 'history_type', 'offset', 'limit']
body = filter_out_none(locals(), valid_keys)
if not self.req_checker.check_params(
body,
required_params=['alarm'],
integer_params=['offset', 'limit']):
return None
return self.send_request(action, body)
def describe_alarm_policy_rules(self,
alarm_policy=None,
alarm_policy_rules=None,
offset=None,
limit=None,
**ignore):
""" Describe alarm policy rules filtered by conditions.
@param alarm_policy : the ID of alarm_policy.
@param alarm_policy_rules : the array of IDs of alarm policy rules.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_ALARM_POLICY_RULES
valid_keys = ['alarm_policy', 'alarm_policy_rules', 'offset', 'limit']
body = filter_out_none(locals(), valid_keys)
if not self.req_checker.check_params(
body,
integer_params=['offset', 'limit'],
list_params=['alarm_policy_rules']):
return None
return self.send_request(action, body)
def describe_s2_groups(self,
s2_groups=None,
group_types=None,
group_name=None,
search_word=None,
verbose=None,
offset=None,
limit=None,
**ignore):
""" Describe S2 groups
:param s2_groups: the IDs of s2 groups.
:param group_types: valid values is NFS_GROUP or SMB_GROUP.
:param group_name: the name of group.
:param search_word: you may use this field to search from id or name.
:param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
:param offset: the starting offset of the returning results.
:param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_S2_GROUPS
valid_keys = [
's2_groups',
'group_types',
'account_name',
'search_word',
'verbose',
'offset',
'limit',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=['offset', 'limit', 'verbose'],
list_params=['s2_groups', 'group_types'],
):
return None
return self.conn.send_request(action, body)
def describe_nics(self,
nics=None,
nic_name=None,
status=None,
vxnets=None,
vxnet_type=None,
offset=None,
limit=None,
**ignore):
""" Describe nics
@param nics: the IDs of nic you want to describe.
@param nic_name: the name of nic.
@param status: valid values include available, in-use.
@param vxnets: the IDs of vxnet.
@param vxnet_type: vxnet type, 0: unmanaged, 1: managed.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_NICS
valid_keys = [
"nics",
"nic_name",
"status",
"vxnets",
"vxnet_type",
"offset",
"limit",
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=["offset", "limit"],
list_params=["nics", "vxnets"],
):
return None
return self.conn.send_request(action, body)
def describe_instances(self, instances=None,
image_id=None,
instance_type=None,
status=None,
owner=None,
search_word=None,
verbose=0,
offset=None,
limit=None,
tags=None,
instance_name=None,
**ignore):
""" Describe instances filtered by conditions
@param instances : the array of IDs of instances
@param image_id : ID of the image which is used to launch this instance.
@param instance_type: The instance type.
See: https://docs.qingcloud.com/api/common/includes/instance_type.html
@param status : Status of the instance, including pending, running, stopped, terminated.
@param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
@param search_word: the combined search column.
@param offset: the starting offset of the returning results.
@param limit: specify the number of the returning results.
@param tags : the array of IDs of tags.
"""
action = const.ACTION_DESCRIBE_INSTANCES
valid_keys = ['instances', 'image_id', 'instance_type', 'status',
'search_word', 'verbose', 'offset', 'limit', 'tags', 'owner','instance_name']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[],
integer_params=[
'offset', 'limit', 'verbose'],
list_params=[
'instances', 'status', 'tags']
):
return None
return self.conn.send_request(action, body)
def describe_s2_accounts(self,
s2_accounts=None,
account_types=None,
account_name=None,
search_word=None,
verbose=None,
offset=None,
limit=None,
**ignore):
""" Describe S2 accounts
:param s2_accounts: the IDs of accounts.
:param account_types: valid values is NFS or SMB.
:param account_name: the name of account.
:param search_word: you may use this field to search from id, account_name nfs_ipaddr or smb_name.
:param verbose: the number to specify the verbose level, larger the number, the more detailed information will be returned.
:param offset: the starting offset of the returning results.
:param limit: specify the number of the returning results.
"""
action = const.ACTION_DESCRIBE_S2_ACCOUNTS
valid_keys = [
's2_accounts',
'account_types',
'account_name',
'search_word',
'verbose',
'offset',
'limit',
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=["limit", "offset", "verbose"],
list_params=["s2_accounts", "account_types"],
):
return None
return self.conn.send_request(action, body)
def modify_loadbalancer_attributes(self, loadbalancer,
security_group=None,
loadbalancer_name=None,
description=None,
**ignore):
""" Modify load balancer attributes.
@param loadbalancer: the ID of loadbalancer you want to modify.
@param security_group: the ID of the security_group.
@param loadbalancer_name: the name of the loadbalancer.
@param description: the description of the loadbalancer.
"""
action = const.ACTION_MODIFY_LOADBALANCER_ATTRIBUTES
valid_keys = ['loadbalancer', 'security_group', 'loadbalancer_name',
'description']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=['loadbalancer'],
integer_params=[],
list_params=[]
):
return None
return self.conn.send_request(action, body)
def create_s2_group(self,
group_type,
group_name=None,
s2_accounts=None,
description=None,
**ignore):
""" Create S2 group
:param group_type: valid values is NFS_GROUP or SMB_GROUP.
:param group_name: the name of group.
:param s2_accounts: the IDs of s2 accounts.
:param description: the detailed description of the resource.
"""
action = const.ACTION_CREATE_S2_GROUP
valid_keys = [
'group_type',
'group_name',
's2_accounts',
'description',
]
body = filter_out_none(locals(), valid_keys)
return self.conn.send_request(action, body)
def add_listeners_to_loadbalancer(self,
loadbalancer,
listeners,
target_user=None,
**ignore):
""" Add listeners to load balancer.
@param loadbalancer: The ID of loadbalancer.
@param listeners: the listeners to add.
@param target_user: ID of user who will own this resource, should be one of your sub-accounts
"""
action = const.ACTION_ADD_LOADBALANCER_LISTENERS
valid_keys = ['listeners', 'loadbalancer', 'target_user']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=['loadbalancer', 'listeners'],
integer_params=[],
list_params=['listeners']):
return None
self.conn.req_checker.check_lb_listeners(listeners)
return self.conn.send_request(action, body)
def resize_s2_servers(self,
s2_servers,
s2_server_type,
**ignore):
""" Resize S2 servers
:param s2_servers: the IDs of s2 servers you want to resize.
:param s2_server_type: valid values includes 0, 1, 2, 3.
"""
action = const.ACTION_RESIZE_S2_SERVERS
valid_keys = [
's2_servers', 's2_server_type'
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
integer_params=['s2_server_type'],
list_params=['s2_servers'],
):
return None
return self.conn.send_request(action, body)
def modify_instance_attributes(self, instance,
instance_name=None,
description=None,
nic_mqueue=None,
**ignore):
""" Modify instance attributes.
@param instance: the ID of instance whose attributes you want to modify.
@param instance_name: Name of the instance. It's a short name for the instance
that more meaningful than instance id.
@param nic_mqueue: Enable or disable multiqueue.
@param description: The detailed description of the resource.
"""
action = const.ACTION_MODIFY_INSTANCE_ATTRIBUTES
valid_keys = ['instance', 'instance_name', 'description', 'nic_mqueue']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=['instance'],
integer_params=['nic_mqueue'],
list_params=[]
):
return None
return self.conn.send_request(action, body)
def add_cluster_nodes(self,
cluster,
node_count,
owner=None,
node_name=None,
node_role=None,
resource_conf=None,
**params):
""" Add one or more cluster nodes
"""
action = const.ACTION_ADD_CLUSTER_NODES
valid_keys = [
'cluster', 'node_count', 'owner', 'node_name', 'node_role',
'resource_conf'
]
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=['cluster', 'node_count'],
integer_params=['node_count']):
return None
return self.conn.send_request(action, body)
def resize_cluster(self,
cluster,
node_role=None,
cpu=None,
memory=None,
storage_size=None,
**ignore):
""" Resize cluster
@param cluster: the ID of the cluster you want to resize.
@param cpu: cpu core number.
@param memory: memory size in MB.
@param storage_size: The new larger size of the storage_size, unit is GB.
"""
action = const.ACTION_RESIZE_CLUSTER
valid_keys = ['cluster', 'node_role', 'cpu', 'memory', 'storage_size']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=['cluster'],
integer_params=['cpu', 'memory']):
return None
return self.conn.send_request(action, body)
def run_instances_by_configuration(self, launch_configuration,
instance_name='',
count=1,
volumes=None,
**ignore):
""" Run one or more instances by launch configuration.
@param launch_configuration: ID of launch configuration you want to use
@param instance_name: a meaningful short name of instance.
@param count : The number of instances to launch, default 1.
@param volumes: the ids of volumes will be attached.
"""
action = const.ACTION_RUN_INSTANCES_BY_CONFIGURATION
valid_keys = ['launch_configuration', 'instance_name', 'count', 'volumes']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(body,
required_params=[
'launch_configuration'],
integer_params=['count'],
list_params=['volumes']
):
return None
return self.conn.send_request(action, body)
def apply_security_group(self,
security_group,
instances=None,
target_user=None,
**ignore):
""" Apply a security group with current rules.
If `instances` specified, apply the security group to them,
or will affect all instances that has applied this security group.
@param security_group: the ID of the security group that you
want to apply to instances.
@param instances: the IDs of the instances you want to apply the security group.
@param target_user: ID of user who will own this resource, should be one of your sub-accounts
"""
action = const.ACTION_APPLY_SECURITY_GROUP
valid_keys = ['security_group', 'instances', 'target_user']
body = filter_out_none(locals(), valid_keys)
if not self.conn.req_checker.check_params(
body,
required_params=['security_group'],
integer_params=[],
list_params=['instances']):
return None
return self.conn.send_request(action, body)
