Merge "Stream Files handling CommonUtil.java"
[vfc/nfvo/driver/vnfm/svnfm.git] / nokiav2 / driver / src / main / java / org / onap / vfc / nfvo / driver / vnfm / svnfm / nokia / onap / core / SelfRegistrationManager.java
1 /*
2  * Copyright 2016-2017, Nokia Corporation
3  *
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
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
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.
15  */
16
17 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core;
18
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;
33
34 import java.util.ArrayList;
35 import java.util.HashSet;
36
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;
40
41 /**
42  * Responsible for registering the driver in the core systems.
43  */
44 @Component
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;
55
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;
63
64     @Autowired
65     SelfRegistrationManager(DriverProperties driverProperties, MsbApiProvider msbApiProvider, CbamRestApiProvider cbamRestApiProvider) {
66         this.cbamRestApiProvider = cbamRestApiProvider;
67         this.msbApiProvider = msbApiProvider;
68         this.driverProperties = driverProperties;
69     }
70
71     /**
72      * Register the driver in micro-service bus and subscribe to LCNs from CBAM
73      */
74     public void register() {
75         //the order is important (only publish it's existence after the subscription has been created)
76         subscribeToLcn(driverProperties.getVnfmId());
77         try {
78             registerMicroService();
79         } catch (RuntimeException e) {
80             deleteSubscription(driverProperties.getVnfmId());
81             throw e;
82         }
83         ready = true;
84     }
85
86     /**
87      * De-register the VNFM driver from the micro-service bus
88      */
89     public void deRegister() {
90         try {
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
95             try {
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)
102             }
103         }
104         deleteSubscription(driverProperties.getVnfmId());
105     }
106
107     /**
108      * @return the swagger API definition
109      */
110     public byte[] getSwaggerApiDefinition() {
111         return SystemFunctions.systemFunctions().loadFile(SWAGGER_API_DEFINITION);
112     }
113
114     private String getDriverVnfmUrl() {
115         return "http://" + driverVnfmExternalIp + ":" + driverPort + DriverProperties.BASE_URL;
116     }
117
118     private void deleteSubscription(String vnfmId) {
119         logger.info("Deleting CBAM LCN subscription");
120         SubscriptionsApi lcnApi = cbamRestApiProvider.getCbamLcnApi(vnfmId);
121         try {
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);
126                 }
127             }
128         } catch (ApiException e) {
129             logger.error("Unable to delete CBAM LCN subscription");
130             throw new RuntimeException(e);
131         }
132     }
133
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);
150         node.setTtl("0");
151         try {
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);
156         }
157     }
158
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);
163         try {
164             for (Subscription subscription : lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)) {
165                 if (subscription.getCallbackUrl().equals(callbackUrl)) {
166                     return;
167                 }
168             }
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);
185         }
186     }
187
188     /**
189      * @return is the component ready to serve requests
190      */
191     public boolean isReady() {
192         return ready;
193     }
194 }