Ejemplo n.º 1
0
    def test_dict_to_querystring(self):
        expected = [
            "start=2016-02-10T13%3A54%3A53%2B00%3A00"
            "&stop=2016-02-10T13%3A56%3A42%2B02%3A00",
            "stop=2016-02-10T13%3A56%3A42%2B02%3A00"
            "&start=2016-02-10T13%3A54%3A53%2B00%3A00"
        ]

        self.assertIn(
            utils.dict_to_querystring({
                "start": "2016-02-10T13:54:53+00:00",
                "stop": "2016-02-10T13:56:42+02:00"
            }), expected)

        self.assertEqual(
            "groupby=foo&groupby=bar",
            utils.dict_to_querystring({"groupby": ["foo", "bar"]}),
        )

        self.assertEqual(
            "groupby=foo&groupby=bar&overlap=0",
            utils.dict_to_querystring({
                "groupby": ["foo", "bar"],
                "overlap": 0,
            }),
        )
Ejemplo n.º 2
0
    def test_dict_to_querystring(self):
        expected = ["start=2016-02-10T13%3A54%3A53%2B00%3A00"
                    "&stop=2016-02-10T13%3A56%3A42%2B02%3A00",
                    "stop=2016-02-10T13%3A56%3A42%2B02%3A00"
                    "&start=2016-02-10T13%3A54%3A53%2B00%3A00"]

        self.assertIn(utils.dict_to_querystring(
            {"start": "2016-02-10T13:54:53+00:00",
             "stop": "2016-02-10T13:56:42+02:00"}),
            expected)

        self.assertEqual(
            "groupby=foo&groupby=bar",
            utils.dict_to_querystring({
                "groupby": ["foo", "bar"]
            }),
        )

        self.assertEqual(
            "groupby=foo&groupby=bar&overlap=0",
            utils.dict_to_querystring({
                "groupby": ["foo", "bar"],
                "overlap": 0,
            }),
        )
Ejemplo n.º 3
0
    def search(self,
               resource_type="generic",
               query=None,
               details=False,
               history=False,
               limit=None,
               marker=None,
               sorts=None):
        """List resources.

        :param resource_type: Type of the resource
        :type resource_type: str
        :param query: The query dictionary
        :type query: dict
        :param details: Show all attributes of resources
        :type details: bool
        :param history: Show the history of resources
        :type history: bool
        :param limit: maximum number of resources to return
        :type limit: int
        :param marker: the last item of the previous page; we returns the next
                       results after this value.
        :type marker: str
        :param sorts: list of resource attributes to order by. (example
                      ["user_id:desc-nullslast", "project_id:asc"]
        :type sorts: list of str

        See Gnocchi REST API documentation for the format
        of *query dictionary*
        http://gnocchi.osci.io/rest.html#searching-for-resources
        """
        query = query or {}
        params = utils.build_pagination_options(details, history, limit,
                                                marker, sorts)
        url = "v1/search/resource/%s?%%s" % resource_type

        if isinstance(query, dict):
            return self._post(url % utils.dict_to_querystring(params),
                              headers={
                                  'Content-Type': "application/json"
                              },
                              data=ujson.dumps(query)).json()

        params['filter'] = query
        return self._post(url % utils.dict_to_querystring(params),
                          headers={
                              'Content-Type': "application/json"
                          }).json()
Ejemplo n.º 4
0
    def list(self, limit=None, marker=None, sorts=None):
        """List metrics.

        :param limit: maximum number of resources to return
        :type limit: int
        :param marker: the last item of the previous page; we return the next
                       results after this value.
        :type marker: str
        :param sorts: list of resource attributes to order by. (example
                      ["user_id:desc-nullslast", "project_id:asc"]
        :type sorts: list of str
        """
        params = utils.build_pagination_options(False, False, limit, marker,
                                                sorts)
        metrics = []
        page_url = "%s?%s" % (self.metric_url[:-1],
                              utils.dict_to_querystring(params))
        while page_url:
            page = self._get(page_url)
            metrics.extend(page.json())
            if limit is None or len(metrics) < limit:
                page_url = page.links.get("next", {'url': None})['url']
            else:
                break
        return metrics
Ejemplo n.º 5
0
    def history(self,
                resource_type,
                resource_id,
                details=False,
                limit=None,
                marker=None,
                sorts=None):
        """Get a resource.

        :param resource_type: Type of the resource
        :type resource_type: str
        :param resource_id: ID of the resource
        :type resource_id: str
        :param details: Show all attributes of resources
        :type details: bool
        :param limit: maximum number of resources to return
        :type limit: int
        :param marker: the last item of the previous page; we returns the next
                       results after this value.
        :type marker: str
        :param sorts: list of resource attributes to order by. (example
                      ["user_id:desc-nullslast", "project_id:asc"]
        :type sorts: list of str
        """
        params = utils.build_pagination_options(details, False, limit, marker,
                                                sorts)
        url = "%s%s/%s/history?%s" % (self.url, resource_type, resource_id,
                                      utils.dict_to_querystring(params))
        return self._get(url).json()
    def test_dict_to_querystring(self):
        expected = ["start=2016-02-10T13%3A54%3A53%2B00%3A00"
                    "&stop=2016-02-10T13%3A56%3A42%2B02%3A00",
                    "stop=2016-02-10T13%3A56%3A42%2B02%3A00"
                    "&start=2016-02-10T13%3A54%3A53%2B00%3A00"]

        self.assertIn(utils.dict_to_querystring(
            {"start": "2016-02-10T13:54:53+00:00",
             "stop": "2016-02-10T13:56:42+02:00"}),
            expected)
Ejemplo n.º 7
0
    def test_dict_to_querystring(self):
        expected = [
            "start=2016-02-10T13%3A54%3A53%2B00%3A00"
            "&stop=2016-02-10T13%3A56%3A42%2B02%3A00",
            "stop=2016-02-10T13%3A56%3A42%2B02%3A00"
            "&start=2016-02-10T13%3A54%3A53%2B00%3A00"
        ]

        self.assertIn(
            utils.dict_to_querystring({
                "start": "2016-02-10T13:54:53+00:00",
                "stop": "2016-02-10T13:56:42+02:00"
            }), expected)
Ejemplo n.º 8
0
    def aggregation(self,
                    metrics,
                    query=None,
                    start=None,
                    stop=None,
                    aggregation=None,
                    needed_overlap=None,
                    resource_type="generic"):
        """Get measurements of a aggregated metrics

        :param metrics: IDs of metric or metric name
        :type metric: list or str
        :param query: The query dictionary
        :type query: dict
        :param start: beginning of the period
        :type start: timestamp
        :param stop: end of the period
        :type stop: timestamp
        :param aggregation: aggregation to retrieve
        :type aggregation: str
        :param resource_type: type of resource for the query
        :type resource_type: str

        See Gnocchi REST API documentation for the format
        of *query dictionary*
        http://docs.openstack.org/developer/gnocchi/rest.html#searching-for-resources
        """

        if isinstance(start, datetime.datetime):
            start = start.isoformat()
        if isinstance(stop, datetime.datetime):
            stop = stop.isoformat()

        params = dict(start=start,
                      stop=stop,
                      aggregation=aggregation,
                      needed_overlap=needed_overlap)
        if query is None:
            for metric in metrics:
                self._ensure_metric_is_uuid(metric)
            params['metric'] = metrics
            return self._get("v1/aggregation/metric", params=params).json()
        else:
            return self._post(
                "v1/aggregation/resource/%s/metric/%s?%s" %
                (resource_type, metrics, utils.dict_to_querystring(params)),
                headers={
                    'Content-Type': "application/json"
                },
                data=jsonutils.dumps(query)).json()
    def aggregation(self, metrics, query=None,
                    start=None, stop=None, aggregation=None,
                    needed_overlap=None, resource_type="generic"):
        """Get measurements of a aggregated metrics

        :param metrics: IDs of metric or metric name
        :type metric: list or str
        :param query: The query dictionary
        :type query: dict
        :param start: beginning of the period
        :type start: timestamp
        :param stop: end of the period
        :type stop: timestamp
        :param aggregation: aggregation to retrieve
        :type aggregation: str
        :param resource_type: type of resource for the query
        :type resource_type: str

        See Gnocchi REST API documentation for the format
        of *query dictionary*
        http://docs.openstack.org/developer/gnocchi/rest.html#searching-for-resources
        """

        if isinstance(start, datetime.datetime):
            start = start.isoformat()
        if isinstance(stop, datetime.datetime):
            stop = stop.isoformat()

        params = dict(start=start, stop=stop, aggregation=aggregation,
                      needed_overlap=needed_overlap)
        if query is None:
            for metric in metrics:
                self._ensure_metric_is_uuid(metric)
            params['metric'] = metrics
            return self._get("v1/aggregation/metric",
                             params=params).json()
        else:
            return self._post(
                "v1/aggregation/resource/%s/metric/%s?%s" % (
                    resource_type, metrics,
                    utils.dict_to_querystring(params)),
                headers={'Content-Type': "application/json"},
                data=jsonutils.dumps(query)).json()
Ejemplo n.º 10
0
    def aggregation(self,
                    metrics,
                    query=None,
                    start=None,
                    stop=None,
                    aggregation=None,
                    reaggregation=None,
                    granularity=None,
                    needed_overlap=None,
                    resource_type="generic",
                    groupby=None,
                    refresh=False,
                    resample=None,
                    fill=None):
        """Get measurements of an aggregated metrics

        :param metrics: IDs of metric or metric name
        :type metric: list or str
        :param query: The query dictionary
        :type query: dict
        :param start: beginning of the period
        :type start: timestamp
        :param stop: end of the period
        :type stop: timestamp
        :param aggregation: granularity aggregation function to retrieve
        :type aggregation: str
        :param reaggregation: groupby aggregation function to retrieve
        :type reaggregation: str
        :param granularity: granularity to retrieve (in seconds)
        :type granularity: int
        :param needed_overlap: percent of datapoints in each metrics required
        :type needed_overlap: float
        :param resource_type: type of resource for the query
        :type resource_type: str
        :param groupby: list of attribute to group by
        :type groupby: list
        :param refresh: force aggregation of all known measures
        :type refresh: bool
        :param resample: resample measures to new granularity
        :type resample: float
        :param fill: value to use when backfilling missing datapoints
        :type fill: float or 'null'

        See Gnocchi REST API documentation for the format
        of *query dictionary*
        http://docs.openstack.org/developer/gnocchi/rest.html#searching-for-resources
        """

        if isinstance(start, datetime.datetime):
            start = start.isoformat()
        if isinstance(stop, datetime.datetime):
            stop = stop.isoformat()

        params = dict(start=start,
                      stop=stop,
                      aggregation=aggregation,
                      reaggregation=reaggregation,
                      granularity=granularity,
                      needed_overlap=needed_overlap,
                      groupby=groupby,
                      refresh=refresh,
                      resample=resample,
                      fill=fill)
        if query is None:
            for metric in metrics:
                self._ensure_metric_is_uuid(metric)
            params['metric'] = metrics
            measures = self._get("v1/aggregation/metric", params=params).json()
        else:
            measures = self._post(
                "v1/aggregation/resource/%s/metric/%s?%s" %
                (resource_type, metrics, utils.dict_to_querystring(params)),
                headers={
                    'Content-Type': "application/json"
                },
                data=ujson.dumps(query)).json()

        if groupby is None:
            return [(iso8601.parse_date(ts), g, value)
                    for ts, g, value in measures]

        for group in measures:
            group["measures"] = [(iso8601.parse_date(ts), g, value)
                                 for ts, g, value in group["measures"]]

        return measures
Ejemplo n.º 11
0
    def fetch(self,
              operations,
              search=None,
              resource_type='generic',
              start=None,
              stop=None,
              granularity=None,
              needed_overlap=None,
              groupby=None,
              fill=None,
              details=False):
        """Get measurements of an aggregated metrics.

        :param operations: operations
        :type operations: list or str
        :param start: beginning of the period
        :type start: timestamp
        :param stop: end of the period
        :type stop: timestamp
        :param granularity: granularity to retrieve (in seconds)
        :type granularity: int
        :param needed_overlap: percent of datapoints in each metrics required
        :type needed_overlap: float
        :param groupby: list of attribute to group by
        :type groupby: list
        :param fill: value to use when backfilling missing datapoints
        :type fill: float or 'null'
        :param details: also returns the list of metrics or resources
                        associated to the operations
        :type details: boolean

        See Gnocchi REST API documentation for the format
        of *query dictionary*
        http://docs.openstack.org/developer/gnocchi/rest.html#aggregates
        """
        if isinstance(start, datetime.datetime):
            start = start.isoformat()
        if isinstance(stop, datetime.datetime):
            stop = stop.isoformat()

        params = dict(start=start,
                      stop=stop,
                      granularity=granularity,
                      needed_overlap=needed_overlap,
                      fill=fill,
                      details=details)

        data = dict(operations=operations)
        if search is not None:
            data["search"] = search
            data["resource_type"] = resource_type
            params["groupby"] = groupby

        aggregates = self._post("v1/aggregates?%s" %
                                (utils.dict_to_querystring(params)),
                                headers={
                                    'Content-Type': "application/json"
                                },
                                data=ujson.dumps(data)).json()

        if search is not None and groupby is not None:
            for group in aggregates:
                self._convert_dates(group["measures"]["measures"])
        else:
            self._convert_dates(aggregates["measures"])
        return aggregates
Ejemplo n.º 12
0
    def aggregation(self, metrics, query=None,
                    start=None, stop=None, aggregation=None,
                    reaggregation=None, granularity=None,
                    needed_overlap=None, resource_type="generic",
                    groupby=None, refresh=False, resample=None, fill=None):
        """Get measurements of an aggregated metrics

        :param metrics: IDs of metric or metric name
        :type metric: list or str
        :param query: The query dictionary
        :type query: dict
        :param start: beginning of the period
        :type start: timestamp
        :param stop: end of the period
        :type stop: timestamp
        :param aggregation: granularity aggregation function to retrieve
        :type aggregation: str
        :param reaggregation: groupby aggregation function to retrieve
        :type reaggregation: str
        :param granularity: granularity to retrieve (in seconds)
        :type granularity: int
        :param needed_overlap: percent of datapoints in each metrics required
        :type needed_overlap: float
        :param resource_type: type of resource for the query
        :type resource_type: str
        :param groupby: list of attribute to group by
        :type groupby: list
        :param refresh: force aggregation of all known measures
        :type refresh: bool
        :param resample: resample measures to new granularity
        :type resample: float
        :param fill: value to use when backfilling missing datapoints
        :type fill: float or 'null'

        See Gnocchi REST API documentation for the format
        of *query dictionary*
        http://docs.openstack.org/developer/gnocchi/rest.html#searching-for-resources
        """

        if isinstance(start, datetime.datetime):
            start = start.isoformat()
        if isinstance(stop, datetime.datetime):
            stop = stop.isoformat()

        params = dict(start=start, stop=stop, aggregation=aggregation,
                      reaggregation=reaggregation, granularity=granularity,
                      needed_overlap=needed_overlap, groupby=groupby,
                      refresh=refresh, resample=resample, fill=fill)
        if query is None:
            for metric in metrics:
                self._ensure_metric_is_uuid(metric)
            params['metric'] = metrics
            measures = self._get("v1/aggregation/metric",
                                 params=params).json()
        else:
            measures = self._post(
                "v1/aggregation/resource/%s/metric/%s?%s" % (
                    resource_type, metrics,
                    utils.dict_to_querystring(params)),
                headers={'Content-Type': "application/json"},
                data=ujson.dumps(query)).json()

        if groupby is None:
            return [(iso8601.parse_date(ts), g, value)
                    for ts, g, value in measures]

        for group in measures:
            group["measures"] = [
                (iso8601.parse_date(ts), g, value)
                for ts, g, value in group["measures"]
            ]

        return measures