def map_context(self, context: TemplateContext) -> TemplateContext:
if self._is_ambassador(context):
context.append_templates([{
'apiVersion':
'getambassador.io/v1',
'kind':
'Mapping',
'metadata': {
'name': self.name + '-mapping'
},
'spec':
nmap({
'prefix':
'/',
'service':
self.service + str(
M.map(self.port, (lambda x: ':' + str(x)))
| M.value_or_default | '')
}).append_if_value(
'host',
M.nothing()
if self.host == '*' else M.just(self.host)).to_map()
}])
return context
if self._is_istio(context):
context.append_templates([{
'apiVersion': 'networking.istio.io/v1alpha3',
'kind': 'VirtualService',
'metadata': {
'name': self.name + '-vs'
},
'spec': {
'hosts': [self.host],
'gateways': [self.gateway_name],
'http':
nlist([
nmap({
'route': [{
'destination':
nmap({
'host': self.service
}).append_if_value(
'port',
M.map(self.port, (lambda x: {
'number': x
}))).to_map()
}]
}).to_map(),
]).to_list()
}
}])
return context
raise AssertionError('Unsupported gateway')
def _get_templates(name: str, image: str,
schedule: str, suspend: bool, env_vars: List[str],
command: M.Maybe[List[str]]) -> List[dict]:
return nlist([
{
'kind': 'CronJob',
'apiVersion': 'batch/v1beta1',
'metadata': {'name': name},
'spec': {
'suspend': suspend,
'concurrencyPolicy': 'Forbid',
'schedule': schedule,
'jobTemplate': {'spec': {
'template': {
'metadata': {
'annotations': {
'traffic.sidecar.istio.io/excludeOutboundIPRanges': "0.0.0.0/0",
"sidecar.istio.io/inject": "false"}
},
'spec': {
'containers': nlist([
nmap({
'name': name,
'image': image,
'env': env_vars
}).append_if_value(
'command', command).to_map()
]).to_list(),
'volumes': nlist([]).to_list(),
'restartPolicy': 'Never'
}
},
'backoffLimit': 0
}},
}
}
]).to_list()
def map_context(self, context: TemplateContext) -> TemplateContext:
if context.get_state('cluster_name') is not None:
self.with_environment_variable('CLUSTER',
context.get_state('cluster_name'))
templates = nlist([{
'kind': 'Service',
'apiVersion': 'v1',
'metadata': {
'name': self.name
},
'spec': {
'type':
self.service_type,
'selector': {
'app': _app_name(self.name)
},
'ports': [{
'protocol': 'TCP',
'port': self.service_port,
'targetPort': self.app_port
}]
}
}, {
'apiVersion': 'apps/v1',
'kind': 'Deployment',
'metadata': {
'name': _deployment_name(self.name),
'labels': {
'app': _app_name(self.name)
},
},
'spec': {
'replicas': self.min_replicas,
'strategy': self.strategy,
'selector': {
'matchLabels': {
'app': _app_name(self.name)
}
},
'template': {
'metadata': {
'annotations': self.annotations,
'labels': {
'app': _app_name(self.name)
}
},
'spec':
nmap({
'containers':
nlist([
nmap({
'name':
_app_name(self.name),
'image':
self.image,
'ports': [{
'containerPort': self.app_port
}],
'env':
self.environment_vars,
'volumeMounts':
list(map(lambda x: x['mount'], self.volumes))
}).append_if_value('command',
self.command).append_if_value(
'resources',
self.resources).to_map()
]).append_all(
list(
map(lambda x: x.get_template(context),
self.sidecars))).to_list(),
'volumes':
list(map(lambda x: x['volume'], self.volumes))
}).append_if_value('initContainers',
self.init_containers).to_map()
}
}
}, {
'apiVersion': 'autoscaling/v1',
'kind': 'HorizontalPodAutoscaler',
'metadata': {
'name': _horizontal_pod_autoscaler_name(self.name)
},
'spec': {
'scaleTargetRef': {
'apiVersion': 'apps/v1',
'kind': 'Deployment',
'name': _deployment_name(self.name)
},
'minReplicas': self.min_replicas,
'maxReplicas': self.max_replicas,
'targetCPUUtilizationPercentage': self.cpu_threshold_percentage
}
}]).to_list()
context.append_templates(templates)
return context
def test_will_ignore_append_list_if_nothing():
assert nlist([1]).append_if_value(M.nothing()) == [1]
def test_will_append_to_list_if_value():
assert nlist([1]).append_if_value(M.just(2)) == [1, 2]
def test_can_convert_to_base_list_type():
a_list = nlist([1, 2]).to_list()
assert a_list == [1, 2]
assert type(a_list) == list
def test_will_append_item():
assert nlist([1, 2]).append(3) == [1, 2, 3]
def test_will_ignore_list_if_nothing():
assert nlist([1, 2]).append_if_list(M.nothing()) == [1, 2]
def test_will_concat_list_if_value():
assert nlist([1, 2]).append_if_list(M.just([3, 4])) == [1, 2, 3, 4]