def get_waiter(self, waiter_name):
config = self._get_waiter_config()
if not config:
raise ValueError("Waiter does not exist: %s" % waiter_name)
model = waiter.WaiterModel(config)
mapping = {}
for name in model.waiter_names:
mapping[xform_name(name)] = name
if waiter_name not in mapping:
raise ValueError("Waiter does not exist: %s" % waiter_name)
return waiter.create_waiter_with_client(
mapping[waiter_name], model, self)
def get(self, name):
"""
:type name: str
:param name: The name of the waiter
:rtype: botocore.waiter.Waiter
:return: The waiter object.
"""
if not self.__has(name):
config = self.model_configs.get(name)
model = waiter.WaiterModel(config.get('model'))
client = self.clients.get(config.get('client'))
self.__create(name, model, client)
return self.waiters.get(name)
def get_waiter(self, waiter_name):
"""Returns an object that can wait for some condition.
:type waiter_name: str
:param waiter_name: The name of the waiter to get. See the waiters
section of the service docs for a list of available waiters.
:returns: The specified waiter object.
:rtype: botocore.waiter.Waiter
"""
config = self._get_waiter_config()
if not config:
raise ValueError("Waiter does not exist: %s" % waiter_name)
model = waiter.WaiterModel(config)
mapping = {}
for name in model.waiter_names:
mapping[xform_name(name)] = name
if waiter_name not in mapping:
raise ValueError("Waiter does not exist: %s" % waiter_name)
return waiter.create_waiter_with_client(mapping[waiter_name], model,
self)
def get_dynamodb_scan_count_is(self, size):
"""
:type size: int or str
:param size: The number of expected scan items to find
:rtype: botocore.waiter.Waiter
:return: The waiter object.
"""
name = "ScanCountIs" + str(size)
if not self.__has(name):
model = waiter.WaiterModel({
"version": 2,
"waiters": {
name: {
"delay":
15,
"operation":
"Scan",
"maxAttempts":
40,
"acceptors": [{
"expected":
True,
"matcher":
"path",
"state":
"success",
"argument":
"length(Items[]) == "
f"`{size}`"
}]
}
}
})
self.__create(name, model, self.clients.get('dynamodb'))
return self.get(name)
def get_waiter_model(self, service_name, api_version=None):
loader = self.get_component('data_loader')
waiter_config = loader.load_service_model(service_name, 'waiters-2',
api_version)
return waiter.WaiterModel(waiter_config)
def model_for(name):
ec2_models = core_waiter.WaiterModel(waiter_config=ec2_data)
return ec2_models.get_waiter(name)
def route53_model(name):
route53_models = core_waiter.WaiterModel(waiter_config=_inject_limit_retries(route53_data))
return route53_models.get_waiter(name)
def elb_model(name):
elb_models = core_waiter.WaiterModel(waiter_config=_inject_limit_retries(elb_data))
return elb_models.get_waiter(name)
def waf_model(name):
waf_models = core_waiter.WaiterModel(waiter_config=_inject_limit_retries(waf_data))
return waf_models.get_waiter(name)
from botocore import waiter
import jmespath
ecs_model = waiter.WaiterModel({
'version': 2,
'waiters': {
'ServiceDrained': {
'operation': 'DescribeServices',
'delay': 6,
'maxAttempts': 150,
'acceptors': [
{
'expected': 0,
'matcher': 'pathAll',
'state': 'success',
'argument': 'services[].runningCount',
},
]
}
}
})
class Cluster:
def __init__(self, cluster, scheduler, worker, web, client):
self.name = cluster
self.scheduler = scheduler
self.worker = worker
self.web = web
self.ecs = client
def rds_model(name):
rds_models = core_waiter.WaiterModel(waiter_config=rds_data)
return rds_models.get_waiter(name)
def eks_model(name):
eks_models = core_waiter.WaiterModel(waiter_config=eks_data)
return eks_models.get_waiter(name)
def waf_model(name):
waf_models = core_waiter.WaiterModel(waiter_config=waf_data)
return waf_models.get_waiter(name)
def get_autoscaling_complete_for(self, instance_id, is_launching):
"""
:rtype: botocore.waiter.Waiter
:return: The waiter object.
"""
if is_launching:
desc = "Launching a new EC2 instance: " + instance_id
name = "AutoscalingCompleteForLaunching" + instance_id
else:
desc = "Terminating EC2 instance: " + instance_id
name = "AutoscalingCompleteForTerminating" + instance_id
if not self.__has(name):
model = waiter.WaiterModel({
"version": 2,
"waiters": {
name: {
"delay":
20,
"operation":
"DescribeScalingActivities",
"maxAttempts":
6,
"acceptors": [{
"expected":
True,
"matcher":
"path",
"state":
"failure",
"argument":
"length(Activities[?contains(Description, '"
f"{desc}"
"')]) < `1`"
}, {
"expected":
True,
"matcher":
"path",
"state":
"retry",
"argument":
"Activities[?contains(Description, '"
f"{desc}"
"')] | [0].Progress < `100`"
}, {
"expected":
True,
"matcher":
"path",
"state":
"success",
"argument":
"Activities[?contains(Description, '"
f"{desc}"
"')] | [0].Progress == `100`"
}]
}
}
})
self.__create(name, model, self.clients.get('autoscaling'))
return self.get(name)
