2 * Copyright 2016-2017, Nokia Corporation
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core;
19 import com.nokia.cbam.lcn.v32.ApiException;
20 import com.nokia.cbam.lcn.v32.api.SubscriptionsApi;
21 import com.nokia.cbam.lcn.v32.model.*;
22 import org.onap.msb.sdk.discovery.common.RouteException;
23 import org.onap.msb.sdk.discovery.entity.MicroServiceFullInfo;
24 import org.onap.msb.sdk.discovery.entity.MicroServiceInfo;
25 import org.onap.msb.sdk.discovery.entity.Node;
26 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions;
27 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider;
28 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties;
29 import org.slf4j.Logger;
30 import org.springframework.beans.factory.annotation.Autowired;
31 import org.springframework.beans.factory.annotation.Value;
32 import org.springframework.stereotype.Component;
34 import java.util.ArrayList;
35 import java.util.HashSet;
37 import static com.nokia.cbam.lcn.v32.model.SubscriptionAuthentication.TypeEnum.NONE;
38 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCN_API_VERSION;
39 import static org.slf4j.LoggerFactory.getLogger;
42 * Responsible for registering the driver in the core systems.
45 public class SelfRegistrationManager {
46 public static final String DRIVER_VERSION = "v1";
47 public static final String SERVICE_NAME = "NokiaSVNFM";
48 // 1 means internal 0 means core :)
49 public static final String INTERNAL_SERVICE = "1";
50 public static final String SWAGGER_API_DEFINITION = "self.swagger.json";
51 private static Logger logger = getLogger(SelfRegistrationManager.class);
52 private final DriverProperties driverProperties;
53 private final MsbApiProvider msbApiProvider;
54 private final CbamRestApiProvider cbamRestApiProvider;
56 @Value("${driverMsbExternalIp}")
57 private String driverMsbExternalIp;
58 @Value("${driverVnfmExternalIp}")
59 private String driverVnfmExternalIp;
60 @Value("${server.port}")
61 private String driverPort;
62 private volatile boolean ready = false;
65 SelfRegistrationManager(DriverProperties driverProperties, MsbApiProvider msbApiProvider, CbamRestApiProvider cbamRestApiProvider) {
66 this.cbamRestApiProvider = cbamRestApiProvider;
67 this.msbApiProvider = msbApiProvider;
68 this.driverProperties = driverProperties;
72 * Register the driver in micro-service bus and subscribe to LCNs from CBAM
74 public void register() {
75 //the order is important (only publish it's existence after the subscription has been created)
76 subscribeToLcn(driverProperties.getVnfmId());
78 registerMicroService();
79 } catch (RuntimeException e) {
80 deleteSubscription(driverProperties.getVnfmId());
87 * De-register the VNFM driver from the micro-service bus
89 public void deRegister() {
91 logger.info("Cancelling micro service registration");
92 msbApiProvider.getMsbClient().cancelMicroServiceInfo(SERVICE_NAME, DRIVER_VERSION);
93 } catch (RouteException e) {
94 //ONAP throws 500 internal server error, but deletes the micro service
96 MicroServiceFullInfo microServiceFullInfo = msbApiProvider.getMsbClient().queryMicroServiceInfo(SERVICE_NAME, DRIVER_VERSION);
97 logger.error("Unable to deRegister Nokia VNFM driver", e);
98 //the micro service still exists
99 throw new RuntimeException(e);
100 } catch (RouteException e1) {
101 // the micro service was deleted (even though 500 HTTP code was reported)
104 deleteSubscription(driverProperties.getVnfmId());
108 * @return the swagger API definition
110 public byte[] getSwaggerApiDefinition() {
111 return SystemFunctions.systemFunctions().loadFile(SWAGGER_API_DEFINITION);
114 private String getDriverVnfmUrl() {
115 return "http://" + driverVnfmExternalIp + ":" + driverPort + DriverProperties.BASE_URL;
118 private void deleteSubscription(String vnfmId) {
119 logger.info("Deleting CBAM LCN subscription");
120 SubscriptionsApi lcnApi = cbamRestApiProvider.getCbamLcnApi(vnfmId);
122 String callbackUrl = getDriverVnfmUrl() + DriverProperties.LCN_PATH;
123 for (Subscription subscription : lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)) {
124 if (subscription.getCallbackUrl().equals(callbackUrl)) {
125 lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
128 } catch (ApiException e) {
129 logger.error("Unable to delete CBAM LCN subscription");
130 throw new RuntimeException(e);
134 private MicroServiceFullInfo registerMicroService() {
135 logger.info("Registering micro service");
136 MicroServiceInfo microServiceInfo = new MicroServiceInfo();
137 microServiceInfo.setUrl(DriverProperties.BASE_URL);
138 //the PATH should not be set
139 microServiceInfo.setProtocol("REST");
140 microServiceInfo.setVisualRange(INTERNAL_SERVICE);
141 microServiceInfo.setServiceName(SERVICE_NAME);
142 microServiceInfo.setVersion(DRIVER_VERSION);
143 //FIXME set enable_ssl to false after the field has been added to MSB SDK
144 //currently defaults to false, which is good
145 Node node = new Node();
146 microServiceInfo.setNodes(new HashSet<>());
147 microServiceInfo.getNodes().add(node);
148 node.setIp(driverMsbExternalIp);
149 node.setPort(driverPort);
152 return msbApiProvider.getMsbClient().registerMicroServiceInfo(microServiceInfo);
153 } catch (RouteException e) {
154 logger.error("Unable to register Nokia VNFM driver", e);
155 throw new RuntimeException(e);
159 private void subscribeToLcn(String vnfmId) {
160 String callbackUrl = getDriverVnfmUrl() + DriverProperties.LCN_PATH;
161 logger.info("Subscribing to CBAM LCN " + driverProperties.getCbamLcnUrl() + " with callback to " + callbackUrl);
162 SubscriptionsApi lcnApi = cbamRestApiProvider.getCbamLcnApi(vnfmId);
164 for (Subscription subscription : lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)) {
165 if (subscription.getCallbackUrl().equals(callbackUrl)) {
169 CreateSubscriptionRequest request = new CreateSubscriptionRequest();
170 request.setFilter(new SubscriptionFilter());
171 request.getFilter().setNotificationTypes(new ArrayList<>());
172 request.getFilter().getNotificationTypes().add(VnfNotificationType.VNFLIFECYCLECHANGENOTIFICATION);
173 request.setCallbackUrl(callbackUrl);
174 request.getFilter().addOperationTypesItem(OperationType.HEAL);
175 request.getFilter().addOperationTypesItem(OperationType.INSTANTIATE);
176 request.getFilter().addOperationTypesItem(OperationType.SCALE);
177 request.getFilter().addOperationTypesItem(OperationType.TERMINATE);
178 SubscriptionAuthentication subscriptionAuthentication = new SubscriptionAuthentication();
179 subscriptionAuthentication.setType(NONE);//FIXME improve authentication
180 request.setAuthentication(subscriptionAuthentication);
181 lcnApi.subscriptionsPost(request, NOKIA_LCN_API_VERSION);
182 } catch (ApiException e) {
183 logger.error("Unable to subscribe to CBAM LCN", e);
184 throw new RuntimeException(e);
189 * @return is the component ready to serve requests
191 public boolean isReady() {