Api

dashboard/src/actions/datasetListActions.js

@@ -1,13 +1,15 @@
 import * as TYPES from "./types";
 
 import API from "../utils/axiosInstance";
+import { uriTemplate } from "utils/helper";
 
 export const fetchPublicDatasets = () => async (dispatch, getState) => {
   try {
     dispatch({ type: TYPES.LOADING });
     const endpoints = getState().apiEndpoint.endpoints;
     const response = await API.get(
-      `${endpoints?.api?.datasets_list}?metadata=dataset.uploaded&access=public`
+      uriTemplate(endpoints, "datasets_list", {}),
+      { params: { metadata: "dataset.uploaded", access: "public" } }
     );
     if (response.status === 200 && response.data) {
       dispatch({

dashboard/src/actions/overviewActions.js

@@ -4,7 +4,7 @@ import * as TYPES from "./types";
 import { DANGER, ERROR_MSG } from "assets/constants/toastConstants";
 
 import API from "../utils/axiosInstance";
-import { expandUriTemplate } from "../utils/helper";
+import { uriTemplate } from "../utils/helper";
 import { findNoOfDays } from "utils/dateFunctions";
 import { showToast } from "./toastActions";
 import { clearCachedSession } from "./authActions";
@@ -27,8 +27,8 @@ export const getDatasets = () => async (dispatch, getState) => {
     params.append("mine", "true");
 
     const endpoints = getState().apiEndpoint.endpoints;
-    const response = await API.get(endpoints?.api?.datasets_list, {
-      params: params,
+    const response = await API.get(uriTemplate(endpoints, "datasets_list"), {
+      params,
     });
 
     if (response.status === 200) {
@@ -127,7 +127,7 @@ export const updateDataset =
       const method = metaDataActions[actionType];
 
       const endpoints = getState().apiEndpoint.endpoints;
-      const uri = expandUriTemplate(endpoints, "datasets_metadata", {
+      const uri = uriTemplate(endpoints, "datasets_metadata", {
         dataset: dataset.resource_id,
       });
       const response = await API.put(uri, {
@@ -176,7 +176,9 @@ export const deleteDataset = (dataset) => async (dispatch, getState) => {
     dispatch({ type: TYPES.LOADING });
     const endpoints = getState().apiEndpoint.endpoints;
     const response = await API.delete(
-      `${endpoints.api.datasets}/${dataset.resource_id}`
+      uriTemplate(endpoints, "datasets", {
+        dataset: dataset.resource_id,
+      })
     );
     if (response.status === 200) {
       const datasets = getState().overview.datasets;
@@ -257,7 +259,11 @@ export const publishDataset =
       const savedRuns = getState().overview.savedRuns;
 
       const response = await API.post(
-        `${endpoints.api.datasets}/${dataset.resource_id}?access=${updateValue}`
+        uriTemplate(endpoints, "datasets", {
+          dataset: dataset.resource_id,
+        }),
+        null,
+        { params: { access: updateValue } }
       );
       if (response.status === 200) {
         const dataIndex = savedRuns.findIndex(

dashboard/src/actions/tableOfContentActions.js

@@ -1,12 +1,12 @@
 import * as TYPES from "./types";
 import API from "../utils/axiosInstance";
-import { expandUriTemplate } from "../utils/helper";
+import { uriTemplate } from "../utils/helper";
 
 export const fetchTOC =
   (param, parent, callForSubData) => async (dispatch, getState) => {
     try {
       const endpoints = getState().apiEndpoint.endpoints;
-      const uri = expandUriTemplate(endpoints, "datasets_contents", {
+      const uri = uriTemplate(endpoints, "datasets_contents", {
         dataset: param,
         target: parent,
       });

dashboard/src/utils/helper.js

@@ -10,10 +10,10 @@ export const uid = () => {
  *
  * @param {Object} endpoints - endpoint object from server
  * @param {string} name - name of the API to expand
- * @param {Object} args - value for each templated parameter
+ * @param {Object} args - [Optional] value for each templated parameter
  * @return {string} - formatted URI
  */
-export const expandUriTemplate = (endpoints, name, args) => {
+export const uriTemplate = (endpoints, name, args = {}) => {
   let uri = endpoints.uri[name].template;
   for (const [key, value] of Object.entries(args)) {
     uri = uri.replace(`{${key}}`, value);

lib/pbench/client/__init__.py

@@ -120,15 +120,13 @@ def _uri(self, api: API, uri_params: Optional[JSONOBJECT] = None) -> str:
         Returns:
             A fully specified URI
         """
-        if not uri_params:
-            return self.endpoints["api"][api.value]
-        else:
-            description = self.endpoints["uri"][api.value]
-            template = description["template"]
-            cnt = len(description["params"])
-            if cnt != len(uri_params):
-                raise IncorrectParameterCount(api, cnt, uri_params)
-            return template.format(**uri_params)
+        description = self.endpoints["uri"][api.value]
+        template = description["template"]
+        cnt = len(description["params"])
+        params = uri_params if uri_params else {}
+        if cnt != len(params):
+            raise IncorrectParameterCount(api, cnt, params)
+        return template.format(**params)
 
     def get(
         self,

lib/pbench/server/api/resources/endpoint_configure.py

@@ -51,46 +51,22 @@ def get(self):
         including the Pbench dashboard UI. This includes:
 
         openid-connect: A JSON object containing the OpenID Connect parameters
-                        required for the web client to use OIDC authentication.
+                required for the web client to use OIDC authentication.
         identification: The Pbench server name and version
-        api:    A dict of the server APIs supported; we give a name, which
-                identifies the service, and the full URI relative to the
-                configured host name and port (local or remote reverse proxy).
-
-                This is dynamically generated by processing the Flask URI
-                rules; refer to api/__init__.py for the code which creates
-                those mappings, or test_endpoint_configure.py for code that
-                validates the current set (and must be updated when the API
-                set changes).
         uri:    A dict of server API templates, where each template defines a
                 template URI and a list of typed parameters.
 
         We derive a "name" for each API by removing URI parameters and the API
         prefix (/api/v1/), then replacing the path "/" characters with
         underscores.
 
-        The "api" object contains a key for each API name, where the value is a
-        simplified URI omitting URI parameters. The client must either know the
-        required parameters and order, and connect them to the "api" value
-        separated by slash characters, or refer to the "uri" templates.
-
-        E.g, "/api/v1/controllers/list" yields:
-
-            "controllers_list": "http://host/api/v1/controllers/list"
-
-        while "/api/v1/users/<string:username>" yields:
-
-            "users": "http://host/api/v1/users"
-
-        For URIs with multiple parameters, or embedded parameters, it may be
-        easier to work with the template string in the "uri" object. The value
-        of each API name key in the "uri" object is a minimal "schema" object
-        defining the template string and parameters for the API. The "uri"
-        value for the "users" API, for example, will be
+        The "uri" object defines a template for each API name, defining a set of
+        URI parameters that must be expanded in the template. For example, the
+        API to get or modify metadata is:
 
             {
-                "template": "http://host/api/v1/users/{target_username}",
-                "params": {"target_username": {"type": "string"}}
+                "template": "http://host/api/v1/datasets/{dataset}/metadata",
+                "params": {"dataset": {"type": "string"}}
             }
 
         The template can be resolved in Python with:
@@ -137,7 +113,6 @@ def get(self):
             host_value,
         )
 
-        apis = {}
         templates = {}
 
         # Iterate through the Flask endpoints to add a description for each.
@@ -156,7 +131,6 @@ def get(self):
                         for match in matches
                     },
                 }
-                url = self.param_template.sub("", url)
                 path = rule.endpoint
 
                 # We have some URI endpoints that repeat a basic URI pattern.
@@ -168,12 +142,10 @@ def get(self):
                 if path not in templates or (
                     len(template["params"]) > len(templates[path]["params"])
                 ):
-                    apis[path] = urljoin(host, url)
                     templates[path] = template
 
         endpoints = {
             "identification": f"Pbench server {self.server_config.COMMIT_ID}",
-            "api": apis,
             "uri": templates,
         }
 

lib/pbench/test/functional/server/test_connect.py

@@ -12,19 +12,15 @@ def test_connect(self, server_client: PbenchServerClient):
         assert server_client.session.headers["Accept"] == "application/json"
         endpoints = server_client.endpoints
         assert endpoints
-        assert "api" in endpoints
         assert "identification" in endpoints
         assert "uri" in endpoints
 
         # Verify that all expected endpoints are reported
-        for a in endpoints["api"].keys():
-            assert a in expected
         for a in endpoints["uri"].keys():
             assert a in expected
 
         # Verify that no unexpected endpoints are reported
         for e in expected:
-            assert e in endpoints["api"].keys()
             assert e in endpoints["uri"].keys()
 
         # verify all the required openid-connect fields are present

lib/pbench/test/unit/client/test_connect.py

@@ -30,7 +30,6 @@ def test_connect(self):
                 url,
                 json={
                     "identification": "string",
-                    "api": {},
                     "uri": {},
                     "openid": openid_dict,
                 },
@@ -54,7 +53,6 @@ def test_connect(self):
         # Check that the fake endpoints we returned are captured
         endpoints = pbench.endpoints
         assert endpoints
-        assert endpoints["api"] == {}
         assert endpoints["identification"] == "string"
         assert endpoints["uri"] == {}
         assert endpoints["openid"] == openid_dict

lib/pbench/test/unit/server/test_endpoint_configure.py

@@ -41,23 +41,6 @@ def check_config(self, client, server_config, host, my_headers={}):
         uri = urljoin(host, uri_prefix)
         expected_results = {
             "identification": f"Pbench server {server_config.COMMIT_ID}",
-            "api": {
-                "datasets": f"{uri}/datasets",
-                "datasets_contents": f"{uri}/datasets/contents",
-                "datasets_daterange": f"{uri}/datasets/daterange",
-                "datasets_detail": f"{uri}/datasets/detail",
-                "datasets_inventory": f"{uri}/datasets/inventory",
-                "datasets_list": f"{uri}/datasets",
-                "datasets_mappings": f"{uri}/datasets/mappings",
-                "datasets_metadata": f"{uri}/datasets/metadata",
-                "datasets_namespace": f"{uri}/datasets/namespace",
-                "datasets_search": f"{uri}/datasets/search",
-                "datasets_values": f"{uri}/datasets/values",
-                "endpoints": f"{uri}/endpoints",
-                "server_audit": f"{uri}/server/audit",
-                "server_settings": f"{uri}/server/settings",
-                "upload": f"{uri}/upload",
-            },
             "uri": {
                 "datasets": {
                     "template": f"{uri}/datasets/{{dataset}}",