server/src/main/java/org/onap/usecaseui/server/service/sotn/impl/SOTNServiceImpl.java

   1 /*
   2  * Copyright (C) 2018 CMCC, Inc. and others. All rights reserved.
   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 package org.onap.usecaseui.server.service.sotn.impl;
  17
  18 import static org.onap.usecaseui.server.util.RestfulServices.extractBody;
  19
  20 import java.io.IOException;
  21 import java.util.Collections;
  22 import java.util.List;
  23
  24 import javax.servlet.http.HttpServletRequest;
  25
  26 import org.onap.usecaseui.server.bean.sotn.Pinterface;
  27 import org.onap.usecaseui.server.bean.sotn.PinterfaceRsp;
  28 import org.onap.usecaseui.server.constant.CommonConstant;
  29 import org.onap.usecaseui.server.service.lcm.domain.aai.AAIService;
  30 import org.onap.usecaseui.server.service.lcm.domain.aai.exceptions.AAIException;
  31 import org.onap.usecaseui.server.service.lcm.domain.so.exceptions.SOException;
  32 import org.onap.usecaseui.server.service.sotn.SOTNService;
  33 import org.onap.usecaseui.server.util.RestfulServices;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  37 import org.springframework.stereotype.Service;
  38
  39 import okhttp3.RequestBody;
  40 import okhttp3.ResponseBody;
  41 import retrofit2.Response;
  42
  43 @Service("SOTNService")
  44 @org.springframework.context.annotation.Configuration
  45 @EnableAspectJAutoProxy
  46 public class SOTNServiceImpl implements SOTNService{
  47
  48     private static final Logger logger = LoggerFactory.getLogger(SOTNServiceImpl.class);
  49
  50     private AAIService aaiService;
  51
  52     public SOTNServiceImpl() {
  53         this(RestfulServices.create(AAIService.class));
  54     }
  55
  56     public SOTNServiceImpl(AAIService aaiService) {
  57         this.aaiService = aaiService;
  58         }
  59
  60         @Override
  61         public String getNetWorkResources() {
  62                 String result="";
  63         try {
  64                 logger.info("aai getNetWorkResources is starting!");
  65             Response<ResponseBody> response = this.aaiService.listNetWorkResources().execute();
  66             logger.info("aai getNetWorkResources has finished!");
  67             if (response.isSuccessful()) {
  68                 result=new String(response.body().bytes());
  69             } else {
  70                 logger.info(String.format("Can not get getNetWorkResources[code=%s, message=%s]", response.code(), response.message()));
  71                 result = CommonConstant.CONSTANT_FAILED;
  72             }
  73         } catch (IOException e) {
  74             logger.error("getNetWorkResources occur exception:"+e);
  75             result = CommonConstant.CONSTANT_FAILED;
  76         }
  77         return result;
  78         }
  79
  80         @Override
  81         public List<Pinterface> getPinterfaceByPnfName(String pnfName) {
  82         try {
  83                 logger.info("aai getPinterfaceByPnfName is starting!");
  84             Response<PinterfaceRsp> response = this.aaiService.getPinterfaceByPnfName(pnfName).execute();
  85             logger.info(String.format("excute aai interface:/api/aai-network/v13/pnfs/pnf/%s/p-interfaces",pnfName));
  86             logger.info("aai getPinterfaceByPnfName has finished!");
  87             if (response.isSuccessful()) {
  88                 return response.body().getPinterfaces();
  89             } else {
  90                 logger.info(String.format("Can not get getPinterfaceByPnfName[code=%s, message=%s]", response.code(), response.message()));
  91                 return Collections.emptyList();
  92             }
  93         } catch (IOException e) {
  94             logger.error("getPinterfaceByPnfName occur exception:"+e);
  95             throw new AAIException("AAI is not available.", e);
  96         }
  97         }
  98
  99         @Override
 100         public String getLogicalLinks() {
 101                 String result="";
 102         try {
 103                 logger.info("aai getLogicalLinks is starting!");
 104             Response<ResponseBody> response = this.aaiService.getLogicalLinks().execute();
 105             logger.info("aai getLogicalLinks has finished!");
 106             if (response.isSuccessful()) {
 107                 result=new String(response.body().bytes());
 108             } else {
 109                 logger.info(String.format("Can not get getLogicalLinks[code=%s, message=%s]", response.code(), response.message()));
 110                 result= CommonConstant.CONSTANT_FAILED;
 111             }
 112         } catch (IOException e) {
 113             logger.error("getLogicalLinks occur exception:"+e);
 114             result= CommonConstant.CONSTANT_FAILED;
 115         }
 116         return result;
 117         }
 118
 119         @Override
 120         public String getSpecificLogicalLink(String linkName) {
 121                 String result="";
 122         try {
 123                 logger.info("aai getSpecificLogicalLink is starting!");
 124             Response<ResponseBody> response = this.aaiService.getSpecificLogicalLink(linkName).execute();
 125             logger.info("aai getSpecificLogicalLink has finished!");
 126             if (response.isSuccessful()) {
 127                 result=new String(response.body().bytes());
 128             } else {
 129                 logger.info(String.format("Can not get getSpecificLogicalLink[code=%s, message=%s]", response.code(), response.message()));
 130                 result= CommonConstant.CONSTANT_FAILED;
 131             }
 132         } catch (IOException e) {
 133             logger.error("getSpecificLogicalLink occur exception:"+e);
 134             result= CommonConstant.CONSTANT_FAILED;
 135         }
 136         return result;
 137         }
 138
 139         @Override
 140         public String getHostUrl(String aaiId) {
 141                 String result="";
 142         try {
 143                 logger.info("aai getHostUrl is starting!");
 144             Response<ResponseBody> response = this.aaiService.getHostUrl(aaiId).execute();
 145             logger.info("aai getHostUrl has finished!");
 146             if (response.isSuccessful()) {
 147                 result=new String(response.body().bytes());
 148             } else {
 149                 logger.info(String.format("Can not get getHostUrl[code=%s, message=%s]", response.code(), response.message()));
 150                 result= CommonConstant.CONSTANT_FAILED;
 151             }
 152         } catch (IOException e) {
 153             logger.error("getHostUrl occur exception:"+e);
 154             result= CommonConstant.CONSTANT_FAILED;
 155         }
 156         return result;
 157         }
 158
 159         @Override
 160         public String getExtAaiId(String aaiId) {
 161                 String result="";
 162         try {
 163                 logger.info("aai getExtAaiId is starting!");
 164             Response<ResponseBody> response = this.aaiService.getExtAaiId(aaiId).execute();
 165             logger.info("aai getExtAaiId has finished!");
 166             if (response.isSuccessful()) {
 167                 result=new String(response.body().bytes());
 168             } else {
 169                 logger.info(String.format("Can not get getExtAaiId[code=%s, message=%s]", response.code(), response.message()));
 170                 result= CommonConstant.CONSTANT_FAILED;
 171             }
 172         } catch (IOException e) {
 173             logger.error("getExtAaiId occur exception:"+e);
 174             result= CommonConstant.CONSTANT_FAILED;
 175         }
 176         return result;
 177         }
 178
 179         @Override
 180         public String createHostUrl(HttpServletRequest request,String aaiId) {
 181                 String result = "";
 182         try {
 183                 logger.info("aai createHostUrl is starting");
 184                 RequestBody requestBody = extractBody(request);
 185             Response<ResponseBody> response = aaiService.createHostUrl(requestBody,aaiId).execute();
 186                         logger.info("aai createHostUrl has finished");
 187             if (response.isSuccessful()) {
 188                 result= CommonConstant.CONSTANT_SUCCESS;
 189             } else {
 190                 result= CommonConstant.CONSTANT_FAILED;
 191                 logger.error(String.format("Can not createHostUrl[code=%s, message=%s]", response.code(), response.message()));
 192             }
 193         } catch (Exception e) {
 194                 result= CommonConstant.CONSTANT_FAILED;
 195                 logger.error("createHostUrl occur exception:"+e);
 196         }
 197         return result;
 198         }
 199
 200         @Override
 201         public String createTopoNetwork(HttpServletRequest request,String networkId) {
 202                 String result = "";
 203         try {
 204                 logger.info("aai createTopoNetwork is starting");
 205                 RequestBody requestBody = extractBody(request);
 206             Response<ResponseBody> response = aaiService.createTopoNetwork(requestBody,networkId).execute();
 207                         logger.info("aai createTopoNetwork has finished");
 208             if (response.isSuccessful()) {
 209                 result= CommonConstant.CONSTANT_SUCCESS;
 210             } else {
 211                 result= CommonConstant.CONSTANT_FAILED;
 212                 logger.error(String.format("Can not createTopoNetwork[code=%s, message=%s]", response.code(), response.message()));
 213             }
 214         } catch (Exception e) {
 215                 result= CommonConstant.CONSTANT_FAILED;
 216                 logger.error("createTopoNetwork occur exception:"+e);
 217         }
 218         return result;
 219         }
 220
 221         @Override
 222         public String createTerminationPoint(HttpServletRequest request,String pnfName,String tpId) {
 223                 String result = "";
 224         try {
 225                 logger.info("aai createTerminationPoint is starting");
 226                 RequestBody requestBody = extractBody(request);
 227             Response<ResponseBody> response = aaiService.createTerminationPoint(requestBody,pnfName,tpId).execute();
 228                         logger.info("aai createTerminationPoint has finished");
 229             if (response.isSuccessful()) {
 230                 result= CommonConstant.CONSTANT_SUCCESS;
 231             } else {
 232                 result= CommonConstant.CONSTANT_FAILED;
 233                 logger.error(String.format("Can not createTerminationPoint[code=%s, message=%s]", response.code(), response.message()));
 234             }
 235         } catch (Exception e) {
 236                 result= CommonConstant.CONSTANT_FAILED;
 237                 logger.error("createTerminationPoint occur exception:"+e);
 238         }
 239         return result;
 240         }
 241
 242         @Override
 243         public String createLink(HttpServletRequest request,String linkName) {
 244                 String result = "";
 245         try {
 246                 logger.info("aai createLink is starting");
 247                 RequestBody requestBody = extractBody(request);
 248             Response<ResponseBody> response = aaiService.createLink(requestBody,linkName).execute();
 249                         logger.info("aai createLink has finished");
 250             if (response.isSuccessful()) {
 251                 result= CommonConstant.CONSTANT_SUCCESS;
 252             } else {
 253                 result= CommonConstant.CONSTANT_FAILED;
 254                 logger.error(String.format("Can not createLink[code=%s, message=%s]", response.code(), response.message()));
 255             }
 256         } catch (Exception e) {
 257                 result="FAILED";
 258                 logger.error("createLink occur exception:"+e);
 259         }
 260         return result;
 261         }
 262
 263         @Override
 264         public String createPnf(HttpServletRequest request,String pnfName) {
 265                 String result = "";
 266         try {
 267                 logger.info("aai createPnf is starting");
 268                 RequestBody requestBody = extractBody(request);
 269             Response<ResponseBody> response = aaiService.createPnf(requestBody,pnfName).execute();
 270                         logger.info("aai createPnf has finished");
 271             if (response.isSuccessful()) {
 272                 result= CommonConstant.CONSTANT_SUCCESS;
 273             } else {
 274                 result= CommonConstant.CONSTANT_FAILED;
 275                 logger.error(String.format("Can not createPnf[code=%s, message=%s]", response.code(), response.message()));
 276             }
 277         } catch (Exception e) {
 278                 result= CommonConstant.CONSTANT_FAILED;
 279                 logger.error("createPnf occur exception:"+e);
 280         }
 281         return result;
 282         }
 283
 284         @Override
 285         public String deleteLink(String linkName,String resourceVersion) {
 286                 String result = "";
 287         try {
 288                 logger.info("aai deleteLink is starting");
 289             Response<ResponseBody> response = aaiService.deleteLink(linkName,resourceVersion).execute();
 290                         logger.info("aai deleteLink has finished");
 291             if (response.isSuccessful()) {
 292                 result= CommonConstant.CONSTANT_SUCCESS;
 293             } else {
 294                 result= CommonConstant.CONSTANT_FAILED;
 295                 logger.error(String.format("Can not deleteLink[code=%s, message=%s]", response.code(), response.message()));
 296             }
 297         } catch (Exception e) {
 298                 result= CommonConstant.CONSTANT_FAILED;
 299                 logger.error("deleteLink occur exception:"+e);
 300         }
 301         return result;
 302         }
 303
 304         @Override
 305         public String getServiceInstances(String customerId, String serviceType) {
 306                 String result="";
 307         try {
 308                 logger.info("aai getServiceInstances is starting");
 309             Response<ResponseBody> response = aaiService.getServiceInstances(customerId, serviceType).execute();
 310                         logger.info("aai getServiceInstances has finished");
 311             if (response.isSuccessful()) {
 312                 result=new String(response.body().bytes());
 313             } else {
 314                 logger.error(String.format("Can not getServiceInstances[code=%s, message=%s]", response.code(), response.message()));
 315                 result= CommonConstant.CONSTANT_FAILED;
 316             }
 317         } catch (Exception e) {
 318                 logger.error("getServiceInstances occur exception:"+e);
 319                  result= CommonConstant.CONSTANT_FAILED;
 320         }
 321         return result;
 322         }
 323
 324         @Override
 325         public String serviceInstanceInfo(String customerId, String serviceType, String serviceInstanceId) {
 326         try {
 327                 logger.info("aai serviceInstanceInfo is starting");
 328             Response<ResponseBody> response = aaiService.serviceInstaneInfo(customerId, serviceType, serviceInstanceId).execute();
 329                         logger.info("aai serviceInstanceInfo has finished");
 330             if (response.isSuccessful()) {
 331                 String result=new String(response.body().bytes());
 332                 return result;
 333             } else {
 334                 logger.error(String.format("Can not serviceInstanceInfo[code=%s, message=%s]", response.code(), response.message()));
 335                 throw new SOException("aai serviceInstanceInfo failed!");
 336             }
 337         } catch (Exception e) {
 338                 logger.error("serviceInstanceInfo occur exception:"+e);
 339             throw new SOException("aai serviceInstanceInfo is not available!", e);
 340         }
 341         }
 342
 343         @Override
 344         public String getPnfInfo(String pnfName) {
 345                 String result="";
 346         try {
 347                 logger.info("aai getPnfInfo is starting!");
 348             Response<ResponseBody> response = this.aaiService.getPnfInfo(pnfName).execute();
 349             logger.info("aai getPnfInfo has finished!");
 350             if (response.isSuccessful()) {
 351                 result=new String(response.body().bytes());
 352             } else {
 353                 logger.info(String.format("Can not get getPnfInfo[code=%s, message=%s]", response.code(), response.message()));
 354                 result= CommonConstant.CONSTANT_FAILED;
 355             }
 356         } catch (IOException e) {
 357             logger.error("getPnfInfo occur exception:"+e);
 358             result= CommonConstant.CONSTANT_FAILED;
 359         }
 360         return result;
 361         }
 362
 363         @Override
 364         public String getAllottedResources(String customerId, String serviceType, String serviceId) {
 365                 String result="";
 366         try {
 367                 logger.info("aai getAllottedResources is starting!");
 368             Response<ResponseBody> response = this.aaiService.getAllottedResources(customerId, serviceType, serviceId).execute();
 369             logger.info("aai getAllottedResources has finished!");
 370             if (response.isSuccessful()) {
 371                 result=new String(response.body().bytes());
 372             } else {
 373                 logger.info(String.format("Can not get getAllottedResources[code=%s, message=%s]", response.code(), response.message()));
 374                 result= CommonConstant.CONSTANT_FAILED;
 375             }
 376         } catch (IOException e) {
 377             logger.error("getAllottedResources occur exception:"+e);
 378             result= CommonConstant.CONSTANT_FAILED;
 379         }
 380         return result;
 381         }
 382
 383         @Override
 384         public String getConnectivityInfo(String connectivityId) {
 385                 String result="";
 386         try {
 387                 logger.info("aai getConnectivityInfo is starting!");
 388             Response<ResponseBody> response = this.aaiService.getConnectivityInfo(connectivityId).execute();
 389             logger.info("aai getConnectivityInfo has finished!");
 390             if (response.isSuccessful()) {
 391                 result=new String(response.body().bytes());
 392             } else {
 393                 logger.info(String.format("Can not get getConnectivityInfo[code=%s, message=%s]", response.code(), response.message()));
 394                 result= CommonConstant.CONSTANT_FAILED;
 395             }
 396         } catch (IOException e) {
 397             logger.error("getConnectivityInfo occur exception:"+e);
 398             result= CommonConstant.CONSTANT_FAILED;
 399         }
 400         return result;
 401         }
 402
 403     @Override
 404     public String getVpnBindingInfo(String vpnId) {
 405         String result="";
 406         try {
 407             logger.info("aai getVpnBindingInfo is starting!");
 408             Response<ResponseBody> response = this.aaiService.getVpnBindingInfo(vpnId).execute();
 409             logger.info("aai getVpnBindingInfo has finished!");
 410             if (response.isSuccessful()) {
 411                 result=new String(response.body().bytes());
 412             } else {
 413                 logger.info(String.format("Can not get getVpnBindingInfo[code=%s, message=%s]", response.code(), response.message()));
 414                 result= CommonConstant.CONSTANT_FAILED;
 415             }
 416         } catch (IOException e) {
 417             logger.error("getVpnBindingInfo occur exception:"+e);
 418             result= CommonConstant.CONSTANT_FAILED;
 419         }
 420         return result;
 421     }
 422
 423     @Override
 424     public String getNetworkRouteInfo(String routeId){
 425         String result="";
 426         try {
 427             logger.info("aai getNetworkRouteInfo is starting!");
 428             Response<ResponseBody> response = this.aaiService.getNetworkRouteInfo(routeId).execute();
 429             logger.info("aai getNetworkRouteInfo has finished!");
 430             if (response.isSuccessful()) {
 431                 result=new String(response.body().bytes());
 432             } else {
 433                 logger.info(String.format("Can not get getNetworkRouteInfo[code=%s, message=%s]", response.code(), response.message()));
 434                 result= CommonConstant.CONSTANT_FAILED;
 435             }
 436         } catch (IOException e) {
 437             logger.error("getNetworkRouteInfo occur exception:"+e);
 438             result= CommonConstant.CONSTANT_FAILED;
 439         }
 440         return result;
 441     }
 442
 443         @Override
 444         public String getPinterfaceByVpnId(String vpnId) {
 445                 String result="";
 446         try {
 447                 logger.info("aai getPinterfaceByVpnId is starting!");
 448             Response<ResponseBody> response = this.aaiService.getPinterfaceByVpnId(vpnId).execute();
 449             logger.info("aai getPinterfaceByVpnId has finished!");
 450             if (response.isSuccessful()) {
 451                 result=new String(response.body().bytes());
 452             } else {
 453                 logger.info(String.format("Can not get getPinterfaceByVpnId[code=%s, message=%s]", response.code(), response.message()));
 454                 result= CommonConstant.CONSTANT_FAILED;
 455             }
 456         } catch (IOException e) {
 457             logger.error("getPinterfaceByVpnId occur exception:"+e);
 458             result= CommonConstant.CONSTANT_FAILED;
 459         }
 460         return result;
 461         }
 462
 463         @Override
 464         public String deleteExtNetwork(String networkId,String resourceVersion) {
 465                 String result = "";
 466         try {
 467                 logger.info("aai deleteExtNetwork is starting");
 468             Response<ResponseBody> response = aaiService.deleteExtNetwork(networkId,resourceVersion).execute();
 469                         logger.info("aai deleteExtNetwork has finished");
 470             if (response.isSuccessful()) {
 471                 result= CommonConstant.CONSTANT_SUCCESS;
 472             } else {
 473                 result= CommonConstant.CONSTANT_FAILED;
 474                 logger.error(String.format("Can not deleteExtNetwork[code=%s, message=%s]", response.code(), response.message()));
 475             }
 476         } catch (Exception e) {
 477                 result= CommonConstant.CONSTANT_FAILED;
 478                 logger.error("deleteExtNetwork occur exception:"+e);
 479         }
 480         return result;
 481         }
 482 }