Esempio n. 1
0
def kubernetes_instance_status(
    instance_status: Mapping[str, Any],
    service: str,
    instance: str,
    verbose: bool,
) -> Mapping[str, Any]:
    kstatus: Dict[str, Any] = {}
    job_config = kubernetes_tools.load_kubernetes_service_config(
        service,
        instance,
        settings.cluster,
        soa_dir=settings.soa_dir,
    )
    client = settings.kubernetes_client
    if client is not None:
        # bouncing status can be inferred from app_count, ref get_bouncing_status
        pod_list = kubernetes_tools.pods_for_service_instance(
            job_config.service, job_config.instance, client)
        active_shas = kubernetes_tools.get_active_shas_for_service(pod_list)
        kstatus['app_count'] = max(
            len(active_shas['config_sha']),
            len(active_shas['git_sha']),
        )
        kstatus['desired_state'] = job_config.get_desired_state()
        kstatus['bounce_method'] = kubernetes_tools.KUBE_DEPLOY_STATEGY_REVMAP[
            job_config.get_bounce_method()]
        kubernetes_job_status(kstatus=kstatus,
                              client=client,
                              job_config=job_config,
                              verbose=verbose,
                              pod_list=pod_list)
    return kstatus
Esempio n. 2
0
def bounce_status(
    service: str,
    instance: str,
    settings: Any,
):
    status: Dict[str, Any] = {}
    job_config = kubernetes_tools.load_kubernetes_service_config(
        service=service,
        instance=instance,
        cluster=settings.cluster,
        soa_dir=settings.soa_dir,
        load_deployments=True,
    )
    expected_instance_count = job_config.get_instances()
    status["expected_instance_count"] = expected_instance_count
    desired_state = job_config.get_desired_state()
    status["desired_state"] = desired_state

    kube_client = settings.kubernetes_client
    if kube_client is None:
        raise RuntimeError("Could not load Kubernetes client!")

    app = kubernetes_tools.get_kubernetes_app_by_name(
        name=job_config.get_sanitised_deployment_name(),
        kube_client=kube_client,
        namespace=job_config.get_kubernetes_namespace(),
    )
    status["running_instance_count"] = (app.status.ready_replicas
                                        if app.status.ready_replicas else 0)

    deploy_status, message = kubernetes_tools.get_kubernetes_app_deploy_status(
        app=app,
        desired_instances=(expected_instance_count
                           if desired_state != "stop" else 0),
    )
    status["deploy_status"] = kubernetes_tools.KubernetesDeployStatus.tostring(
        deploy_status)

    if job_config.get_persistent_volumes():
        version_objects = kubernetes_tools.controller_revisions_for_service_instance(
            service=job_config.service,
            instance=job_config.instance,
            kube_client=kube_client,
            namespace=job_config.get_kubernetes_namespace(),
        )
    else:
        replicasets = kubernetes_tools.replicasets_for_service_instance(
            service=job_config.service,
            instance=job_config.instance,
            kube_client=kube_client,
            namespace=job_config.get_kubernetes_namespace(),
        )
        version_objects = filter_actually_running_replicasets(replicasets)

    active_shas = kubernetes_tools.get_active_shas_for_service(
        [app, *version_objects], )
    status["active_shas"] = list(active_shas)
    status["app_count"] = len(active_shas)
    return status
Esempio n. 3
0
def test_load_kubernetes_service_config():
    with mock.patch(
            'paasta_tools.kubernetes_tools.load_kubernetes_service_config_no_cache',
            autospec=True,
    ) as mock_load_kubernetes_service_config_no_cache:
        ret = load_kubernetes_service_config(
            service='kurupt',
            instance='fm',
            cluster='brentford',
            load_deployments=True,
            soa_dir='/nail/blah',
        )
        assert ret == mock_load_kubernetes_service_config_no_cache.return_value
Esempio n. 4
0
def kubernetes_instance_status(
    instance_status: Mapping[str, Any],
    service: str,
    instance: str,
    verbose: int,
    include_smartstack: bool,
) -> Mapping[str, Any]:
    kstatus: Dict[str, Any] = {}
    job_config = kubernetes_tools.load_kubernetes_service_config(
        service, instance, settings.cluster, soa_dir=settings.soa_dir)
    client = settings.kubernetes_client
    if client is not None:
        # bouncing status can be inferred from app_count, ref get_bouncing_status
        pod_list = kubernetes_tools.pods_for_service_instance(
            job_config.service, job_config.instance, client)
        replicaset_list = kubernetes_tools.replicasets_for_service_instance(
            job_config.service, job_config.instance, client)
        active_shas = kubernetes_tools.get_active_shas_for_service(pod_list)
        kstatus["app_count"] = max(len(active_shas["config_sha"]),
                                   len(active_shas["git_sha"]))
        kstatus["desired_state"] = job_config.get_desired_state()
        kstatus["bounce_method"] = kubernetes_tools.KUBE_DEPLOY_STATEGY_REVMAP[
            job_config.get_bounce_method()]
        kubernetes_job_status(
            kstatus=kstatus,
            client=client,
            job_config=job_config,
            verbose=verbose,
            pod_list=pod_list,
            replicaset_list=replicaset_list,
        )

        if include_smartstack:
            service_namespace_config = kubernetes_tools.load_service_namespace_config(
                service=service,
                namespace=job_config.get_nerve_namespace(),
                soa_dir=settings.soa_dir,
            )
            if "proxy_port" in service_namespace_config:
                kstatus["smartstack"] = kubernetes_smartstack_status(
                    service,
                    instance,
                    job_config,
                    service_namespace_config,
                    pod_list,
                    should_return_individual_backends=verbose > 0,
                )
    return kstatus
Esempio n. 5
0
def get_instance_configs_for_service(
    service: str,
    soa_dir: str,
    type_filter: Optional[Sequence[str]] = None,
) -> Iterable[InstanceConfig]:
    for cluster in list_clusters(
            service=service,
            soa_dir=soa_dir,
    ):
        if type_filter is None:
            type_filter = ['marathon', 'chronos', 'adhoc', 'kubernetes']
        if 'marathon' in type_filter:
            for _, instance in get_service_instance_list(
                    service=service,
                    cluster=cluster,
                    instance_type='marathon',
                    soa_dir=soa_dir,
            ):
                yield load_marathon_service_config(
                    service=service,
                    instance=instance,
                    cluster=cluster,
                    soa_dir=soa_dir,
                    load_deployments=False,
                )
        if 'chronos' in type_filter:
            for _, instance in get_service_instance_list(
                    service=service,
                    cluster=cluster,
                    instance_type='chronos',
                    soa_dir=soa_dir,
            ):
                yield load_chronos_job_config(
                    service=service,
                    instance=instance,
                    cluster=cluster,
                    soa_dir=soa_dir,
                    load_deployments=False,
                )
        if 'adhoc' in type_filter:
            for _, instance in get_service_instance_list(
                    service=service,
                    cluster=cluster,
                    instance_type='adhoc',
                    soa_dir=soa_dir,
            ):
                yield load_adhoc_job_config(
                    service=service,
                    instance=instance,
                    cluster=cluster,
                    soa_dir=soa_dir,
                    load_deployments=False,
                )
        if 'kubernetes' in type_filter:
            for _, instance in get_service_instance_list(
                    service=service,
                    cluster=cluster,
                    instance_type='kubernetes',
                    soa_dir=soa_dir,
            ):
                yield load_kubernetes_service_config(
                    service=service,
                    instance=instance,
                    cluster=cluster,
                    soa_dir=soa_dir,
                    load_deployments=False,
                )