#1120

pending completion

Build # #1120

Build Type

Pull #388

github-actions

Committed by

web-flow

Commit Message

<a href="https://github.com/tableau/TabPy/commit/<a class=hub.com/tableau/TabPy/commit/<a class="double-link" href="https://git"><a class=hub.com/tableau/TabPy/commit/<a class="double-link" href="https://git"><a class=hub.com/tableau/TabPy/commit/<a class="double-link" href="https://git"><a class=hub.com/tableau/TabPy/commit/af8b4bee0008150167b2b319995805b840e832a3">af8b4bee0">&lt;a href=&quot;https://github.com/tableau/TabPy/commit/</a><a class="double-link" href="https://github.com/tableau/TabPy/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tableau/TabPy/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tableau/TabPy/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tableau/TabPy/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tableau/TabPy/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tableau/TabPy/commit/af8b4bee0008150167b2b319995805b840e832a3">af8b4bee0</a><a href="https://github.com/tableau/TabPy/commit/af8b4bee0008150167b2b319995805b840e832a3">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tableau/TabPy/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tableau/TabPy/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tableau/TabPy/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tableau/TabPy/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tableau/TabPy/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tableau/TabPy/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tableau/TabPy/commit/af8b4bee0008150167b2b319995805b840e832a3&quot;&gt;af8b4bee0&lt;/a&gt;&lt;a href=&quot;https://github.com/tableau/TabPy/commit/af8b4bee0008150167b2b319995805b840e832a3&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot... (continued)

Pull Request Pull Request #388: v0.8.10

Run Details

110 of 110 new or added lines in 6 files covered. (100.0%)

1189 of 2080 relevant lines covered (57.16%)

0.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

37.2

/tabpy/tabpy_server/management/state.py

try:
    from ConfigParser import ConfigParser
except ImportError:
    from configparser import ConfigParser
import json
import logging
from tabpy.tabpy_server.management.util import write_state_config
from threading import Lock
from time import time


logger = logging.getLogger(__name__)

# State File Config Section Names
_DEPLOYMENT_SECTION_NAME = "Query Objects Service Versions"
_QUERY_OBJECT_DOCSTRING = "Query Objects Docstrings"
_SERVICE_INFO_SECTION_NAME = "Service Info"
_META_SECTION_NAME = "Meta"

# Directory Names
_QUERY_OBJECT_DIR = "query_objects"

"""
Lock to change the TabPy State.
"""
_PS_STATE_LOCK = Lock()


def state_lock(func):
    """
    Mutex for changing PS state
    """

    def wrapper(self, *args, **kwargs):
        try:
            _PS_STATE_LOCK.acquire()
            return func(self, *args, **kwargs)
        finally:
            # ALWAYS RELEASE LOCK
            _PS_STATE_LOCK.release()

    return wrapper


def _get_root_path(state_path):
    if state_path[-1] != "/":
        return state_path + "/"
    else:
        return state_path


def get_query_object_path(state_file_path, name, version):
    """
    Returns the query object path

    If the version is None, a path without the version will be returned.
    """
    root_path = _get_root_path(state_file_path)
    if version is not None:
        full_path = root_path + "/".join([_QUERY_OBJECT_DIR, name, str(version)])
    else:
        full_path = root_path + "/".join([_QUERY_OBJECT_DIR, name])
    return full_path


class TabPyState:
    """
    The TabPy state object that stores attributes
    about this TabPy and perform GET/SET on these
    attributes.

    Attributes:
        - name
        - description
        - endpoints (name, description, docstring, version, target)
        - revision number

    When the state object is initialized, the state is saved as a ConfigParser.
    There is a config to any attribute.

    """

    def __init__(self, settings, config=None):
        self.settings = settings
        self.set_config(config, _update=False)

    @state_lock
    def set_config(self, config, logger=logging.getLogger(__name__), _update=True):
        """
        Set the local ConfigParser manually.
        This new ConfigParser will be used as current state.
        """
        if not isinstance(config, ConfigParser):
            raise ValueError("Invalid config")
        self.config = config
        if _update:
            self._write_state(logger)

    def get_endpoints(self, name=None):
        """
        Return a dictionary of endpoints

        Parameters
        ----------
        name : str
            The name of the endpoint.
            If "name" is specified, only the information about that endpoint
            will be returned.

        Returns
        -------
        endpoints : dict
            The dictionary containing information about each endpoint.
            The keys are the endpoint names.
            The values for each include:
                - description
                - doc string
                - type
                - target

        """
        endpoints = {}
        try:
            endpoint_names = self._get_config_value(_DEPLOYMENT_SECTION_NAME, name)
        except Exception as e:
            logger.error(f"error in get_endpoints: {str(e)}")
            return {}

        if name:
            endpoint_info = json.loads(endpoint_names)
            docstring = self._get_config_value(_QUERY_OBJECT_DOCSTRING, name)
            endpoint_info["docstring"] = str(
                bytes(docstring, "utf-8").decode("unicode_escape")
            )
            endpoints = {name: endpoint_info}
        else:
            for endpoint_name in endpoint_names:
                endpoint_info = json.loads(
                    self._get_config_value(_DEPLOYMENT_SECTION_NAME, endpoint_name)
                )
                docstring = self._get_config_value(
                    _QUERY_OBJECT_DOCSTRING, endpoint_name, True, ""
                )
                endpoint_info["docstring"] = str(
                    bytes(docstring, "utf-8").decode("unicode_escape")
                )
                endpoints[endpoint_name] = endpoint_info
        logger.debug(f"Collected endpoints: {endpoints}")
        return endpoints

    @state_lock
    def add_endpoint(
        self,
        name,
        description=None,
        docstring=None,
        endpoint_type=None,
        methods=None,
        target=None,
        dependencies=None,
        schema=None,
    ):
        """
        Add a new endpoint to the TabPy.

        Parameters
        ----------
        name : str
            Name of the endpoint
        description : str, optional
            Description of this endpoint
        doc_string : str, optional
            The doc string for this endpoint, if needed.
        endpoint_type : str
            The endpoint type (model, alias)
        target : str, optional
            The target endpoint name for the alias to be added.

        Note:
        The version of this endpoint will be set to 1 since it is a new
        endpoint.

        """
        try:
            endpoints = self.get_endpoints()
            if name is None or not isinstance(name, str) or len(name) == 0:
                raise ValueError("name of the endpoint must be a valid string.")
            elif name in endpoints:
                raise ValueError(f"endpoint {name} already exists.")
            if description and not isinstance(description, str):
                raise ValueError("description must be a string.")
            elif not description:
                description = ""
            if docstring and not isinstance(docstring, str):
                raise ValueError("docstring must be a string.")
            elif not docstring:
                docstring = "-- no docstring found in query function --"
            if not endpoint_type or not isinstance(endpoint_type, str):
                raise ValueError("endpoint type must be a string.")
            if dependencies and not isinstance(dependencies, list):
                raise ValueError("dependencies must be a list.")
            elif not dependencies:
                dependencies = []
            if target and not isinstance(target, str):
                raise ValueError("target must be a string.")
            elif target and target not in endpoints:
                raise ValueError("target endpoint is not valid.")

            endpoint_info = {
                "description": description,
                "docstring": docstring,
                "type": endpoint_type,
                "version": 1,
                "dependencies": dependencies,
                "target": target,
                "creation_time": int(time()),
                "last_modified_time": int(time()),
                "schema": schema,
            }

            endpoints[name] = endpoint_info
            self._add_update_endpoints_config(endpoints)
        except Exception as e:
            logger.error(f"Error in add_endpoint: {e}")
            raise

    def _add_update_endpoints_config(self, endpoints):
        # save the endpoint info to config
        dstring = ""
        for endpoint_name in endpoints:
            try:
                info = endpoints[endpoint_name]
                dstring = str(
                    bytes(info["docstring"], "utf-8").decode("unicode_escape")
                )
                self._set_config_value(
                    _QUERY_OBJECT_DOCSTRING,
                    endpoint_name,
                    dstring,
                    _update_revision=False,
                )
                del info["docstring"]
                self._set_config_value(
                    _DEPLOYMENT_SECTION_NAME, endpoint_name, json.dumps(info)
                )
            except Exception as e:
                logger.error(f"Unable to write endpoints config: {e}")
                raise

    @state_lock
    def update_endpoint(
        self,
        name,
        description=None,
        docstring=None,
        endpoint_type=None,
        version=None,
        methods=None,
        target=None,
        dependencies=None,
        schema=None,
    ):
        """
        Update an existing endpoint on the TabPy.

        Parameters
        ----------
        name : str
            Name of the endpoint
        description : str, optional
            Description of this endpoint
        doc_string : str, optional
            The doc string for this endpoint, if needed.
        endpoint_type : str, optional
            The endpoint type (model, alias)
        version : str, optional
            The version of this endpoint
        dependencies=[]
            List of dependent endpoints for this existing endpoint
        target : str, optional
            The target endpoint name for the alias.

        Note:
        For those parameters that are not specified, those values will not
        get changed.

        """
        try:
            endpoints = self.get_endpoints()
            if not name or not isinstance(name, str):
                raise ValueError("name of the endpoint must be string.")
            elif name not in endpoints:
                raise ValueError(f"endpoint {name} does not exist.")

            endpoint_info = endpoints[name]

            if description and not isinstance(description, str):
                raise ValueError("description must be a string.")
            elif not description:
                description = endpoint_info["description"]
            if docstring and not isinstance(docstring, str):
                raise ValueError("docstring must be a string.")
            elif not docstring:
                docstring = endpoint_info["docstring"]
            if endpoint_type and not isinstance(endpoint_type, str):
                raise ValueError("endpoint type must be a string.")
            elif not endpoint_type:
                endpoint_type = endpoint_info["type"]
            if version and not isinstance(version, int):
                raise ValueError("version must be an int.")
            elif not version:
                version = endpoint_info["version"]
            if dependencies and not isinstance(dependencies, list):
                raise ValueError("dependencies must be a list.")
            elif not dependencies:
                if "dependencies" in endpoint_info:
                    dependencies = endpoint_info["dependencies"]
                else:
                    dependencies = []
            if target and not isinstance(target, str):
                raise ValueError("target must be a string.")
            elif target and target not in endpoints:
                raise ValueError("target endpoint is not valid.")
            elif not target:
                target = endpoint_info["target"]
            endpoint_info = {
                "description": description,
                "docstring": docstring,
                "type": endpoint_type,
                "version": version,
                "dependencies": dependencies,
                "target": target,
                "creation_time": endpoint_info["creation_time"],
                "last_modified_time": int(time()),
                "schema": schema,
            }

            endpoints[name] = endpoint_info
            self._add_update_endpoints_config(endpoints)
        except Exception as e:
            logger.error(f"Error in update_endpoint: {e}")
            raise

    @state_lock
    def delete_endpoint(self, name):
        """
        Delete an existing endpoint on the TabPy

        Parameters
        ----------
        name : str
            The name of the endpoint to be deleted.

        Returns
        -------
        deleted endpoint object

        Note:
        Cannot delete this endpoint if other endpoints are currently
        depending on this endpoint.

        """
        if not name or name == "":
            raise ValueError("Name of the endpoint must be a valid string.")
        endpoints = self.get_endpoints()
        if name not in endpoints:
            raise ValueError(f"Endpoint {name} does not exist.")

        endpoint_to_delete = endpoints[name]

        # get dependencies and target
        deps = set()
        for endpoint_name in endpoints:
            if endpoint_name != name:
                deps_list = endpoints[endpoint_name].get("dependencies", [])
                if name in deps_list:
                    deps.add(endpoint_name)

        # check if other endpoints are depending on this endpoint
        if len(deps) > 0:
            raise ValueError(
                f"Cannot remove endpoint {name}, it is currently "
                f"used by {list(deps)} endpoints."
            )

        del endpoints[name]

        # delete the endpoint from state
        try:
            self._remove_config_option(
                _QUERY_OBJECT_DOCSTRING, name, _update_revision=False
            )
            self._remove_config_option(_DEPLOYMENT_SECTION_NAME, name)

            return endpoint_to_delete
        except Exception as e:
            logger.error(f"Unable to delete endpoint {e}")
            raise ValueError(f"Unable to delete endpoint: {e}")

    @property
    def name(self):
        """
        Returns the name of the TabPy service.
        """
        name = None
        try:
            name = self._get_config_value(_SERVICE_INFO_SECTION_NAME, "Name")
        except Exception as e:
            logger.error(f"Unable to get name: {e}")
        return name

    @property
    def creation_time(self):
        """
        Returns the creation time of the TabPy service.
        """
        creation_time = 0
        try:
            creation_time = self._get_config_value(
                _SERVICE_INFO_SECTION_NAME, "Creation Time"
            )
        except Exception as e:
            logger.error(f"Unable to get name: {e}")
        return creation_time

    @state_lock
    def set_name(self, name):
        """
        Set the name of this TabPy service.

        Parameters
        ----------
        name : str
            Name of TabPy service.
        """
        if not isinstance(name, str):
            raise ValueError("name must be a string.")
        try:
            self._set_config_value(_SERVICE_INFO_SECTION_NAME, "Name", name)
        except Exception as e:
            logger.error(f"Unable to set name: {e}")

    def get_description(self):
        """
        Returns the description of the TabPy service.
        """
        description = None
        try:
            description = self._get_config_value(
                _SERVICE_INFO_SECTION_NAME, "Description"
            )
        except Exception as e:
            logger.error(f"Unable to get description: {e}")
        return description

    @state_lock
    def set_description(self, description):
        """
        Set the description of this TabPy service.

        Parameters
        ----------
        description : str
            Description of TabPy service.
        """
        if not isinstance(description, str):
            raise ValueError("Description must be a string.")
        try:
            self._set_config_value(
                _SERVICE_INFO_SECTION_NAME, "Description", description
            )
        except Exception as e:
            logger.error(f"Unable to set description: {e}")

    def get_revision_number(self):
        """
        Returns the revision number of this TabPy service.
        """
        rev = -1
        try:
            rev = int(self._get_config_value(_META_SECTION_NAME, "Revision Number"))
        except Exception as e:
            logger.error(f"Unable to get revision number: {e}")
        return rev

    def get_access_control_allow_origin(self):
        """
        Returns Access-Control-Allow-Origin of this TabPy service.
        """
        _cors_origin = ""
        try:
            logger.debug("Collecting Access-Control-Allow-Origin from state file ...")
            _cors_origin = self._get_config_value(
                "Service Info", "Access-Control-Allow-Origin"
            )
        except Exception as e:
            logger.error(e)
        return _cors_origin

    def get_access_control_allow_headers(self):
        """
        Returns Access-Control-Allow-Headers of this TabPy service.
        """
        _cors_headers = ""
        try:
            _cors_headers = self._get_config_value(
                "Service Info", "Access-Control-Allow-Headers"
            )
        except Exception:
            pass
        return _cors_headers

    def get_access_control_allow_methods(self):
        """
        Returns Access-Control-Allow-Methods of this TabPy service.
        """
        _cors_methods = ""
        try:
            _cors_methods = self._get_config_value(
                "Service Info", "Access-Control-Allow-Methods"
            )
        except Exception:
            pass
        return _cors_methods

    def _set_revision_number(self, revision_number):
        """
        Set the revision number of this TabPy service.
        """
        if not isinstance(revision_number, int):
            raise ValueError("revision number must be an int.")
        try:
            self._set_config_value(
                _META_SECTION_NAME, "Revision Number", revision_number
            )
        except Exception as e:
            logger.error(f"Unable to set revision number: {e}")

    def _remove_config_option(
        self,
        section_name,
        option_name,
        logger=logging.getLogger(__name__),
        _update_revision=True,
    ):
        if not self.config:
            raise ValueError("State configuration not yet loaded.")
        self.config.remove_option(section_name, option_name)
        # update revision number
        if _update_revision:
            self._increase_revision_number()
        self._write_state(logger=logger)

    def _has_config_value(self, section_name, option_name):
        if not self.config:
            raise ValueError("State configuration not yet loaded.")
        return self.config.has_option(section_name, option_name)

    def _increase_revision_number(self):
        if not self.config:
            raise ValueError("State configuration not yet loaded.")
        cur_rev = int(self.config.get(_META_SECTION_NAME, "Revision Number"))
        self.config.set(_META_SECTION_NAME, "Revision Number", str(cur_rev + 1))

    def _set_config_value(
        self,
        section_name,
        option_name,
        option_value,
        logger=logging.getLogger(__name__),
        _update_revision=True,
    ):
        if not self.config:
            raise ValueError("State configuration not yet loaded.")

        if not self.config.has_section(section_name):
            logger.log(logging.DEBUG, f"Adding config section {section_name}")
            self.config.add_section(section_name)

        self.config.set(section_name, option_name, option_value)
        # update revision number
        if _update_revision:
            self._increase_revision_number()
        self._write_state(logger=logger)

    def _get_config_items(self, section_name):
        if not self.config:
            raise ValueError("State configuration not yet loaded.")
        return self.config.items(section_name)

    def _get_config_value(
        self, section_name, option_name, optional=False, default_value=None
    ):
        logger.log(
            logging.DEBUG,
            f"Loading option '{option_name}' from section [{section_name}]...")

        if not self.config:
            msg = "State configuration not yet loaded."
            logging.log(msg)
            raise ValueError(msg)

        res = None
        if not option_name:
            res = self.config.options(section_name)
        elif self.config.has_option(section_name, option_name):
            res = self.config.get(section_name, option_name)
        elif optional:
            res = default_value
        else:
            raise ValueError(
                f"Cannot find option name {option_name} "
                f"under section {section_name}"
            )

        logger.log(logging.DEBUG, f"Returning value '{res}'")
        return res

    def _write_state(self, logger=logging.getLogger(__name__)):
        """
        Write state (ConfigParser) to Consul
        """
        logger.log(logging.INFO, "Writing state to config")
        write_state_config(self.config, self.settings, logger=logger)

1	try:	1✔
2	from ConfigParser import ConfigParser	1✔
3	except ImportError:	1✔
4	from configparser import ConfigParser	1✔
5	import json	1✔
6	import logging	1✔
7	from tabpy.tabpy_server.management.util import write_state_config	1✔
8	from threading import Lock	1✔
9	from time import time	1✔
10
11
12	logger = logging.getLogger(__name__)	1✔
13
14	# State File Config Section Names
15	_DEPLOYMENT_SECTION_NAME = "Query Objects Service Versions"	1✔
16	_QUERY_OBJECT_DOCSTRING = "Query Objects Docstrings"	1✔
17	_SERVICE_INFO_SECTION_NAME = "Service Info"	1✔
18	_META_SECTION_NAME = "Meta"	1✔
19
20	# Directory Names
21	_QUERY_OBJECT_DIR = "query_objects"	1✔
22
23	"""
24	Lock to change the TabPy State.
25	"""
26	_PS_STATE_LOCK = Lock()	1✔
27
28
29	def state_lock(func):	1✔
30	"""
31	Mutex for changing PS state
32	"""
33
34	def wrapper(self, args, *kwargs):	1✔
35	try:	1✔
36	_PS_STATE_LOCK.acquire()	1✔
37	return func(self, args, *kwargs)	1✔
38	finally:
39	# ALWAYS RELEASE LOCK
40	_PS_STATE_LOCK.release()	1✔
41
42	return wrapper	1✔
43
44
45	def _get_root_path(state_path):	1✔
46	if state_path[-1] != "/":	1✔
47	return state_path + "/"	1✔
48	else:
49	return state_path	×
50
51
52	def get_query_object_path(state_file_path, name, version):	1✔
53	"""
54	Returns the query object path
55
56	If the version is None, a path without the version will be returned.
57	"""
58	root_path = _get_root_path(state_file_path)	1✔
59	if version is not None:	1✔
60	full_path = root_path + "/".join([_QUERY_OBJECT_DIR, name, str(version)])	1✔
61	else:
62	full_path = root_path + "/".join([_QUERY_OBJECT_DIR, name])	×
63	return full_path	1✔
64
65
66	class TabPyState:	1✔
67	"""
68	The TabPy state object that stores attributes
69	about this TabPy and perform GET/SET on these
70	attributes.
71
72	Attributes:
73	- name
74	- description
75	- endpoints (name, description, docstring, version, target)
76	- revision number
77
78	When the state object is initialized, the state is saved as a ConfigParser.
79	There is a config to any attribute.
80
81	"""
82
83	def __init__(self, settings, config=None):	1✔
84	self.settings = settings	1✔
85	self.set_config(config, _update=False)	1✔
86
87	@state_lock	1✔
88	def set_config(self, config, logger=logging.getLogger(__name__), _update=True):	1✔
89	"""
90	Set the local ConfigParser manually.
91	This new ConfigParser will be used as current state.
92	"""
93	if not isinstance(config, ConfigParser):	1✔
94	raise ValueError("Invalid config")	×
95	self.config = config	1✔
96	if _update:	1✔
97	self._write_state(logger)	×
98
99	def get_endpoints(self, name=None):	1✔
100	"""
101	Return a dictionary of endpoints
102
103	Parameters
104	----------
105	name : str
106	The name of the endpoint.
107	If "name" is specified, only the information about that endpoint
108	will be returned.
109
110	Returns
111	-------
112	endpoints : dict
113	The dictionary containing information about each endpoint.
114	The keys are the endpoint names.
115	The values for each include:
116	- description
117	- doc string
118	- type
119	- target
120
121	"""
122	endpoints = {}	1✔
123	try:	1✔
124	endpoint_names = self._get_config_value(_DEPLOYMENT_SECTION_NAME, name)	1✔
125	except Exception as e:	×
126	logger.error(f"error in get_endpoints: {str(e)}")	×
127	return {}	×
128
129	if name:	1✔
130	endpoint_info = json.loads(endpoint_names)	×
131	docstring = self._get_config_value(_QUERY_OBJECT_DOCSTRING, name)	×
132	endpoint_info["docstring"] = str(	×
133	bytes(docstring, "utf-8").decode("unicode_escape")
134	)
135	endpoints = {name: endpoint_info}	×
136	else:
137	for endpoint_name in endpoint_names:	1✔
138	endpoint_info = json.loads(	1✔
139	self._get_config_value(_DEPLOYMENT_SECTION_NAME, endpoint_name)
140	)
141	docstring = self._get_config_value(	1✔
142	_QUERY_OBJECT_DOCSTRING, endpoint_name, True, ""
143	)
144	endpoint_info["docstring"] = str(	1✔
145	bytes(docstring, "utf-8").decode("unicode_escape")
146	)
147	endpoints[endpoint_name] = endpoint_info	1✔
148	logger.debug(f"Collected endpoints: {endpoints}")	1✔
149	return endpoints	1✔
150
151	@state_lock	1✔
152	def add_endpoint(	1✔
153	self,
154	name,
155	description=None,
156	docstring=None,
157	endpoint_type=None,
158	methods=None,
159	target=None,
160	dependencies=None,
161	schema=None,
162	):
163	"""
164	Add a new endpoint to the TabPy.
165
166	Parameters
167	----------
168	name : str
169	Name of the endpoint
170	description : str, optional
171	Description of this endpoint
172	doc_string : str, optional
173	The doc string for this endpoint, if needed.
174	endpoint_type : str
175	The endpoint type (model, alias)
176	target : str, optional
177	The target endpoint name for the alias to be added.
178
179	Note:
180	The version of this endpoint will be set to 1 since it is a new
181	endpoint.
182
183	"""
184	try:	×
185	endpoints = self.get_endpoints()	×
186	if name is None or not isinstance(name, str) or len(name) == 0:	×
187	raise ValueError("name of the endpoint must be a valid string.")	×
188	elif name in endpoints:	×
189	raise ValueError(f"endpoint {name} already exists.")	×
190	if description and not isinstance(description, str):	×
191	raise ValueError("description must be a string.")	×
192	elif not description:	×
193	description = ""	×
194	if docstring and not isinstance(docstring, str):	×
195	raise ValueError("docstring must be a string.")	×
196	elif not docstring:	×
197	docstring = "-- no docstring found in query function --"	×
198	if not endpoint_type or not isinstance(endpoint_type, str):	×
199	raise ValueError("endpoint type must be a string.")	×
200	if dependencies and not isinstance(dependencies, list):	×
201	raise ValueError("dependencies must be a list.")	×
202	elif not dependencies:	×
203	dependencies = []	×
204	if target and not isinstance(target, str):	×
205	raise ValueError("target must be a string.")	×
206	elif target and target not in endpoints:	×
207	raise ValueError("target endpoint is not valid.")	×
208
209	endpoint_info = {	×
210	"description": description,
211	"docstring": docstring,
212	"type": endpoint_type,
213	"version": 1,
214	"dependencies": dependencies,
215	"target": target,
216	"creation_time": int(time()),
217	"last_modified_time": int(time()),
218	"schema": schema,
219	}
220
221	endpoints[name] = endpoint_info	×
222	self._add_update_endpoints_config(endpoints)	×
223	except Exception as e:	×
224	logger.error(f"Error in add_endpoint: {e}")	×
225	raise	×
226
227	def _add_update_endpoints_config(self, endpoints):	1✔
228	# save the endpoint info to config
229	dstring = ""	×
230	for endpoint_name in endpoints:	×
231	try:	×
232	info = endpoints[endpoint_name]	×
233	dstring = str(	×
234	bytes(info["docstring"], "utf-8").decode("unicode_escape")
235	)
236	self._set_config_value(	×
237	_QUERY_OBJECT_DOCSTRING,
238	endpoint_name,
239	dstring,
240	_update_revision=False,
241	)
242	del info["docstring"]	×
243	self._set_config_value(	×
244	_DEPLOYMENT_SECTION_NAME, endpoint_name, json.dumps(info)
245	)
246	except Exception as e:	×
247	logger.error(f"Unable to write endpoints config: {e}")	×
248	raise	×
249
250	@state_lock	1✔
251	def update_endpoint(	1✔
252	self,
253	name,
254	description=None,
255	docstring=None,
256	endpoint_type=None,
257	version=None,
258	methods=None,
259	target=None,
260	dependencies=None,
261	schema=None,
262	):
263	"""
264	Update an existing endpoint on the TabPy.
265
266	Parameters
267	----------
268	name : str
269	Name of the endpoint
270	description : str, optional
271	Description of this endpoint
272	doc_string : str, optional
273	The doc string for this endpoint, if needed.
274	endpoint_type : str, optional
275	The endpoint type (model, alias)
276	version : str, optional
277	The version of this endpoint
278	dependencies=[]
279	List of dependent endpoints for this existing endpoint
280	target : str, optional
281	The target endpoint name for the alias.
282
283	Note:
284	For those parameters that are not specified, those values will not
285	get changed.
286
287	"""
288	try:	×
289	endpoints = self.get_endpoints()	×
290	if not name or not isinstance(name, str):	×
291	raise ValueError("name of the endpoint must be string.")	×
292	elif name not in endpoints:	×
293	raise ValueError(f"endpoint {name} does not exist.")	×
294
295	endpoint_info = endpoints[name]	×
296
297	if description and not isinstance(description, str):	×
298	raise ValueError("description must be a string.")	×
299	elif not description:	×
300	description = endpoint_info["description"]	×
301	if docstring and not isinstance(docstring, str):	×
302	raise ValueError("docstring must be a string.")	×
303	elif not docstring:	×
304	docstring = endpoint_info["docstring"]	×
305	if endpoint_type and not isinstance(endpoint_type, str):	×
306	raise ValueError("endpoint type must be a string.")	×
307	elif not endpoint_type:	×
308	endpoint_type = endpoint_info["type"]	×
309	if version and not isinstance(version, int):	×
310	raise ValueError("version must be an int.")	×
311	elif not version:	×
312	version = endpoint_info["version"]	×
313	if dependencies and not isinstance(dependencies, list):	×
314	raise ValueError("dependencies must be a list.")	×
315	elif not dependencies:	×
316	if "dependencies" in endpoint_info:	×
317	dependencies = endpoint_info["dependencies"]	×
318	else:
319	dependencies = []	×
320	if target and not isinstance(target, str):	×
321	raise ValueError("target must be a string.")	×
322	elif target and target not in endpoints:	×
323	raise ValueError("target endpoint is not valid.")	×
324	elif not target:	×
325	target = endpoint_info["target"]	×
326	endpoint_info = {	×
327	"description": description,
328	"docstring": docstring,
329	"type": endpoint_type,
330	"version": version,
331	"dependencies": dependencies,
332	"target": target,
333	"creation_time": endpoint_info["creation_time"],
334	"last_modified_time": int(time()),
335	"schema": schema,
336	}
337
338	endpoints[name] = endpoint_info	×
339	self._add_update_endpoints_config(endpoints)	×
340	except Exception as e:	×
341	logger.error(f"Error in update_endpoint: {e}")	×
342	raise	×
343
344	@state_lock	1✔
345	def delete_endpoint(self, name):
346	"""
347	Delete an existing endpoint on the TabPy
348
349	Parameters
350	----------
351	name : str
352	The name of the endpoint to be deleted.
353
354	Returns
355	-------
356	deleted endpoint object
357
358	Note:
359	Cannot delete this endpoint if other endpoints are currently
360	depending on this endpoint.
361
362	"""
363	if not name or name == "":	×
364	raise ValueError("Name of the endpoint must be a valid string.")	×
365	endpoints = self.get_endpoints()	×
366	if name not in endpoints:	×
367	raise ValueError(f"Endpoint {name} does not exist.")	×
368
369	endpoint_to_delete = endpoints[name]	×
370
371	# get dependencies and target
372	deps = set()	×
373	for endpoint_name in endpoints:	×
374	if endpoint_name != name:	×
375	deps_list = endpoints[endpoint_name].get("dependencies", [])	×
376	if name in deps_list:	×
377	deps.add(endpoint_name)	×
378
379	# check if other endpoints are depending on this endpoint
380	if len(deps) > 0:	×
381	raise ValueError(	×
382	f"Cannot remove endpoint {name}, it is currently "
383	f"used by {list(deps)} endpoints."
384	)
385
386	del endpoints[name]	×
387
388	# delete the endpoint from state
389	try:	×
390	self._remove_config_option(	×
391	_QUERY_OBJECT_DOCSTRING, name, _update_revision=False
392	)
393	self._remove_config_option(_DEPLOYMENT_SECTION_NAME, name)	×
394
395	return endpoint_to_delete	×
396	except Exception as e:	×
397	logger.error(f"Unable to delete endpoint {e}")	×
398	raise ValueError(f"Unable to delete endpoint: {e}")	×
399
400	@property	1✔
401	def name(self):
402	"""
403	Returns the name of the TabPy service.
404	"""
405	name = None	1✔
406	try:	1✔
407	name = self._get_config_value(_SERVICE_INFO_SECTION_NAME, "Name")	1✔
408	except Exception as e:	×
409	logger.error(f"Unable to get name: {e}")	×
410	return name	1✔
411
412	@property	1✔
413	def creation_time(self):
414	"""
415	Returns the creation time of the TabPy service.
416	"""
417	creation_time = 0	1✔
418	try:	1✔
419	creation_time = self._get_config_value(	1✔
420	_SERVICE_INFO_SECTION_NAME, "Creation Time"
421	)
422	except Exception as e:	×
423	logger.error(f"Unable to get name: {e}")	×
424	return creation_time	1✔
425
426	@state_lock	1✔
427	def set_name(self, name):
428	"""
429	Set the name of this TabPy service.
430
431	Parameters
432	----------
433	name : str
434	Name of TabPy service.
435	"""
436	if not isinstance(name, str):	×
437	raise ValueError("name must be a string.")	×
438	try:	×
439	self._set_config_value(_SERVICE_INFO_SECTION_NAME, "Name", name)	×
440	except Exception as e:	×
441	logger.error(f"Unable to set name: {e}")	×
442
443	def get_description(self):	1✔
444	"""
445	Returns the description of the TabPy service.
446	"""
447	description = None	1✔
448	try:	1✔
449	description = self._get_config_value(	1✔
450	_SERVICE_INFO_SECTION_NAME, "Description"
451	)
452	except Exception as e:	×
453	logger.error(f"Unable to get description: {e}")	×
454	return description	1✔
455
456	@state_lock	1✔
457	def set_description(self, description):
458	"""
459	Set the description of this TabPy service.
460
461	Parameters
462	----------
463	description : str
464	Description of TabPy service.
465	"""
466	if not isinstance(description, str):	×
467	raise ValueError("Description must be a string.")	×
468	try:	×
469	self._set_config_value(	×
470	_SERVICE_INFO_SECTION_NAME, "Description", description
471	)
472	except Exception as e:	×
473	logger.error(f"Unable to set description: {e}")	×
474
475	def get_revision_number(self):	1✔
476	"""
477	Returns the revision number of this TabPy service.
478	"""
479	rev = -1	×
480	try:	×
481	rev = int(self._get_config_value(_META_SECTION_NAME, "Revision Number"))	×
482	except Exception as e:	×
483	logger.error(f"Unable to get revision number: {e}")	×
484	return rev	×
485
486	def get_access_control_allow_origin(self):	1✔
487	"""
488	Returns Access-Control-Allow-Origin of this TabPy service.
489	"""
490	_cors_origin = ""	1✔
491	try:	1✔
492	logger.debug("Collecting Access-Control-Allow-Origin from state file ...")	1✔
493	_cors_origin = self._get_config_value(	1✔
494	"Service Info", "Access-Control-Allow-Origin"
495	)
496	except Exception as e:	×
497	logger.error(e)	×
498	return _cors_origin	1✔
499
500	def get_access_control_allow_headers(self):	1✔
501	"""
502	Returns Access-Control-Allow-Headers of this TabPy service.
503	"""
504	_cors_headers = ""	1✔
505	try:	1✔
506	_cors_headers = self._get_config_value(	1✔
507	"Service Info", "Access-Control-Allow-Headers"
508	)
509	except Exception:	×
510	pass	×
511	return _cors_headers	1✔
512
513	def get_access_control_allow_methods(self):	1✔
514	"""
515	Returns Access-Control-Allow-Methods of this TabPy service.
516	"""
517	_cors_methods = ""	1✔
518	try:	1✔
519	_cors_methods = self._get_config_value(	1✔
520	"Service Info", "Access-Control-Allow-Methods"
521	)
522	except Exception:	×
523	pass	×
524	return _cors_methods	1✔
525
526	def _set_revision_number(self, revision_number):	1✔
527	"""
528	Set the revision number of this TabPy service.
529	"""
530	if not isinstance(revision_number, int):	×
531	raise ValueError("revision number must be an int.")	×
532	try:	×
533	self._set_config_value(	×
534	_META_SECTION_NAME, "Revision Number", revision_number
535	)
536	except Exception as e:	×
537	logger.error(f"Unable to set revision number: {e}")	×
538
539	def _remove_config_option(	1✔
540	self,
541	section_name,
542	option_name,
543	logger=logging.getLogger(__name__),
544	_update_revision=True,
545	):
546	if not self.config:	×
547	raise ValueError("State configuration not yet loaded.")	×
548	self.config.remove_option(section_name, option_name)	×
549	# update revision number
550	if _update_revision:	×
551	self._increase_revision_number()	×
552	self._write_state(logger=logger)	×
553
554	def _has_config_value(self, section_name, option_name):	1✔
555	if not self.config:	×
556	raise ValueError("State configuration not yet loaded.")	×
557	return self.config.has_option(section_name, option_name)	×
558
559	def _increase_revision_number(self):	1✔
560	if not self.config:	×
561	raise ValueError("State configuration not yet loaded.")	×
562	cur_rev = int(self.config.get(_META_SECTION_NAME, "Revision Number"))	×
563	self.config.set(_META_SECTION_NAME, "Revision Number", str(cur_rev + 1))	×
564
565	def _set_config_value(	1✔
566	self,
567	section_name,
568	option_name,
569	option_value,
570	logger=logging.getLogger(__name__),
571	_update_revision=True,
572	):
573	if not self.config:	×
574	raise ValueError("State configuration not yet loaded.")	×
575
576	if not self.config.has_section(section_name):	×
577	logger.log(logging.DEBUG, f"Adding config section {section_name}")	×
578	self.config.add_section(section_name)	×
579
580	self.config.set(section_name, option_name, option_value)	×
581	# update revision number
582	if _update_revision:	×
583	self._increase_revision_number()	×
584	self._write_state(logger=logger)	×
585
586	def _get_config_items(self, section_name):	1✔
587	if not self.config:	×
588	raise ValueError("State configuration not yet loaded.")	×
589	return self.config.items(section_name)	×
590
591	def _get_config_value(	1✔
592	self, section_name, option_name, optional=False, default_value=None
593	):
594	logger.log(	1✔
595	logging.DEBUG,
596	f"Loading option '{option_name}' from section [{section_name}]...")
597
598	if not self.config:	1✔
599	msg = "State configuration not yet loaded."	×
600	logging.log(msg)	×
601	raise ValueError(msg)	×
602
603	res = None	1✔
604	if not option_name:	1✔
605	res = self.config.options(section_name)	1✔
606	elif self.config.has_option(section_name, option_name):	1✔
607	res = self.config.get(section_name, option_name)	1✔
608	elif optional:	×
609	res = default_value	×
610	else:
611	raise ValueError(	×
612	f"Cannot find option name {option_name} "
613	f"under section {section_name}"
614	)
615
616	logger.log(logging.DEBUG, f"Returning value '{res}'")	1✔
617	return res	1✔
618
619	def _write_state(self, logger=logging.getLogger(__name__)):	1✔
620	"""
621	Write state (ConfigParser) to Consul
622	"""
623	logger.log(logging.INFO, "Writing state to config")	×
624	write_state_config(self.config, self.settings, logger=logger)	×

tableau / TabPy / #1120

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous