def requires_bootstrap(deployment_config):
try:
Deployment.get(name=deployment_config.name,
namespace=deployment_config.namespace)
return False
except NotFound:
return True
except Exception as e:
LOG.warning(e, exc_info=True)
def delete(self, app_spec):
LOG.info("Deleting deployment for %s", app_spec.name)
try:
body = {
"kind": "DeleteOptions",
"apiVersion": "v1",
"propagationPolicy": "Foreground"
}
Deployment.delete(app_spec.name, app_spec.namespace, body=body)
except NotFound:
pass
def _create_default_deployment():
labels = {"test": "true"}
object_meta = ObjectMeta(name=NAME, namespace=NAMESPACE, labels=labels)
container_port = ContainerPort(name="http5000", containerPort=5000)
http = HTTPGetAction(path="/", port="http5000")
liveness = Probe(httpGet=http)
tcp = TCPSocketAction(port=5000)
readiness = Probe(tcpSocket=tcp)
container = Container(name="container",
image="dummy_image",
ports=[container_port],
livenessProbe=liveness,
readinessProbe=readiness)
image_pull_secret = LocalObjectReference(name="image_pull_secret")
pod_spec = PodSpec(containers=[container],
imagePullSecrets=[image_pull_secret],
serviceAccountName="default")
pod_template_spec = PodTemplateSpec(metadata=object_meta, spec=pod_spec)
deployer_spec = DeploymentSpec(replicas=2,
selector=LabelSelector(matchLabels=labels),
template=pod_template_spec,
revisionHistoryLimit=5)
deployment = Deployment(metadata=object_meta, spec=deployer_spec)
return deployment
def _ready(self):
try:
dep = Deployment.get(self._app_spec.name, self._app_spec.namespace)
except NotFound:
return False
return (dep.status.updatedReplicas >= dep.spec.replicas
and dep.status.availableReplicas >= dep.spec.replicas)
def _get_status(self, namespace=None):
deployment_configs = self._cluster.find_deployment_configs(
NAME, namespace=namespace)
deployments = {
d.metadata.namespace: d
for d in Deployment.find(NAME, namespace=namespace)
}
applications = {
d.metadata.namespace: d
for d in self._application.find(NAME, namespace=namespace)
}
res = []
for c in deployment_configs:
dep = deployments.get(c.namespace)
app = applications.get(c.namespace)
version = _get_version(dep)
status = _get_status(dep, app)
res.append(
DeploymentStatus(name=NAME,
namespace=c.namespace,
status=status.summary,
description=status.description,
version=version or '',
channel=c.tag or ''))
return res
def deployment():
main_container = Container(
env=[EnvVar(name=CANARY_NAME, value=CANARY_VALUE)])
pod_spec = PodSpec(containers=[main_container])
pod_metadata = ObjectMeta(annotations={CANARY_NAME: CANARY_VALUE})
pod_template_spec = PodTemplateSpec(spec=pod_spec, metadata=pod_metadata)
deployment_spec = DeploymentSpec(template=pod_template_spec)
return Deployment(spec=deployment_spec)
def _create_deployment(available_replicas, namespace, image):
container = Container(image=image)
pod_spec = PodSpec(containers=[container])
pod_template_spec = PodTemplateSpec(spec=pod_spec)
spec = DeploymentSpec(replicas=1, template=pod_template_spec)
status = DeploymentStatus(availableReplicas=available_replicas)
metadata = ObjectMeta(name=NAME, namespace=namespace)
return Deployment(metadata=metadata, spec=spec, status=status)
def _ready(self):
try:
dep = Deployment.get(self._app_spec.name, self._app_spec.namespace)
except NotFound:
return False
return (dep.status.updatedReplicas == dep.spec.replicas
and dep.status.replicas == dep.spec.replicas
and dep.status.availableReplicas == dep.spec.replicas
and dep.status.observedGeneration >= dep.metadata.generation)
def action():
for kind in kinds:
assert kind.get(name)
dep = Deployment.get(name)
assert dep.spec.template.spec.containers[0].image == image
svc = Service.get(name)
assert svc.spec.type == service_type
for kind, expected_dict in expected.items():
actual = kind.get(name)
assert_k8s_resource_matches(actual, expected_dict, image, service_type, deployment_id, strongbox_groups)
def test_updated_if_exists(self, get, put):
mock_response = _create_mock_response()
get.return_value = mock_response
deployment = _create_default_deployment()
from_api = Deployment.get_or_create(metadata=deployment.metadata, spec=deployment.spec)
assert not from_api._new
assert from_api.spec.replicas == 2
call_params = from_api.as_dict()
from_api.save()
pytest.helpers.assert_any_call(put, _uri(NAMESPACE, NAME), call_params)
def deployment(self):
main_container = Container(env=[EnvVar(name="DUMMY", value="CANARY")])
pod_spec = PodSpec(containers=[main_container])
pod_template_spec = PodTemplateSpec(spec=pod_spec)
deployment_spec = DeploymentSpec(template=pod_template_spec)
return Deployment(spec=deployment_spec)
def deployment(self):
metadata = ObjectMeta(annotations={"dummy": "annotations"})
pod_template_spec = PodTemplateSpec(metadata=metadata)
deployment_spec = DeploymentSpec(template=pod_template_spec)
return Deployment(spec=deployment_spec)
def deploy(self, app_spec, selector, labels, besteffort_qos_is_required):
LOG.info("Creating new deployment for %s", app_spec.name)
deployment_labels = merge_dicts(app_spec.labels.deployment, labels)
metadata = ObjectMeta(name=app_spec.name,
namespace=app_spec.namespace,
labels=deployment_labels,
annotations=app_spec.annotations.deployment)
container_ports = [
ContainerPort(name=port_spec.name,
containerPort=port_spec.target_port)
for port_spec in app_spec.ports
]
env = self._make_env(app_spec)
pull_policy = "IfNotPresent" if (":" in app_spec.image and ":latest"
not in app_spec.image) else "Always"
env_from = [
EnvFromSource(configMapRef=ConfigMapEnvSource(name=app_spec.name,
optional=True))
]
containers = [
Container(
name=app_spec.name,
image=app_spec.image,
ports=container_ports,
env=env,
envFrom=env_from,
lifecycle=self._lifecycle,
livenessProbe=_make_probe(app_spec.health_checks.liveness),
readinessProbe=_make_probe(app_spec.health_checks.readiness),
imagePullPolicy=pull_policy,
volumeMounts=self._make_volume_mounts(app_spec),
resources=_make_resource_requirements(app_spec.resources))
]
automount_service_account_token = app_spec.admin_access
init_containers = []
service_account_name = "default"
pod_spec = PodSpec(
containers=containers,
initContainers=init_containers,
volumes=self._make_volumes(app_spec),
serviceAccountName=service_account_name,
automountServiceAccountToken=automount_service_account_token,
terminationGracePeriodSeconds=self._grace_period)
pod_labels = merge_dicts(app_spec.labels.pod,
_add_status_label(labels))
pod_metadata = ObjectMeta(name=app_spec.name,
namespace=app_spec.namespace,
labels=pod_labels,
annotations=app_spec.annotations.pod)
pod_template_spec = PodTemplateSpec(metadata=pod_metadata,
spec=pod_spec)
replicas = app_spec.replicas
# we must avoid that the deployment scales up to app_spec.replicas if autoscaler has set another value
if should_have_autoscaler(app_spec):
try:
deployment = Deployment.get(app_spec.name, app_spec.namespace)
replicas = deployment.spec.replicas
except NotFound:
pass
deployment_strategy = DeploymentStrategy(
rollingUpdate=RollingUpdateDeployment(
maxUnavailable=self._max_unavailable,
maxSurge=self._max_surge))
if app_spec.replicas == 1 and app_spec.singleton:
deployment_strategy = DeploymentStrategy(
rollingUpdate=RollingUpdateDeployment(maxUnavailable=1,
maxSurge=0))
spec = DeploymentSpec(replicas=replicas,
selector=LabelSelector(matchLabels=selector),
template=pod_template_spec,
revisionHistoryLimit=5,
strategy=deployment_strategy)
deployment = Deployment.get_or_create(metadata=metadata, spec=spec)
_clear_pod_init_container_annotations(deployment)
self._datadog.apply(deployment, app_spec, besteffort_qos_is_required)
self._prometheus.apply(deployment, app_spec)
self._secrets.apply(deployment, app_spec)
deployment.save()
def test_delete(self, delete):
Deployment.delete(NAME, namespace=NAMESPACE)
pytest.helpers.assert_any_call(delete, _uri(NAMESPACE, NAME))
def test_create_blank_deployment(self):
object_meta = ObjectMeta(name=NAME, namespace=NAMESPACE)
deployment = Deployment(metadata=object_meta)
assert deployment.as_dict()[u"metadata"][u"name"] == NAME
def deployment(self):
with mock.patch("k8s.models.deployment.Deployment.get") as m:
deployment = mock.create_autospec(Deployment(), spec_set=True)
deployment.spec.replicas.return_value = REPLICAS
m.return_value = deployment
return deployment