paasta-tools 1.21.3__py3-none-any.whl

paasta_tools/paasta_execute_docker_command.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+# Copyright 2015-2016 Yelp Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Usage: ./paasta_execute_docker_command.py [options]
+
+This script will attempt to find a running container that contains an environment variable matching
+the specified Mesos task ID and then execute the given command with the specified timeout. The script will
+print the output of the command and exit with the same return code as the command.
+
+Command line options:
+
+- -i <MESOS_TASK_ID>, --mesos-id <MESOS_TASK_ID>: Specify a Mesos task ID to search for
+- -c <command>, --cmd <command>: Shell command to execute in container
+- -t <timeout>, --timeout <timeout>: Timeout for command
+"""
+import argparse
+import signal
+import sys
+from contextlib import contextmanager
+
+from paasta_tools.mesos_tools import get_container_id_for_mesos_id
+from paasta_tools.utils import get_docker_client
+from paasta_tools.utils import is_using_unprivileged_containers
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Executes given command in Docker container for given Mesos task ID"
+    )
+    parser.add_argument("-i", "--mesos-id", required=True, help="Mesos task ID")
+    parser.add_argument(
+        "-c", "--cmd", required=True, help="command to execute in container"
+    )
+    parser.add_argument(
+        "-t", "--timeout", default=45, type=int, help="timeout for command"
+    )
+    args = parser.parse_args()
+    return args
+
+
+class TimeoutException(Exception):
+    pass
+
+
+@contextmanager
+def time_limit(seconds):  # From http://stackoverflow.com/a/601168/1576438
+    def signal_handler(signum, frame):
+        raise TimeoutException("Timed out!")
+
+    signal.signal(signal.SIGALRM, signal_handler)
+    signal.alarm(seconds)
+    try:
+        yield
+    finally:
+        signal.alarm(0)
+
+
+def execute_in_container(docker_client, container_id, cmd, timeout):
+    container_info = docker_client.inspect_container(container_id)
+    if (
+        container_info["ExecIDs"]
+        and len(container_info["ExecIDs"]) > 0
+        and not is_using_unprivileged_containers()
+    ):
+        for possible_exec_id in container_info["ExecIDs"]:
+            exec_info = docker_client.exec_inspect(possible_exec_id)["ProcessConfig"]
+            if exec_info["entrypoint"] == "/bin/sh" and exec_info["arguments"] == [
+                "-c",
+                cmd,
+            ]:
+                exec_id = possible_exec_id
+                break
+    else:
+        exec_id = docker_client.exec_create(container_id, ["/bin/sh", "-c", cmd])["Id"]
+    output = docker_client.exec_start(exec_id, stream=False)
+    return_code = docker_client.exec_inspect(exec_id)["ExitCode"]
+    return (output, return_code)
+
+
+def main():
+    args = parse_args()
+
+    if not args.mesos_id:
+        print(
+            "The Mesos task id you supplied seems to be an empty string! Please provide a valid task id."
+        )
+        sys.exit(2)
+
+    docker_client = get_docker_client()
+
+    container_id = get_container_id_for_mesos_id(docker_client, args.mesos_id)
+
+    if container_id:
+        try:
+            with time_limit(args.timeout):
+                output, return_code = execute_in_container(
+                    docker_client, container_id, args.cmd, args.timeout
+                )
+            print(output)
+        except TimeoutException:
+            print("Command timed out!")
+            return_code = 1
+        finally:
+            sys.exit(return_code)
+    else:
+        print("Could not find container with MESOS_TASK_ID '%s'." % args.mesos_id)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

paasta_tools/paasta_native_serviceinit.py

@@ -0,0 +1,21 @@
+from paasta_tools.frameworks.native_scheduler import MESOS_TASK_SPACER
+from paasta_tools.mesos_tools import status_mesos_tasks_verbose
+from paasta_tools.utils import calculate_tail_lines
+from paasta_tools.utils import compose_job_id
+
+
+def perform_command(command, service, instance, cluster, verbose, soa_dir):
+    tail_lines = calculate_tail_lines(verbose_level=verbose)
+
+    # We have to add a spacer at the end to make sure we only return
+    # things for service.main and not service.main_foo
+    task_id_prefix = "{}{}".format(compose_job_id(service, instance), MESOS_TASK_SPACER)
+
+    if command == "status":
+        print(
+            status_mesos_tasks_verbose(
+                job_id=task_id_prefix,
+                get_short_task_id=lambda x: x,
+                tail_lines=tail_lines,
+            )
+        )

paasta_tools/paasta_service_config_loader.py

@@ -0,0 +1,201 @@
+# Copyright 2015-2017 Yelp Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import logging
+from typing import Dict
+from typing import Iterable
+from typing import List
+from typing import Tuple
+from typing import Type
+
+from service_configuration_lib import read_service_configuration
+
+from paasta_tools import utils
+from paasta_tools.utils import deep_merge_dictionaries
+from paasta_tools.utils import DEFAULT_SOA_DIR
+from paasta_tools.utils import InstanceConfig_T
+from paasta_tools.utils import list_clusters
+from paasta_tools.utils import load_service_instance_configs
+from paasta_tools.utils import load_v2_deployments_json
+from paasta_tools.utils import NoDeploymentsAvailable
+
+
+log = logging.getLogger(__name__)
+log.addHandler(logging.NullHandler())
+
+
+class PaastaServiceConfigLoader:
+    """PaastaServiceConfigLoader provides useful methods for reading soa-configs and
+    iterating instance names or InstanceConfigs objects.
+
+    :Example:
+
+    >>> from paasta_tools.paasta_service_config_loader import PaastaServiceConfigLoader
+    >>> from paasta_tools.utils import DEFAULT_SOA_DIR
+    >>>
+    >>> sc = PaastaServiceConfigLoader(service='fake_service', soa_dir=DEFAULT_SOA_DIR)
+    >>>
+    >>> for instance in sc.instances(cluster='fake_cluster', instance_type_class=KubernetesDeploymentConfig):
+    ...     print(instance)
+    ...
+    main
+    canary
+    >>>
+    >>> for instance_config in sc.instance_configs(cluster='fake_cluster', instance_type_class=KubernetesDeploymentConfig):
+    ...     print(instance_config.get_instance())
+    ...
+    main
+    canary
+    >>>
+    """
+
+    _framework_configs: Dict[Tuple[str, type], Dict[str, utils.InstanceConfigDict]]
+    _clusters: List[str]
+    _deployments_json: utils.DeploymentsJsonV2
+
+    def __init__(
+        self,
+        service: str,
+        soa_dir: str = DEFAULT_SOA_DIR,
+        load_deployments: bool = True,
+    ) -> None:
+        self._service = service
+        self._soa_dir = soa_dir
+        self._load_deployments = load_deployments
+        self._clusters = None
+        self._general_config = None
+        self._deployments_json = None
+        self._framework_configs = {}
+
+    @property
+    def clusters(self) -> Iterable[str]:
+        """Returns an iterator that yields cluster names for the service.
+
+        :returns: iterator that yields cluster names.
+        """
+        if self._clusters is None:
+            self._clusters = list_clusters(service=self._service, soa_dir=self._soa_dir)
+        for cluster in self._clusters:
+            yield cluster
+
+    def instances(
+        self, cluster: str, instance_type_class: Type[InstanceConfig_T]
+    ) -> Iterable[str]:
+        """Returns an iterator that yields instance names as strings.
+
+        :param cluster: The cluster name
+        :param instance_type_class: a subclass of InstanceConfig
+        :returns: an iterator that yields instance names
+        """
+        if (cluster, instance_type_class) not in self._framework_configs:
+            self._refresh_framework_config(cluster, instance_type_class)
+        for instance in self._framework_configs.get((cluster, instance_type_class), []):
+            yield instance
+
+    def instance_configs(
+        self, cluster: str, instance_type_class: Type[InstanceConfig_T]
+    ) -> Iterable[InstanceConfig_T]:
+        """Returns an iterator that yields InstanceConfig objects.
+
+        :param cluster: The cluster name
+        :param instance_type_class: a subclass of InstanceConfig
+        :returns: an iterator that yields instances of KubernetesDeploymentConfig, etc.
+        :raises NotImplementedError: when it doesn't know how to create a config for instance_type_class
+        """
+        if (cluster, instance_type_class) not in self._framework_configs:
+            self._refresh_framework_config(cluster, instance_type_class)
+        for instance, config in self._framework_configs.get(
+            (cluster, instance_type_class), {}
+        ).items():
+            try:
+                yield self._create_service_config(
+                    cluster, instance, config, instance_type_class
+                )
+            except NoDeploymentsAvailable:
+                pass
+
+    def _framework_config_filename(
+        self, cluster: str, instance_type_class: Type[InstanceConfig_T]
+    ):
+        return f"{instance_type_class.config_filename_prefix}-{cluster}"
+
+    def _refresh_framework_config(
+        self, cluster: str, instance_type_class: Type[InstanceConfig_T]
+    ):
+        instances = load_service_instance_configs(
+            service=self._service,
+            instance_type=instance_type_class.config_filename_prefix,
+            cluster=cluster,
+            soa_dir=self._soa_dir,
+        )
+        self._framework_configs[(cluster, instance_type_class)] = instances
+
+    def _get_branch_dict(
+        self, cluster: str, instance: str, config: utils.InstanceConfig
+    ) -> utils.BranchDictV2:
+        if self._deployments_json is None:
+            self._deployments_json = load_v2_deployments_json(
+                self._service, soa_dir=self._soa_dir
+            )
+
+        branch = config.get_branch()
+        deploy_group = config.get_deploy_group()
+        return self._deployments_json.get_branch_dict(
+            self._service, branch, deploy_group
+        )
+
+    def _get_merged_config(
+        self, config: utils.InstanceConfigDict
+    ) -> utils.InstanceConfigDict:
+        if self._general_config is None:
+            self._general_config = read_service_configuration(
+                service_name=self._service, soa_dir=self._soa_dir
+            )
+        return deep_merge_dictionaries(overrides=config, defaults=self._general_config)
+
+    def _create_service_config(
+        self,
+        cluster: str,
+        instance: str,
+        config: utils.InstanceConfigDict,
+        config_class: Type[InstanceConfig_T],
+    ) -> InstanceConfig_T:
+        """Create a service instance's configuration for kubernetes.
+
+        :param cluster: The cluster to read the configuration for
+        :param instance: The instance of the service to retrieve
+        :param config: the framework instance config.
+        :returns: An instance of config_class
+        """
+
+        merged_config = self._get_merged_config(config)
+
+        temp_instance_config = config_class(
+            service=self._service,
+            cluster=cluster,
+            instance=instance,
+            config_dict=merged_config,
+            branch_dict=None,
+            soa_dir=self._soa_dir,
+        )
+
+        branch_dict = self._get_branch_dict(cluster, instance, temp_instance_config)
+
+        return config_class(
+            service=self._service,
+            cluster=cluster,
+            instance=instance,
+            config_dict=merged_config,
+            branch_dict=branch_dict,
+            soa_dir=self._soa_dir,
+        )

paasta_tools/paastaapi/__init__.py

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+    Paasta API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501
+
+    The version of the OpenAPI document: 1.2.0
+    Generated by: https://openapi-generator.tech
+"""
+
+
+__version__ = "1.0.0"
+
+# import ApiClient
+from paasta_tools.paastaapi.api_client import ApiClient
+
+# import Configuration
+from paasta_tools.paastaapi.configuration import Configuration
+
+# import exceptions
+from paasta_tools.paastaapi.exceptions import OpenApiException
+from paasta_tools.paastaapi.exceptions import ApiAttributeError
+from paasta_tools.paastaapi.exceptions import ApiTypeError
+from paasta_tools.paastaapi.exceptions import ApiValueError
+from paasta_tools.paastaapi.exceptions import ApiKeyError
+from paasta_tools.paastaapi.exceptions import ApiException

paasta_tools/paastaapi/api/__init__.py

@@ -0,0 +1,3 @@
+# do not import all apis into this module because that uses a lot of memory and stack frames
+# if you need the ability to import all apis from one package, import them with
+# from paasta_tools.paastaapi.apis import AutoscalerApi

paasta_tools/paastaapi/api/autoscaler_api.py

@@ -0,0 +1,302 @@
+# coding: utf-8
+
+"""
+    Paasta API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501
+
+    The version of the OpenAPI document: 1.2.0
+    Generated by: https://openapi-generator.tech
+"""
+
+
+import re  # noqa: F401
+import sys  # noqa: F401
+
+from paasta_tools.paastaapi.api_client import ApiClient, Endpoint
+from paasta_tools.paastaapi.model_utils import (  # noqa: F401
+    check_allowed_values,
+    check_validations,
+    date,
+    datetime,
+    file_type,
+    none_type,
+    validate_and_convert_types
+)
+from paasta_tools.paastaapi.model.autoscaler_count_msg import AutoscalerCountMsg
+
+
+class AutoscalerApi(object):
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None):
+        if api_client is None:
+            api_client = ApiClient()
+        self.api_client = api_client
+
+        def __get_autoscaler_count(
+            self,
+            service,
+            instance,
+            **kwargs
+        ):
+            """Get status of service_name.instance_name  # noqa: E501
+
+            This method makes a synchronous HTTP request by default. To make an
+            asynchronous HTTP request, please pass async_req=True
+
+            >>> thread = api.get_autoscaler_count(service, instance, async_req=True)
+            >>> result = thread.get()
+
+            Args:
+                service (str): Service name
+                instance (str): Instance name
+
+            Keyword Args:
+                _return_http_data_only (bool): response data without head status
+                    code and headers. Default is True.
+                _preload_content (bool): if False, the urllib3.HTTPResponse object
+                    will be returned without reading/decoding response data.
+                    Default is True.
+                _request_timeout (float/tuple): timeout setting for this request. If one
+                    number provided, it will be total request timeout. It can also
+                    be a pair (tuple) of (connection, read) timeouts.
+                    Default is None.
+                _check_input_type (bool): specifies if type checking
+                    should be done one the data sent to the server.
+                    Default is True.
+                _check_return_type (bool): specifies if type checking
+                    should be done one the data received from the server.
+                    Default is True.
+                _host_index (int/None): specifies the index of the server
+                    that we want to use.
+                    Default is read from the configuration.
+                async_req (bool): execute request asynchronously
+
+            Returns:
+                AutoscalerCountMsg
+                    If the method is called asynchronously, returns the request
+                    thread.
+            """
+            kwargs['async_req'] = kwargs.get(
+                'async_req', False
+            )
+            kwargs['_return_http_data_only'] = kwargs.get(
+                '_return_http_data_only', True
+            )
+            kwargs['_preload_content'] = kwargs.get(
+                '_preload_content', True
+            )
+            kwargs['_request_timeout'] = kwargs.get(
+                '_request_timeout', None
+            )
+            kwargs['_check_input_type'] = kwargs.get(
+                '_check_input_type', True
+            )
+            kwargs['_check_return_type'] = kwargs.get(
+                '_check_return_type', True
+            )
+            kwargs['_host_index'] = kwargs.get('_host_index')
+            kwargs['service'] = \
+                service
+            kwargs['instance'] = \
+                instance
+            return self.call_with_http_info(**kwargs)
+
+        self.get_autoscaler_count = Endpoint(
+            settings={
+                'response_type': (AutoscalerCountMsg,),
+                'auth': [],
+                'endpoint_path': '/services/{service}/{instance}/autoscaler',
+                'operation_id': 'get_autoscaler_count',
+                'http_method': 'GET',
+                'servers': None,
+            },
+            params_map={
+                'all': [
+                    'service',
+                    'instance',
+                ],
+                'required': [
+                    'service',
+                    'instance',
+                ],
+                'nullable': [
+                ],
+                'enum': [
+                ],
+                'validation': [
+                ]
+            },
+            root_map={
+                'validations': {
+                },
+                'allowed_values': {
+                },
+                'openapi_types': {
+                    'service':
+                        (str,),
+                    'instance':
+                        (str,),
+                },
+                'attribute_map': {
+                    'service': 'service',
+                    'instance': 'instance',
+                },
+                'location_map': {
+                    'service': 'path',
+                    'instance': 'path',
+                },
+                'collection_format_map': {
+                }
+            },
+            headers_map={
+                'accept': [
+                    'application/json'
+                ],
+                'content_type': [],
+            },
+            api_client=api_client,
+            callable=__get_autoscaler_count
+        )
+
+        def __update_autoscaler_count(
+            self,
+            service,
+            instance,
+            autoscaler_count_msg,
+            **kwargs
+        ):
+            """Get status of service_name.instance_name  # noqa: E501
+
+            This method makes a synchronous HTTP request by default. To make an
+            asynchronous HTTP request, please pass async_req=True
+
+            >>> thread = api.update_autoscaler_count(service, instance, autoscaler_count_msg, async_req=True)
+            >>> result = thread.get()
+
+            Args:
+                service (str): Service name
+                instance (str): Instance name
+                autoscaler_count_msg (AutoscalerCountMsg):
+
+            Keyword Args:
+                _return_http_data_only (bool): response data without head status
+                    code and headers. Default is True.
+                _preload_content (bool): if False, the urllib3.HTTPResponse object
+                    will be returned without reading/decoding response data.
+                    Default is True.
+                _request_timeout (float/tuple): timeout setting for this request. If one
+                    number provided, it will be total request timeout. It can also
+                    be a pair (tuple) of (connection, read) timeouts.
+                    Default is None.
+                _check_input_type (bool): specifies if type checking
+                    should be done one the data sent to the server.
+                    Default is True.
+                _check_return_type (bool): specifies if type checking
+                    should be done one the data received from the server.
+                    Default is True.
+                _host_index (int/None): specifies the index of the server
+                    that we want to use.
+                    Default is read from the configuration.
+                async_req (bool): execute request asynchronously
+
+            Returns:
+                AutoscalerCountMsg
+                    If the method is called asynchronously, returns the request
+                    thread.
+            """
+            kwargs['async_req'] = kwargs.get(
+                'async_req', False
+            )
+            kwargs['_return_http_data_only'] = kwargs.get(
+                '_return_http_data_only', True
+            )
+            kwargs['_preload_content'] = kwargs.get(
+                '_preload_content', True
+            )
+            kwargs['_request_timeout'] = kwargs.get(
+                '_request_timeout', None
+            )
+            kwargs['_check_input_type'] = kwargs.get(
+                '_check_input_type', True
+            )
+            kwargs['_check_return_type'] = kwargs.get(
+                '_check_return_type', True
+            )
+            kwargs['_host_index'] = kwargs.get('_host_index')
+            kwargs['service'] = \
+                service
+            kwargs['instance'] = \
+                instance
+            kwargs['autoscaler_count_msg'] = \
+                autoscaler_count_msg
+            return self.call_with_http_info(**kwargs)
+
+        self.update_autoscaler_count = Endpoint(
+            settings={
+                'response_type': (AutoscalerCountMsg,),
+                'auth': [],
+                'endpoint_path': '/services/{service}/{instance}/autoscaler',
+                'operation_id': 'update_autoscaler_count',
+                'http_method': 'POST',
+                'servers': None,
+            },
+            params_map={
+                'all': [
+                    'service',
+                    'instance',
+                    'autoscaler_count_msg',
+                ],
+                'required': [
+                    'service',
+                    'instance',
+                    'autoscaler_count_msg',
+                ],
+                'nullable': [
+                ],
+                'enum': [
+                ],
+                'validation': [
+                ]
+            },
+            root_map={
+                'validations': {
+                },
+                'allowed_values': {
+                },
+                'openapi_types': {
+                    'service':
+                        (str,),
+                    'instance':
+                        (str,),
+                    'autoscaler_count_msg':
+                        (AutoscalerCountMsg,),
+                },
+                'attribute_map': {
+                    'service': 'service',
+                    'instance': 'instance',
+                },
+                'location_map': {
+                    'service': 'path',
+                    'instance': 'path',
+                    'autoscaler_count_msg': 'body',
+                },
+                'collection_format_map': {
+                }
+            },
+            headers_map={
+                'accept': [
+                    'application/json'
+                ],
+                'content_type': [
+                    'application/json'
+                ]
+            },
+            api_client=api_client,
+            callable=__update_autoscaler_count
+        )