dashboard/webapp-backend/src/main/java/org/oransc/ric/portal/dashboard/controller/AppManagerController.java

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2019 AT&T Intellectual Property
   6  * %%
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ========================LICENSE_END===================================
  19  */
  20 package org.oransc.ric.portal.dashboard.controller;
  21
  22 import java.lang.invoke.MethodHandles;
  23
  24 import org.oransc.ric.plt.appmgr.client.api.HealthApi;
  25 import org.oransc.ric.plt.appmgr.client.api.XappApi;
  26 import org.oransc.ric.plt.appmgr.client.model.AllDeployableXapps;
  27 import org.oransc.ric.plt.appmgr.client.model.AllDeployedXapps;
  28 import org.oransc.ric.plt.appmgr.client.model.AllXappConfig;
  29 import org.oransc.ric.plt.appmgr.client.model.ConfigValidationErrors;
  30 import org.oransc.ric.plt.appmgr.client.model.XAppConfig;
  31 import org.oransc.ric.plt.appmgr.client.model.Xapp;
  32 import org.oransc.ric.plt.appmgr.client.model.XappDescriptor;
  33 import org.oransc.ric.portal.dashboard.DashboardApplication;
  34 import org.oransc.ric.portal.dashboard.DashboardConstants;
  35 import org.oransc.ric.portal.dashboard.config.AppManagerApiBuilder;
  36 import org.oransc.ric.portal.dashboard.model.AppTransport;
  37 import org.oransc.ric.portal.dashboard.model.DashboardDeployableXapps;
  38 import org.oransc.ric.portal.dashboard.model.SuccessTransport;
  39 import org.slf4j.Logger;
  40 import org.slf4j.LoggerFactory;
  41 import org.springframework.beans.factory.annotation.Autowired;
  42 import org.springframework.context.annotation.Configuration;
  43 import org.springframework.http.MediaType;
  44 import org.springframework.http.ResponseEntity;
  45 import org.springframework.security.access.annotation.Secured;
  46 import org.springframework.util.Assert;
  47 import org.springframework.web.bind.annotation.DeleteMapping;
  48 import org.springframework.web.bind.annotation.GetMapping;
  49 import org.springframework.web.bind.annotation.PathVariable;
  50 import org.springframework.web.bind.annotation.PostMapping;
  51 import org.springframework.web.bind.annotation.PutMapping;
  52 import org.springframework.web.bind.annotation.RequestBody;
  53 import org.springframework.web.bind.annotation.RequestMapping;
  54 import org.springframework.web.bind.annotation.RestController;
  55
  56 import io.swagger.annotations.ApiOperation;
  57
  58 /**
  59  * Proxies calls from the front end to the App Manager API.
  60  *
  61  * If a method throws RestClientResponseException, it is handled by
  62  * {@link CustomResponseEntityExceptionHandler#handleProxyMethodException(Exception, org.springframework.web.context.request.WebRequest)}
  63  * which returns status 502. All other exceptions are handled by Spring which
  64  * returns status 500.
  65  */
  66 @Configuration
  67 @RestController
  68 @RequestMapping(value = AppManagerController.CONTROLLER_PATH, produces = MediaType.APPLICATION_JSON_VALUE)
  69 public class AppManagerController {
  70
  71         private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
  72
  73         // Publish paths in constants so tests are easy to write
  74         public static final String CONTROLLER_PATH = DashboardConstants.ENDPOINT_PREFIX + "/appmgr";
  75         public static final String HEALTH_ALIVE_METHOD = "health/alive";
  76         public static final String HEALTH_READY_METHOD = "health/ready";
  77         public static final String CONFIG_METHOD = "config";
  78         public static final String XAPPS_METHOD = "xapps";
  79         public static final String XAPPS_LIST_METHOD = XAPPS_METHOD + "/list";
  80         // Path parameters
  81         public static final String PP_XAPP_NAME = "xAppName";
  82         // minimize repeats
  83         private static final String CONFIG_METHOD_PATH = DashboardConstants.RIC_INSTANCE_KEY + "/{"
  84                         + DashboardConstants.RIC_INSTANCE_KEY + "}/" + CONFIG_METHOD;
  85         private static final String XAPPS_METHOD_PATH = DashboardConstants.RIC_INSTANCE_KEY + "/{"
  86                         + DashboardConstants.RIC_INSTANCE_KEY + "}/" + XAPPS_METHOD;
  87
  88         // Populated by the autowired constructor
  89         private final AppManagerApiBuilder appManagerApiBuilder;
  90
  91         @Autowired
  92         public AppManagerController(final AppManagerApiBuilder appManagerApiBuilder) {
  93                 Assert.notNull(appManagerApiBuilder, "builder must not be null");
  94                 this.appManagerApiBuilder = appManagerApiBuilder;
  95                 if (logger.isDebugEnabled())
  96                         logger.debug("ctor: configured with builder type {}", appManagerApiBuilder.getClass().getName());
  97         }
  98
  99         @ApiOperation(value = "Gets the App manager client library MANIFEST.MF property Implementation-Version.", response = SuccessTransport.class)
 100         @GetMapping(DashboardConstants.VERSION_METHOD)
 101         // No role required
 102         public SuccessTransport getClientVersion() {
 103                 return new SuccessTransport(200, DashboardApplication.getImplementationVersion(HealthApi.class));
 104         }
 105
 106         @ApiOperation(value = "Health check of App Manager - Liveness probe.")
 107         @GetMapping(DashboardConstants.RIC_INSTANCE_KEY + "/{" + DashboardConstants.RIC_INSTANCE_KEY + "}/"
 108                         + HEALTH_ALIVE_METHOD)
 109         // No role required
 110         public ResponseEntity<String> getHealth(@PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey) {
 111                 logger.debug("getHealthAlive instance {}", instanceKey);
 112                 HealthApi api = appManagerApiBuilder.getHealthApi(instanceKey);
 113                 api.getHealthAlive();
 114                 return ResponseEntity.status(api.getApiClient().getStatusCode().value()).body(null);
 115         }
 116
 117         @ApiOperation(value = "Readiness check of App Manager - Readiness probe.")
 118         @GetMapping(DashboardConstants.RIC_INSTANCE_KEY + "/{" + DashboardConstants.RIC_INSTANCE_KEY + "}/"
 119                         + HEALTH_READY_METHOD)
 120         // No role required
 121         public ResponseEntity<String> getHealthReady(
 122                         @PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey) {
 123                 logger.debug("getHealthReady instance {}", instanceKey);
 124                 HealthApi api = appManagerApiBuilder.getHealthApi(instanceKey);
 125                 api.getHealthReady();
 126                 return ResponseEntity.status(api.getApiClient().getStatusCode().value()).body(null);
 127         }
 128
 129         @ApiOperation(value = "Returns the configuration of all Xapps.", response = AllXappConfig.class)
 130         @GetMapping(CONFIG_METHOD_PATH)
 131         @Secured({ DashboardConstants.ROLE_ADMIN, DashboardConstants.ROLE_STANDARD })
 132         public AllXappConfig getAllXappConfig(@PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey) {
 133                 logger.debug("getAllXappConfig instance {}", instanceKey);
 134                 return appManagerApiBuilder.getXappApi(instanceKey).getAllXappConfig();
 135         }
 136
 137         @ApiOperation(value = "Modify XApp config.", response = ConfigValidationErrors.class)
 138         @PutMapping(CONFIG_METHOD_PATH)
 139         @Secured({ DashboardConstants.ROLE_ADMIN })
 140         public ConfigValidationErrors modifyXappConfig(
 141                         @PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey, @RequestBody XAppConfig xAppConfig) {
 142                 logger.debug("modifyXappConfig instance {} config {}", instanceKey, xAppConfig);
 143                 return appManagerApiBuilder.getXappApi(instanceKey).modifyXappConfig(xAppConfig);
 144         }
 145
 146         @ApiOperation(value = "Returns a list of deployable xapps.", response = DashboardDeployableXapps.class)
 147         @GetMapping(DashboardConstants.RIC_INSTANCE_KEY + "/{" + DashboardConstants.RIC_INSTANCE_KEY + "}/"
 148                         + XAPPS_LIST_METHOD)
 149         @Secured({ DashboardConstants.ROLE_ADMIN, DashboardConstants.ROLE_STANDARD })
 150         public DashboardDeployableXapps getAvailableXapps(
 151                         @PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey) {
 152                 logger.debug("getAvailableXapps instance {}", instanceKey);
 153                 AllDeployableXapps deployableXapps = appManagerApiBuilder.getXappApi(instanceKey).listAllXapps();
 154                 // Answer a collection of structure instead of string
 155                 // because I expect the AppMgr to be extended with
 156                 // additional properties for each one.
 157                 DashboardDeployableXapps apps = new DashboardDeployableXapps();
 158                 for (String n : deployableXapps)
 159                         apps.add(new AppTransport(n));
 160                 return apps;
 161         }
 162
 163         @ApiOperation(value = "Returns the status of all deployed xapps.", response = AllDeployedXapps.class)
 164         @GetMapping(XAPPS_METHOD_PATH)
 165         @Secured({ DashboardConstants.ROLE_ADMIN, DashboardConstants.ROLE_STANDARD })
 166         public AllDeployedXapps getDeployedXapps(@PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey) {
 167                 logger.debug("getDeployedXapps instance {}", instanceKey);
 168                 return appManagerApiBuilder.getXappApi(instanceKey).getAllXapps();
 169         }
 170
 171         @ApiOperation(value = "Returns the status of a given xapp.", response = Xapp.class)
 172         @GetMapping(XAPPS_METHOD_PATH + "/{" + PP_XAPP_NAME + "}")
 173         @Secured({ DashboardConstants.ROLE_ADMIN, DashboardConstants.ROLE_STANDARD })
 174         public Xapp getXapp(@PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey,
 175                         @PathVariable(PP_XAPP_NAME) String appName) {
 176                 logger.debug("getXapp instance {} name {}", instanceKey, appName);
 177                 return appManagerApiBuilder.getXappApi(instanceKey).getXappByName(appName);
 178         }
 179
 180         @ApiOperation(value = "Deploy a xapp.", response = Xapp.class)
 181         @PostMapping(XAPPS_METHOD_PATH)
 182         @Secured({ DashboardConstants.ROLE_ADMIN })
 183         public Xapp deployXapp(@PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey,
 184                         @RequestBody XappDescriptor appDescriptor) {
 185                 logger.debug("deployXapp instance {} descriptor {}", instanceKey, appDescriptor);
 186                 return appManagerApiBuilder.getXappApi(instanceKey).deployXapp(appDescriptor);
 187         }
 188
 189         @ApiOperation(value = "Undeploy an existing xapp.")
 190         @DeleteMapping(XAPPS_METHOD_PATH + "/{" + PP_XAPP_NAME + "}")
 191         @Secured({ DashboardConstants.ROLE_ADMIN })
 192         public ResponseEntity<String> undeployXapp(@PathVariable(DashboardConstants.RIC_INSTANCE_KEY) String instanceKey,
 193                         @PathVariable(PP_XAPP_NAME) String appName) {
 194                 logger.debug("undeployXapp instance {} name {}", instanceKey, appName);
 195                 XappApi api = appManagerApiBuilder.getXappApi(instanceKey);
 196                 api.undeployXapp(appName);
 197                 return ResponseEntity.status(api.getApiClient().getStatusCode().value()).body(null);
 198         }
 199
 200 }