[cm_api] OPSAPS-29287 add new timeseries API for v11 to sync with java side changes

CM server side introduces queryTimeSeries(ApiTimeSeriesRequest request) in
v11. This change adds query_timeseries_with_long_query_string to ApiResource
to sync with server side changes.

Testing done:
End to end test:
  able to invoke new API in new python client against my cluster.
Updated test_timeseries and following command passes:
  cm_api/python$ make clean test

Author: Xiaobin Zheng

python/src/cm_api/api_client.py

@@ -272,15 +272,15 @@ def get_metrics(self, path, from_time, to_time, metrics, view, params=None):
     resp = self.get(path, params=params)
     return types.ApiList.from_json_dict(resp, self, types.ApiMetric)
 
-  def query_timeseries(self, query, from_time=None, to_time=None):
+  def query_timeseries(self, query, from_time=None, to_time=None, by_post=False):
     """
     Query time series.
     @param query: Query string.
     @param from_time: Start of the period to query (optional).
     @param to_time: End of the period to query (default = now).
     @return: A list of ApiTimeSeriesResponse.
     """
-    return timeseries.query_timeseries(self, query, from_time, to_time)
+    return timeseries.query_timeseries(self, query, from_time, to_time, by_post=by_post)
 
   def get_metric_schema(self):
     """

python/src/cm_api/endpoints/timeseries.py

@@ -26,7 +26,7 @@
 METRIC_ENTITY_ATTR_PATH = "/timeseries/entityTypeAttributes"
 
 def query_timeseries(resource_root, query, from_time=None, to_time=None,
-    desired_rollup=None, must_use_desired_rollup=None):
+    desired_rollup=None, must_use_desired_rollup=None, by_post=False):
   """
   Query for time series data from the CM time series data store.
   @param query: Query string.
@@ -47,11 +47,22 @@ def query_timeseries(resource_root, query, from_time=None, to_time=None,
                          must_use_desired_rollup is set to true.
   @param must_use_desired_rollup: Indicates that the monitoring server should
                                   return the data at the rollup desired.
+  @param by_post: If true, an HTTP POST request will be made to server. This
+                  allows longer query string to be accepted compared to HTTP
+                  GET request.
   @return: List of ApiTimeSeriesResponse
   """
+  data = None
   params = {}
-  if query:
+  request_method = resource_root.get
+  if by_post:
+    request = ApiTimeSeriesRequest(resource_root,
+                                   query=query)
+    data = request
+    request_method = resource_root.post
+  elif query:
     params['query'] = query
+
   if from_time:
     params['from'] = from_time.isoformat()
   if to_time:
@@ -60,8 +71,8 @@ def query_timeseries(resource_root, query, from_time=None, to_time=None,
     params['desiredRollup'] = desired_rollup
   if must_use_desired_rollup:
     params['mustUseDesiredRollup'] = must_use_desired_rollup
-  return call(resource_root.get, TIME_SERIES_PATH,
-      ApiTimeSeriesResponse, True, params=params)
+  return call(request_method, TIME_SERIES_PATH,
+      ApiTimeSeriesResponse, True, params=params, data=data)
 
 def get_metric_schema(resource_root):
   """

python/src/cm_api/endpoints/types.py

@@ -1127,6 +1127,19 @@ class ApiYarnApplicationAttribute(BaseApiObject):
   def __str__(self):
     return "<ApiYarnApplicationAttribute> %s" % name
 
+class ApiTimeSeriesRequest(BaseApiObject):
+  _ATTRIBUTES = {
+      'query'                : None,
+      'from'                 : None,
+      'to'                   : None,
+      'contentType'          : None,
+      'desiredRollup'        : None,
+      'mustUseDesiredRollup' : None
+    }
+
+  def __str__(self):
+    return "<ApiTimeSeriesRequest>: %s" % (self.query)
+
 def config_to_api_list(dic):
   """
   Converts a python dictionary into a list containing the proper

python/src/cm_api_tests/test_timeseries.py

@@ -106,13 +106,53 @@ def test_query_timeseries(self):
     time = datetime.datetime.now()
     api_resource.expect("GET", "/timeseries",
                         retdata=json.loads(TIME_SERIES),
-                        params={ 'from':time.isoformat(), 'to':time.isoformat(),
+                        params={ 'from':time.isoformat(),
+                                 'to':time.isoformat(),
                                  'query':'select cpu_percent'})
     responses = query_timeseries(api_resource,
                                  "select cpu_percent",
                                  time,
                                  time)
+    self._verify_timeseries_response(responses)
 
+    # Test the with-rollups call
+    api_resource.expect("GET", "/timeseries",
+                        retdata=json.loads(TIME_SERIES),
+                        params={ 'from':time.isoformat(),
+                                 'to':time.isoformat(),
+                                 'query':'select cpu_percent',
+                                 'desiredRollup':'RAW',
+                                 'mustUseDesiredRollup': True})
+    responses = query_timeseries(api_resource,
+                                 "select cpu_percent",
+                                 time,
+                                 time,
+                                 "RAW",
+                                 True)
+    self._verify_timeseries_response(responses)
+
+    # Test query_timeseries_with_long_query_string
+    api_resource.expect("POST", "/timeseries",
+                        retdata=json.loads(TIME_SERIES),
+                        data={ 'query':'select cpu_percent'},
+                        params={ 'from':time.isoformat(),
+                                 'to':time.isoformat()})
+    responses = query_timeseries(
+      api_resource, "select cpu_percent", time, time, by_post=True)
+    self._verify_timeseries_response(responses)
+
+    api_resource.expect("POST", "/timeseries",
+                        retdata=json.loads(TIME_SERIES),
+                        data={ 'query':'select cpu_percent'},
+                        params={ 'from':time.isoformat(),
+                                 'to':time.isoformat(),
+                                 'desiredRollup':'RAW',
+                                 'mustUseDesiredRollup': True})
+    responses = query_timeseries(api_resource, "select cpu_percent",
+      time, time, "RAW", True, by_post=True)
+    self._verify_timeseries_response(responses)
+
+  def _verify_timeseries_response(self, responses):
     self.assertIsInstance(responses, ApiList)
     self.assertEqual(1, len(responses))
     response = responses[0]
@@ -154,21 +194,6 @@ def test_query_timeseries(self):
     xEntityMetadata = data.aggregateStatistics.crossEntityMetadata
     self.assertIsNone(xEntityMetadata)
 
-    # Test the with-rollups call
-    api_resource.expect("GET", "/timeseries",
-                        retdata=json.loads(TIME_SERIES),
-                        params={ 'from':time.isoformat(), 'to':time.isoformat(),
-                                 'query':'select cpu_percent',
-                                 'desiredRollup':'RAW',
-                                 'mustUseDesiredRollup': True})
-    responses = query_timeseries(api_resource,
-                                 "select cpu_percent",
-                                 time,
-                                 time,
-                                 "RAW",
-                                 True)
-
-
   def test_get_metric_schema(self):
     METRICS = '''{
       "items" : [ {