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))