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             session.saveOrUpdate(serviceBean);
 178             session.flush();
 179         } catch (Exception e) {
 180             logger.error(
 181                     "exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceBean. Details:"
 182                             + e.getMessage());
 183         }
 184     }
 185
 186     @Override
 187     public void updateServiceInstanceStatusById(String status, String serviceInstanceId) {
 188         Session session = getSession();
 189         try  {
 190             String string = "update ServiceBean set status=:status where 1=1 and serviceInstanceId=:serviceInstanceId";
 191             Query q = session.createQuery(string);
 192             q.setString("status", status);
 193             q.setString("serviceInstanceId", serviceInstanceId);
 194             q.executeUpdate();
 195             session.flush();
 196         } catch (Exception e) {
 197             logger.error(
 198                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusById.Detail."
 199                             + e.getMessage());
 200         }
 201     }
 202
 203     @Override
 204     public ServiceBean getServiceBeanByServiceInStanceId(String serviceInstanceId) {
 205         ServiceBean serviceBean = null;
 206         Session session = getSession();
 207         try  {
 208
 209             String string = "from ServiceBean  where 1=1 and serviceInstanceId=:serviceInstanceId";
 210             Query q = session.createQuery(string);
 211             q.setString("serviceInstanceId", serviceInstanceId);
 212             List<ServiceBean> list = q.list();
 213             session.flush();
 214             if (list.size() > 0) {
 215                 serviceBean = list.get(0);
 216             }
 217         } catch (Exception e) {
 218             logger.error(
 219                     "exception occurred while performing DefaultServiceLcmService getServiceBeanByServiceInStanceId.Detail."
 220                             + e.getMessage());
 221             serviceBean = new ServiceBean();;
 222         }
 223         return serviceBean;
 224
 225     }
 226
 227     @Override
 228     public List<String> getServiceInstanceIdByParentId(String parentServiceInstanceId) {
 229         List<String> list = new ArrayList<>();
 230         Session session = getSession();
 231         try  {
 232
 233             String string = "from ServiceBean  where 1=1 and parentServiceInstanceId=:parentServiceInstanceId";
 234             Query q = session.createQuery(string);
 235             q.setString("parentServiceInstanceId", parentServiceInstanceId);
 236             list = q.list();
 237             session.flush();
 238         } catch (Exception e) {
 239             list = new ArrayList<>();
 240             logger.error(
 241                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusByIdDetail."
 242                             + e.getMessage());
 243         }
 244         return list;
 245
 246     }
 247
 248     @Override
 249     public void saveOrUpdateServiceInstanceOperation(ServiceInstanceOperations serviceOperation) {
 250         Session session = getSession();
 251         try  {
 252             if (null == serviceOperation) {
 253                 logger.error("DefaultServiceLcmService saveOrUpdateServiceBean serviceOperation is null!");
 254             }
 255             session.saveOrUpdate(serviceOperation);
 256             session.flush();
 257         } catch (Exception e) {
 258             logger.error(
 259                     "exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceInstanceOperation. Details:"
 260                             + Throwables.getStackTraceAsString(e));
 261             logger.error(
 262                     "exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceInstanceOperation. Details:"
 263                             + e.getMessage());
 264         }
 265     }
 266
 267     @Override
 268     public void updateServiceInstanceOperation(String serviceInstanceId, String operationType, String progress,
 269             String operationResult) {
 270         List<ServiceInstanceOperations> list = new ArrayList<>();
 271         Session session = getSession();
 272         try {
 273             String hql =
 274                     "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 )";
 275             Query q = session.createSQLQuery(hql).addEntity(ServiceInstanceOperations.class);
 276             q.setString("serviceId", serviceInstanceId);
 277             q.setString("serviceInstanceId", serviceInstanceId);
 278             q.setString("operationType", operationType);
 279             list = q.list();
 280             ServiceInstanceOperations serviceOperation = list.get(0);
 281             serviceOperation.setOperationResult(operationResult);
 282             serviceOperation.setOperationProgress(progress);
 283             if ("100".equals(progress)) {
 284                 serviceOperation.setEndTime(DateUtils.dateToString(DateUtils.now()));
 285             }
 286             session.saveOrUpdate(serviceOperation);
 287             session.flush();
 288
 289         } catch (Exception e) {
 290             logger.error(
 291                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceOperation.Detail."
 292                             + e.getMessage());
 293         }
 294     }
 295
 296     @Override
 297     public ServiceInstanceOperations getServiceInstanceOperationById(String serviceId) {
 298         ServiceInstanceOperations serviceOperation = null;
 299         List<ServiceInstanceOperations> list = new ArrayList<>();
 300         Session session = getSession();
 301         try  {
 302             String hql =
 303                     "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)";
 304             Query q = session.createSQLQuery(hql).addEntity(ServiceInstanceOperations.class);
 305             q.setString("serviceId", serviceId);
 306             q.setString("serviceInstanceId", serviceId);
 307             q.list();
 308             list = q.list();
 309             if (!list.isEmpty()) {
 310                 serviceOperation = list.get(0);
 311             } else {
 312                 serviceOperation = new ServiceInstanceOperations();
 313             }
 314             session.flush();
 315
 316         } catch (Exception e) {
 317             logger.error("exception occurred while performing DefaultServiceLcmService getServiceInstanceOperationById."
 318                     + e.getMessage());
 319         }
 320         return serviceOperation;
 321
 322
 323     }
 324
 325
 326         @Override
 327         public List<ServiceBean> getAllServiceBean() {
 328         List<ServiceBean> list = new ArrayList<ServiceBean>();
 329         Session session = getSession();
 330         try  {
 331
 332             String string = "from ServiceBean";
 333             Query q = session.createQuery(string);
 334             list = q.list();
 335             session.flush();
 336         } catch (Exception e) {
 337             list = new ArrayList<>();
 338             logger.error(
 339                     "exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusByIdDetail."
 340                             + e.getMessage());
 341         }
 342         return list;
 343
 344     }
 345
 346
 347
 348 }