def remove_instances(self,
as_group_id,
instance_ids,
delete_instance=None):
"""batch remove instances of a group
Remove instance preconditions:
1. instance lifecycle status should be INSERVICE
2. Instance group is not scaling
3. After remove, total instance number should not less than
min-instance-number
:param as_group_id: remove instance belong to the group
:param instance_ids: instances which should be removed
:param delete_instance: delete instance after remove, False by default
:return:
"""
json = utils.remove_empty_from_dict({
"action":
"REMOVE",
"instances_id":
instance_ids,
"instance_delete":
"yes" if delete_instance else None
})
url = "/scaling_group_instance/%s/action" % as_group_id
return self._create(url, json=json, raw=True)
def list(self,
as_group_id,
start_time=None,
end_time=None,
limit=None,
offset=None):
"""list auto scaling group activity logs
:param as_group_id:
:param start_time: datetime
:param end_time: datetime
:param limit:
:param offset:
:return:
"""
str_fmt = "%Y-%m-%dT%H:%M:%SZ"
start_time_str = start_time.strftime(str_fmt) if start_time else None
end_time_str = end_time.strftime(str_fmt) if end_time else None
params = utils.remove_empty_from_dict({
"start_time": start_time_str,
"end_time": end_time_str,
"limit": limit,
"offset": offset,
})
url = "/scaling_activity_log/" + as_group_id
return self._list(url, params=params, key="scaling_activity_log")
def list(self,
as_group_id,
name=None,
type_=None,
limit=None,
offset=None):
"""list policy for auto scaling group
:param as_group_id:
:param name:
:param type_:
:param limit:
:param offset:
:return:
:rtype: [resource.AutoScalingPolicy]
"""
params = utils.remove_empty_from_dict({
"scaling_policy_name": name,
"scaling_policy_type": type_,
"start_number": offset,
"limit": limit,
})
url = "/scaling_policy/%s/list" % as_group_id
return self._list(url, params=params, key="scaling_policies")
def list(self,
name=None,
status=None,
as_config_id=None,
limit=None,
offset=None):
"""list auto scaling groups
:param name: group name
:param status: one of ["INSERVICE", "PAUSED", "ERROR"]
:param as_config_id: auto scaling configuration id
:param limit:
:param offset:
:rtype: list of resource.AutoScalingGroup
:return:
"""
params = utils.remove_empty_from_dict({
"scaling_group_name": name,
"scaling_group_status": status,
"scaling_configuration_id": as_config_id,
"start_number": offset,
"limit": limit,
})
return self._list("/scaling_group",
params=params,
key='scaling_groups')
def create(self, name, instance_id=None, flavor_id=None, image_id=None,
disk=None, key_name=None, admin_pwd=None, files=None,
metadata=None):
"""create a new auto scaling instance configuration
:param name: Something to name the configuration.
:param instance_id: Create Instance with the `instance` as template
:param image_id: The :class:`Image` to boot with.
:param flavor_id: The :class:`Flavor` to boot onto.
:param disk: create instance with disk settings, disk is an array like
[{"size": 40, "volume_type": "SATA", "disk_type": "SYS"},
{"size": 40, "volume_type": "SATA", "disk_type": "DATA"}]
:param key_name: (optional extension) name of previously created
keypair to inject into the instance. Not supported for
Window Server. Either key_name or admin_pwd should be set
:param admin_pwd: (optional extension), admin user login password
:param files: A dict of files to overwrite on the server upon boot.
Keys are file names (i.e. ``/etc/passwd``) and values
are the file contents (either as a string or as a
file-like object). A maximum of five entries is allowed,
and each file must be 10k or less.
:param metadata: A dict of arbitrary key/value metadata to store for
instance. Both keys and values must be <=255 characters.
:return:
"""
personality = []
if files:
for filepath, file_or_string in sorted(files.items(),
key=lambda x: x[0]):
if hasattr(file_or_string, 'read'):
data = file_or_string.read()
else:
data = file_or_string
if six.PY3 and isinstance(data, str):
data = data.encode('utf-8')
content = base64.b64encode(data).decode('utf-8')
personality.append({
'path': filepath,
'content': content,
})
config = utils.remove_empty_from_dict({
"instance_id": instance_id,
"flavorRef": flavor_id,
"imageRef": image_id,
"disk": disk,
"key_name": key_name,
"adminPass": admin_pwd,
"metadata": metadata,
"personality": personality,
})
json = {
"scaling_configuration_name": name,
"instance_config": config
}
return self._create("/scaling_configuration", json=json)
def create(self,
name,
vpc_id,
subnets,
security_groups,
as_config_id=None,
desire_instance_number=None,
max_instance_number=None,
min_instance_number=None,
cool_down_time=None,
lb_listener_id=None,
health_periodic_audit_time=None,
health_periodic_audit_method=None,
instance_terminate_policy=None,
delete_public_ip=None,
notifications=None,
availability_zones=None):
"""create new auto scaling group"""
json = utils.remove_empty_from_dict({
"scaling_group_name":
name,
"vpc_id":
vpc_id,
"networks": [dict(id=subnet) for subnet in subnets],
"security_groups": [dict(id=sg) for sg in security_groups],
"scaling_configuration_id":
as_config_id,
"lb_listener_id":
lb_listener_id,
"desire_instance_number":
desire_instance_number,
"min_instance_number":
min_instance_number,
"max_instance_number":
max_instance_number,
"cool_down_time":
cool_down_time,
"health_periodic_audit_method":
health_periodic_audit_method,
"health_periodic_audit_time":
health_periodic_audit_time,
"instance_terminate_policy":
instance_terminate_policy,
"notifications":
notifications,
"delete_publicip":
delete_public_ip,
"availability_zones":
availability_zones,
})
return self._create("/scaling_group", json=json)
def add_instances(self, as_group_id, instance_ids):
"""batch add instances to a group
Remove instance preconditions:
1. Instance group's status should be INSERVICE, and is not scaling
2. After add, total instance number should not be great than
max-instance-number
:param as_group_id: remove instance belong to the group
:param instance_ids: instances which should be removed
:return:
"""
json = utils.remove_empty_from_dict({
"action": "ADD",
"instances_id": instance_ids,
})
url = "/scaling_group_instance/%s/action" % as_group_id
return self._create(url, json=json, raw=True)
def list(self, name=None, image_id=None, offset=None, limit=None):
"""list auto scaling instance configuration
:param name: configuration name
:param image_id: configuration image id
:param offset:
:param limit:
:return: [resource.AutoScalingConfig]
"""
params = utils.remove_empty_from_dict({
"scaling_configuration_name": name,
"image_id": image_id,
"start_number": offset,
"limit": limit,
})
return self._list("/scaling_configuration",
key="scaling_configurations",
params=params)
def list(self,
as_group_id,
lifecycle_status=None,
health_status=None,
limit=None,
offset=None):
"""list auto scaling instances of an auto-scaling group
:param as_group_id:
:param lifecycle_status: ["INSERVICE", "PENDING", "REMOVING"]
:param health_status: ["INITIALIZING", "NORMAL", "ERROR",]
:param limit:
:param offset:
:rtype :class: [resource.AutoScalingInstance]
:return:
"""
params = utils.remove_empty_from_dict({
"life_cycle_status": lifecycle_status,
"health_status": health_status,
"limit": limit,
"start_number": offset,
})
url = "/scaling_group_instance/%s/list" % as_group_id
return self._list(url, params=params, key="scaling_group_instances")
def create(self,
as_group_id,
name,
type_,
cool_down=None,
alarm_id=None,
launch_time=None,
start_time=None,
end_time=None,
recurrence_type=None,
recurrence_value=None,
operation=None,
instance_number=None):
"""create a new policy
:param as_group_id:
:param name: policy name
:param type_: policy type, ["ALARM", "SCHEDULED", "RECURRENCE"]
:param cool_down: Auto-Scaling policy schedule period (second),
900 seconds by default
:param alarm_id: Alarm Id to assign to the policy (Only effect when
policy-type is ALARM)
:param launch_time: Schedule launch time(Only Effect when policy-type
is SCHEDULED)
:param start_time: Recurrence start UTC time (Effect only when policy-
type is RECURRENCE)
:param end_time: Recurrence end UTC time (Effect only when policy-type
is RECURRENCE)
:param recurrence_type: Recurrence type contains ['Daily', 'Weekly',
'Monthly'] (Effect only when policy-type is RECURRENCE)
:param recurrence_value: When type is Daily, value should be HH:ss
(example: Daily:18:00 means schedule at Everyday's
18:00); When type is Weekly, value should be 1-7
(example: Weekly:1,3 means schedule at Every
Sunday,Wednesday); When type is Monthly, value should
be 1-31 (example: Monthly:1,10,20 means schedule at
1,10,20 of Every Month)
:param operation: Action performed when policy execute, operation
contains ['ADD', 'REMOVE', 'SET']
:param instance_number: Instance numbers to operate
:return:
"""
str_fmt = "%Y-%m-%dT%H:%MZ"
start_time_str = start_time.strftime(str_fmt) if start_time else None
end_time_str = end_time.strftime(str_fmt) if end_time else None
launch_time = launch_time.strftime(str_fmt) if launch_time else None
if recurrence_type == 'Daily':
launch_time = recurrence_value
recurrence_value = None
json = utils.remove_empty_from_dict({
"scaling_policy_name":
name,
"scaling_policy_action":
utils.remove_empty_from_dict({
"operation": operation,
"instance_number": instance_number
}),
"cool_down_time":
cool_down,
"alarm_id":
alarm_id,
"scheduled_policy":
utils.remove_empty_from_dict({
"launch_time": launch_time,
"recurrence_type": recurrence_type,
"recurrence_value": recurrence_value,
"start_time": start_time_str,
"end_time": end_time_str
}),
"scaling_policy_type":
type_,
"scaling_group_id":
as_group_id
})
return self._create("/scaling_policy", json=json)
def test_remove_empty_from_dict(self):
d = dict(k1=None, k2='', k3='abc')
self.assertEqual({'k3': 'abc'}, utils.remove_empty_from_dict(d))