server/src/main/java/org/onap/usecaseui/server/service/lcm/impl/DefaultServiceLcmService.java

   1 /**
   2  * Copyright 2016-2017 ZTE 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 package org.onap.usecaseui.server.service.lcm.impl;
  17
  18 import static org.onap.usecaseui.server.util.RestfulServices.create;
  19 import static org.onap.usecaseui.server.util.RestfulServices.extractBody;
  20
  21 import java.io.IOException;
  22 import java.util.ArrayList;
  23 import java.util.List;
  24
  25 import javax.persistence.EntityManager;
  26 import javax.persistence.EntityManagerFactory;
  27 import javax.persistence.PersistenceContext;
  28 import javax.servlet.http.HttpServletRequest;
  29
  30 import com.google.common.base.Throwables;
  31 import javax.transaction.Transactional;
  32 import org.hibernate.Query;
  33 import org.hibernate.Session;
  34 import org.hibernate.SessionFactory;
  35 import org.hibernate.Transaction;
  36 import org.onap.usecaseui.server.bean.ServiceBean;
  37 import org.onap.usecaseui.server.bean.ServiceInstanceOperations;
  38 import org.onap.usecaseui.server.service.lcm.ServiceLcmService;
  39 import org.onap.usecaseui.server.service.lcm.domain.so.SOService;
  40 import org.onap.usecaseui.server.service.lcm.domain.so.bean.DeleteOperationRsp;
  41 import org.onap.usecaseui.server.service.lcm.domain.so.bean.OperationProgressInformation;
  42 import org.onap.usecaseui.server.service.lcm.domain.so.bean.SaveOrUpdateOperationRsp;
  43 import org.onap.usecaseui.server.service.lcm.domain.so.bean.ServiceOperation;
  44 import org.onap.usecaseui.server.service.lcm.domain.so.exceptions.SOException;
  45 import org.onap.usecaseui.server.util.DateUtils;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48 import org.springframework.beans.factory.annotation.Autowired;
  49 import org.springframework.stereotype.Service;
  50
  51 import okhttp3.RequestBody;
  52 import retrofit2.Response;
  53
  54 @Service("ServiceLcmService")
  55 @Transactional
  56 public class DefaultServiceLcmService implements ServiceLcmService {
  57
  58     private static final Logger logger = LoggerFactory.getLogger(DefaultServiceLcmService.class);
  59
  60     @Autowired
  61     private EntityManagerFactory entityManagerFactory;
  62
  63     public Session getSession() {
  64         return entityManagerFactory.unwrap(SessionFactory.class).getCurrentSession();}
  65
  66     private SOService soService;
  67
  68     public DefaultServiceLcmService() {
  69         this(create(SOService.class));
  70     }
  71
  72     public DefaultServiceLcmService(SOService soService) {
  73         this.soService = soService;
  74     }
  75
  76     @Override
  77     public ServiceOperation instantiateService(HttpServletRequest request) {
  78         try {
  79             logger.info("so instantiate is starting");
  80             RequestBody requestBody = extractBody(request);
  81             Response<ServiceOperation> response = soService.instantiateService(requestBody).execute();
  82             logger.info("so instantiate has finished");
  83             if (response.isSuccessful()) {
  84                 return response.body();
  85             } else {
  86                 logger.error(String.format("Can not instantiate service[code=%s, message=%s]", response.code(),
  87                         response.message()));
  88                 throw new SOException("SO instantiate service failed!");
  89             }
  90         } catch (Exception e) {
  91             throw new SOException("SO Service is not available!", e);
  92         }
  93     }
  94
  95     @Override
  96     public OperationProgressInformation queryOperationProgress(String serviceId, String operationId) {
  97         try {
  98             Response<OperationProgressInformation> response =
  99                     soService.queryOperationProgress(serviceId, operationId).execute();
 100             if (response.isSuccessful()) {
 101                 return response.body();
 102             } else {
 103                 logger.error(String.format("Can not query operation process[code=%s, message=%s]", response.code(),
 104                         response.message()));
 105                 throw new SOException("SO query operation process failed!");
 106             }
 107         } catch (IOException e) {
 108             throw new SOException("SO Service is not available!", e);
 109         }
 110     }
 111
 112     @Override
 113     public DeleteOperationRsp terminateService(String serviceId, HttpServletRequest request) {
 114         try {
 115             logger.info("so terminate is starting");
 116             RequestBody requestBody = extractBody(request);
 117             Response<DeleteOperationRsp> response = soService.terminateService(serviceId, requestBody).execute();
 118             logger.info("so terminate has finished");
 119             if (response.isSuccessful()) {
 120                 return response.body();
 121             } else {
 122                 logger.error(String.format("Can not terminate service[code=%s, message=%s]", response.code(),
 123                         response.message()));
 124                 throw new SOException("SO terminate service failed!");
 125             }
 126         } catch (IOException e) {
 127             throw new SOException("SO Service is not available!", e);
 128         }
 129     }
 130
 131     @Override
 132     public SaveOrUpdateOperationRsp scaleService(String serviceId, HttpServletRequest request) {
 133         try {
 134             logger.info("so scale is finished");
 135             RequestBody requestBody = extractBody(request);
 136             Response<SaveOrUpdateOperationRsp> response = soService.scaleService(serviceId, requestBody).execute();
 137             logger.info("so scale has finished");
 138             if (response.isSuccessful()) {
 139                 logger.info("scaleService response content is :" + response.body().toString());
 140                 return response.body();
 141             } else {
 142                 logger.error(String.format("Can not scaleService service[code=%s, message=%s]", response.code(),
 143                         response.message()));
 144                 throw new SOException("SO terminate service failed!");
 145             }
 146         } catch (IOException e) {
 147             throw new SOException("SO Service is not available!", e);
 148         }
 149     }
 150
 151     @Override
 152     public SaveOrUpdateOperationRsp updateService(String serviceId, HttpServletRequest request) {
 153         try {
 154             logger.info("so update is starting");
 155             RequestBody requestBody = extractBody(request);
 156             Response<SaveOrUpdateOperationRsp> response = soService.updateService(serviceId, requestBody).execute();
 157             logger.info("so update has finished");
 158             if (response.isSuccessful()) {
 159                 return response.body();
 160             } else {
 161                 logger.error(String.format("Can not updateService service[code=%s, message=%s]", response.code(),
 162                         response.message()));
 163                 throw new SOException("SO terminate service failed!");
 164             }
 165         } catch (IOException e) {
 166             throw new SOException("SO Service is not available!", e);
 167         }
 168     }
 169
 170     @Override
 171     public void saveOrUpdateServiceBean(ServiceBean serviceBean) {
 172         Session session = getSession();
 173         try  {
 174             if (null == serviceBean) {
 175                 logger.error("DefaultServiceLcmService saveOrUpdateServiceBean serviceBean is null!");
 176             }
 177             Transaction tx = session.beginTransaction();
 178             session.saveOrUpdate(serviceBean);
 179             tx.commit();
 180             session.flush();
 181         } catch (Exception e) {
 182             logger.error(
 183                     "exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceBean. Details:"
 184                             + e.getMessage());
 185         }
 186     }
 187
 188     @Override
 189     public void updateServiceInstanceStatusById(String status, String serviceInstanceId) {
 190         Session session = getSession();
 191         try  {
 192             String string = "update ServiceBean set status=:status where 1=1 and serviceInstanceId=:serviceInstanceId";
 193             Query q = session.createQuery(string);
 194             q.setString("status", status);
 195             q.setString("serviceInstanceId", serviceInstanceId);
 196             q.executeUpdate();
 197             session.flush();
 198         } catch (Exception e) {
 199             logger.error(
 200                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusById.Detail."
 201                             + e.getMessage());
 202         }
 203     }
 204
 205     @Override
 206     public ServiceBean getServiceBeanByServiceInStanceId(String serviceInstanceId) {
 207         ServiceBean serviceBean = null;
 208         Session session = getSession();
 209         try  {
 210
 211             String string = "from ServiceBean  where 1=1 and serviceInstanceId=:serviceInstanceId";
 212             Query q = session.createQuery(string);
 213             q.setString("serviceInstanceId", serviceInstanceId);
 214             List<ServiceBean> list = q.list();
 215             session.flush();
 216             if (list.size() > 0) {
 217                 serviceBean = list.get(0);
 218             }
 219         } catch (Exception e) {
 220             logger.error(
 221                     "exception occurred while performing DefaultServiceLcmService getServiceBeanByServiceInStanceId.Detail."
 222                             + e.getMessage());
 223             serviceBean = new ServiceBean();;
 224         }
 225         return serviceBean;
 226
 227     }
 228
 229     @Override
 230     public List<String> getServiceInstanceIdByParentId(String parentServiceInstanceId) {
 231         List<String> list = new ArrayList<>();
 232         Session session = getSession();
 233         try  {
 234
 235             String string = "from ServiceBean  where 1=1 and parentServiceInstanceId=:parentServiceInstanceId";
 236             Query q = session.createQuery(string);
 237             q.setString("parentServiceInstanceId", parentServiceInstanceId);
 238             list = q.list();
 239             session.flush();
 240         } catch (Exception e) {
 241             list = new ArrayList<>();
 242             logger.error(
 243                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusByIdDetail."
 244                             + e.getMessage());
 245         }
 246         return list;
 247
 248     }
 249
 250     @Override
 251     public void saveOrUpdateServiceInstanceOperation(ServiceInstanceOperations serviceOperation) {
 252         Session session = getSession();
 253         try  {
 254             if (null == serviceOperation) {
 255                 logger.error("DefaultServiceLcmService saveOrUpdateServiceBean serviceOperation is null!");
 256             }
 257             session.saveOrUpdate(serviceOperation);
 258             session.flush();
 259         } catch (Exception e) {
 260             logger.error(
 261                     "exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceInstanceOperation. Details:"
 262                             + Throwables.getStackTraceAsString(e));
 263             logger.error(
 264                     "exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceInstanceOperation. Details:"
 265                             + e.getMessage());
 266         }
 267     }
 268
 269     @Override
 270     public void updateServiceInstanceOperation(String serviceInstanceId, String operationType, String progress,
 271             String operationResult) {
 272         List<ServiceInstanceOperations> list = new ArrayList<>();
 273         Session session = getSession();
 274         try {
 275             String hql =
 276                     "select a.* from service_instance_operations a where service_instance_id =:serviceId and operation_type =:operationType and start_time = (select max(start_time) from service_instance_operations where service_instance_id=:serviceInstanceId )";
 277             Query q = session.createSQLQuery(hql).addEntity(ServiceInstanceOperations.class);
 278             q.setString("serviceId", serviceInstanceId);
 279             q.setString("serviceInstanceId", serviceInstanceId);
 280             q.setString("operationType", operationType);
 281             list = q.list();
 282             ServiceInstanceOperations serviceOperation = list.get(0);
 283             serviceOperation.setOperationResult(operationResult);
 284             serviceOperation.setOperationProgress(progress);
 285             if ("100".equals(progress)) {
 286                 serviceOperation.setEndTime(DateUtils.dateToString(DateUtils.now()));
 287             }
 288             session.saveOrUpdate(serviceOperation);
 289             session.flush();
 290
 291         } catch (Exception e) {
 292             logger.error(
 293                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceOperation.Detail."
 294                             + e.getMessage());
 295         }
 296     }
 297
 298     @Override
 299     public ServiceInstanceOperations getServiceInstanceOperationById(String serviceId) {
 300         ServiceInstanceOperations serviceOperation = null;
 301         List<ServiceInstanceOperations> list = new ArrayList<>();
 302         Session session = getSession();
 303         try  {
 304             String hql =
 305                     "select a.* from service_instance_operations a where service_instance_id =:serviceId and start_time = (select max(start_time) from service_instance_operations where service_instance_id=:serviceInstanceId)";
 306             Query q = session.createSQLQuery(hql).addEntity(ServiceInstanceOperations.class);
 307             q.setString("serviceId", serviceId);
 308             q.setString("serviceInstanceId", serviceId);
 309             q.list();
 310             list = q.list();
 311             if (!list.isEmpty()) {
 312                 serviceOperation = list.get(0);
 313             } else {
 314                 serviceOperation = new ServiceInstanceOperations();
 315             }
 316             session.flush();
 317
 318         } catch (Exception e) {
 319             logger.error("exception occurred while performing DefaultServiceLcmService getServiceInstanceOperationById."
 320                     + e.getMessage());
 321         }
 322         return serviceOperation;
 323
 324
 325     }
 326
 327
 328         @Override
 329         public List<ServiceBean> getAllServiceBean() {
 330         List<ServiceBean> list = new ArrayList<ServiceBean>();
 331         Session session = getSession();
 332         try  {
 333
 334             String string = "from ServiceBean";
 335             Query q = session.createQuery(string);
 336             list = q.list();
 337             session.flush();
 338         } catch (Exception e) {
 339             list = new ArrayList<>();
 340             logger.error(
 341                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusByIdDetail."
 342                             + e.getMessage());
 343         }
 344         return list;
 345
 346     }
 347
 348
 349
 350 }