"Accept: application/json"
     })
 //    @GET("/api/aai-business/v11/customers")
-    @GET("/aai-business/v11/customers")
+    @GET("/api/aai-business/v11/customers")
     Call<AAICustomerRsp> listCustomer();
 
     @Headers({
             "Accept: application/json"
     })
 //    @GET("/api/aai-business/v11/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances")
-    @GET("/aai-business/v11/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances")
+    @GET("/api/aai-business/v11/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances")
     Call<ServiceInstanceRsp> listServiceInstances(@Path("global-customer-id") String customerId, @Path("service-type") String serviceType);
 
     @Headers({
             "Accept: application/json"
     })
 //    @GET("/cloud-infrastructure/cloud-regions")
-    @GET("/aai-cloudInfrastructure/v11/cloud-regions")
+    @GET("/api/aai-cloudInfrastructure/v11/cloud-regions")
     Call<VimInfoRsp> listVimInfo();
 
     @Headers({
             "Accept: application/json"
     })
 //    @GET("/api/aai-business/v11/customers/customer/{global-customer-id}/service-subscriptions")
-    @GET("/aai-business/v11/customers/customer/{global-customer-id}/service-subscriptions")
+    @GET("/api/aai-business/v11/customers/customer/{global-customer-id}/service-subscriptions")
     Call<ServiceSubscriptionRsp> listServiceSubscriptions(@Path("global-customer-id") String customerId);
 }
 
             "X-ECOMP-InstanceID: 777",
             "Authorization:  Basic YWFpOktwOGJKNFNYc3pNMFdYbGhhazNlSGxjc2UyZ0F3ODR2YW9HR21KdlV5MlU="
     })
-    @GET("/sdc/v1/catalog/services")
+    @GET("/api/sdc/v1/catalog/services")
     Call<List<SDCServiceTemplate>> listServices(@Query("category")String category, @Query("distributionStatus") String distributionStatus);
 
     @Headers({
             "X-ECOMP-InstanceID: 777",
             "Authorization:  Basic YWFpOktwOGJKNFNYc3pNMFdYbGhhazNlSGxjc2UyZ0F3ODR2YW9HR21KdlV5MlU="
     })
-    @GET("/sdc/v1/catalog/services/{uuid}/metadata")
+    @GET("/api/sdc/v1/catalog/services/{uuid}/metadata")
     Call<SDCServiceTemplate> getService(@Path("uuid") String uuid);
 
     @Headers({
             "X-ECOMP-InstanceID: 777",
             "Authorization:  Basic YWFpOktwOGJKNFNYc3pNMFdYbGhhazNlSGxjc2UyZ0F3ODR2YW9HR21KdlV5MlU="
     })
-    @GET("/sdc/v1/catalog/resources")
+    @GET("/api/sdc/v1/catalog/resources")
     Call<List<Vnf>> listResources(@Query("resourceType") String resourceType, @Query("distributionStatus") String distributionStatus);
 }
\ No newline at end of file
 
 
 public interface SOService {
 
-    @POST("/so-e2eServiceInstances/v2")
+    @POST("/api/so-e2eServiceInstances/v2")
     Call<ServiceOperation> instantiateService(@Body RequestBody body);
 
-    @GET("/so-e2eServiceInstances/v2/{serviceId}/operations/{operationId}")
+    @GET("/api/so-e2eServiceInstances/v2/{serviceId}/operations/{operationId}")
     Call<OperationProgressInformation> queryOperationProgress(@Path("serviceId") String serviceId, @Path("operationId") String operationId);
 
-    @DELETE("/so-e2eServiceInstances/v2/{serviceId}")
+    @DELETE("/api/so-e2eServiceInstances/v2/{serviceId}")
     Call<ServiceOperation> terminateService(@Path("serviceId") String serviceId);
 }
 
 
 public class SOException extends RuntimeException {
 
+    public SOException(String message) {
+        super(message);
+    }
+
     public SOException(String message, Throwable cause) {
         super(message, cause);
     }
 
 
 public class VfcException extends RuntimeException {
 
+    public VfcException(String message) {
+        super(message);
+    }
+
     public VfcException(String message, Throwable cause) {
         super(message, cause);
     }
 
 import org.onap.usecaseui.server.service.lcm.CustomerService;
 import org.onap.usecaseui.server.service.lcm.domain.aai.AAIService;
 import org.onap.usecaseui.server.service.lcm.domain.aai.bean.AAICustomer;
+import org.onap.usecaseui.server.service.lcm.domain.aai.bean.AAICustomerRsp;
 import org.onap.usecaseui.server.service.lcm.domain.aai.bean.AAIServiceSubscription;
+import org.onap.usecaseui.server.service.lcm.domain.aai.bean.ServiceSubscriptionRsp;
 import org.onap.usecaseui.server.service.lcm.domain.aai.exceptions.AAIException;
 import org.onap.usecaseui.server.util.RestfulServices;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.stereotype.Service;
+import retrofit2.Response;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 
 @Service("CustomerService")
     @Override
     public List<AAICustomer> listCustomer() {
         try {
-            return this.aaiService.listCustomer().execute().body().getCustomer();
+            Response<AAICustomerRsp> response = this.aaiService.listCustomer().execute();
+            if (response.isSuccessful()) {
+                return response.body().getCustomer();
+            } else {
+                logger.info(String.format("Can not get customers[code=%s, message=%s]", response.code(), response.message()));
+                return Collections.emptyList();
+            }
         } catch (IOException e) {
             logger.error("list customers occur exception");
             throw new AAIException("AAI is not available.", e);
     @Override
     public List<AAIServiceSubscription> listServiceSubscriptions(String customerId) {
         try {
-            return this.aaiService.listServiceSubscriptions(customerId).execute().body().getServiceSubscriptions();
+            Response<ServiceSubscriptionRsp> response = this.aaiService.listServiceSubscriptions(customerId).execute();
+            if (response.isSuccessful()) {
+                return response.body().getServiceSubscriptions();
+            } else {
+                logger.info(String.format("Can not get service-subscriptions[code=%s, message=%s]", response.code(), response.message()));
+                return Collections.emptyList();
+            }
         } catch (IOException e) {
             logger.error("list customers occur exception");
             throw new AAIException("AAI is not available.", e);
 
 import org.onap.usecaseui.server.service.lcm.domain.vfc.beans.Job;
 import org.onap.usecaseui.server.service.lcm.domain.vfc.beans.JobStatus;
 import org.onap.usecaseui.server.service.lcm.domain.vfc.exceptions.VfcException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.stereotype.Service;
+import retrofit2.Response;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 
 import static org.onap.usecaseui.server.service.lcm.domain.sdc.consts.SDCConsts.*;
 @EnableAspectJAutoProxy
 public class DefaultPackageDistributionService implements PackageDistributionService {
 
+    private static final Logger logger = LoggerFactory.getLogger(DefaultPackageDistributionService.class);
+
     private SDCCatalogService sdcCatalogService;
 
     private VfcService vfcService;
     @Override
     public VfNsPackageInfo retrievePackageInfo() {
         try {
-            List<SDCServiceTemplate> nsTemplate = sdcCatalogService.listServices(CATEGORY_NS, DISTRIBUTION_STATUS_DISTRIBUTED).execute().body();
-            List<Vnf> vnf = sdcCatalogService.listResources(RESOURCETYPE_VF, DISTRIBUTION_STATUS_DISTRIBUTED).execute().body();
+            List<SDCServiceTemplate> nsTemplate = getNsTemplate();
+            List<Vnf> vnf = getVFResource();
             return new VfNsPackageInfo(nsTemplate, vnf);
         } catch (IOException e) {
             throw new SDCCatalogException("SDC Service is not available!", e);
         }
     }
 
+    private List<Vnf> getVFResource() throws IOException {
+        Response<List<Vnf>> response = sdcCatalogService.listResources(RESOURCETYPE_VF, DISTRIBUTION_STATUS_DISTRIBUTED).execute();
+        if (response.isSuccessful()) {
+            return response.body();
+        } else {
+            logger.info(String.format("Can not get VF resources[code=%s, message=%s]", response.code(), response.message()));
+            return Collections.emptyList();
+        }
+    }
+
+    private List<SDCServiceTemplate> getNsTemplate() throws IOException {
+        Response<List<SDCServiceTemplate>> response = sdcCatalogService.listServices(CATEGORY_NS, DISTRIBUTION_STATUS_DISTRIBUTED).execute();
+        if (response.isSuccessful()) {
+            return response.body();
+        } else {
+            logger.info(String.format("Can not get NS services[code=%s, message=%s]", response.code(), response.message()));
+            return Collections.emptyList();
+        }
+    }
+
     @Override
     public DistributionResult postNsPackage(Csar csar) {
         try {
-            return vfcService.distributeNsPackage(csar).execute().body();
+            Response<DistributionResult> response = vfcService.distributeNsPackage(csar).execute();
+            if (response.isSuccessful()) {
+                return response.body();
+            } else {
+                logger.info(String.format("Can not post NS packages[code=%s, message=%s]", response.code(), response.message()));
+                throw new VfcException("VFC service is not available!");
+            }
         } catch (IOException e) {
             throw new VfcException("VFC service is not available!", e);
         }
     @Override
     public Job postVfPackage(Csar csar) {
         try {
-            return vfcService.distributeVnfPackage(csar).execute().body();
+            Response<Job> response = vfcService.distributeVnfPackage(csar).execute();
+            if (response.isSuccessful()) {
+                return response.body();
+            } else {
+                logger.info(String.format("Can not get VF packages[code=%s, message=%s]", response.code(), response.message()));
+                throw new VfcException("VFC service is not available!");
+            }
         } catch (IOException e) {
             throw new VfcException("VFC service is not available!", e);
         }
     @Override
     public JobStatus getJobStatus(String jobId) {
         try {
-            return vfcService.getJobStatus(jobId).execute().body();
+            Response<JobStatus> response = vfcService.getJobStatus(jobId).execute();
+            if (response.isSuccessful()) {
+                return response.body();
+            } else {
+                logger.info(String.format("Can not get Job status[code=%s, message=%s]", response.code(), response.message()));
+                throw new VfcException("VFC service is not available!");
+            }
         } catch (IOException e) {
             throw new VfcException("VFC service is not available!", e);
         }
 
 import org.onap.usecaseui.server.service.lcm.ServiceInstanceService;
 import org.onap.usecaseui.server.service.lcm.domain.aai.AAIService;
 import org.onap.usecaseui.server.service.lcm.domain.aai.bean.ServiceInstance;
+import org.onap.usecaseui.server.service.lcm.domain.aai.bean.ServiceInstanceRsp;
 import org.onap.usecaseui.server.service.lcm.domain.aai.exceptions.AAIException;
 import org.onap.usecaseui.server.util.RestfulServices;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.stereotype.Service;
+import retrofit2.Response;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 
 @Service("ServiceInstanceService")
     @Override
     public List<ServiceInstance> listServiceInstances(String customerId, String serviceType) {
         try {
-            return aaiService.listServiceInstances(customerId, serviceType).execute().body().getServiceInstances();
+            Response<ServiceInstanceRsp> response = aaiService.listServiceInstances(customerId, serviceType).execute();
+            if (response.isSuccessful()) {
+                return response.body().getServiceInstances();
+            } else {
+                logger.info(String.format("Can not get service instances[code=%s, message=%s]", response.code(), response.message()));
+                return Collections.emptyList();
+            }
         } catch (IOException e) {
             logger.error("list services instances occur exception");
             throw new AAIException("AAI is not available.", e);
 
 import org.onap.usecaseui.server.service.lcm.domain.so.bean.OperationProgressInformation;
 import org.onap.usecaseui.server.service.lcm.domain.so.bean.ServiceOperation;
 import org.onap.usecaseui.server.service.lcm.domain.so.exceptions.SOException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.stereotype.Service;
+import retrofit2.Response;
 
 import javax.servlet.http.HttpServletRequest;
 import java.io.IOException;
+import java.util.Collections;
 
 import static org.onap.usecaseui.server.util.RestfulServices.create;
 import static org.onap.usecaseui.server.util.RestfulServices.extractBody;
 @EnableAspectJAutoProxy
 public class DefaultServiceLcmService implements ServiceLcmService {
 
+    private static final Logger logger = LoggerFactory.getLogger(DefaultServiceLcmService.class);
+
     private SOService soService;
 
     public DefaultServiceLcmService() {
     public ServiceOperation instantiateService(HttpServletRequest request) {
         try {
             RequestBody requestBody = extractBody(request);
-            return soService.instantiateService(requestBody).execute().body();
+            Response<ServiceOperation> response = soService.instantiateService(requestBody).execute();
+            if (response.isSuccessful()) {
+                return response.body();
+            } else {
+                logger.info(String.format("Can not instantiate service[code=%s, message=%s]", response.code(), response.message()));
+                throw new SOException("SO instantiate service failed!");
+            }
         } catch (IOException e) {
             throw new SOException("SO Service is not available!", e);
         }
     @Override
     public OperationProgressInformation queryOperationProgress(String serviceId, String operationId) {
         try {
-            return soService.queryOperationProgress(serviceId, operationId).execute().body();
+            Response<OperationProgressInformation> response = soService.queryOperationProgress(serviceId, operationId).execute();
+            if (response.isSuccessful()) {
+                return response.body();
+            } else {
+                logger.info(String.format("Can not query operation process[code=%s, message=%s]", response.code(), response.message()));
+                throw new SOException("SO query operation process failed!");
+            }
         } catch (IOException e) {
             throw new SOException("SO Service is not available!", e);
         }
     @Override
     public ServiceOperation terminateService(String serviceId) {
         try {
-            return soService.terminateService(serviceId).execute().body();
+            Response<ServiceOperation> response = soService.terminateService(serviceId).execute();
+            if (response.isSuccessful()) {
+                return response.body();
+            } else {
+                logger.info(String.format("Can not terminate service[code=%s, message=%s]", response.code(), response.message()));
+                throw new SOException("SO terminate service failed!");
+            }
         } catch (IOException e) {
             throw new SOException("SO Service is not available!", e);
         }
 
 import org.onap.usecaseui.server.service.lcm.ServiceTemplateService;
 import org.onap.usecaseui.server.service.lcm.domain.aai.AAIService;
 import org.onap.usecaseui.server.service.lcm.domain.aai.bean.VimInfo;
+import org.onap.usecaseui.server.service.lcm.domain.aai.bean.VimInfoRsp;
 import org.onap.usecaseui.server.service.lcm.domain.aai.exceptions.AAIException;
 import org.onap.usecaseui.server.service.lcm.domain.sdc.SDCCatalogService;
 import org.onap.usecaseui.server.service.lcm.domain.sdc.bean.SDCServiceTemplate;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.stereotype.Service;
+import retrofit2.Response;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import static org.onap.usecaseui.server.service.lcm.domain.sdc.consts.SDCConsts.CATEGORY_E2E_SERVICE;
     @Override
     public List<SDCServiceTemplate> listDistributedServiceTemplate() {
         try {
-            return this.sdcCatalog.listServices(CATEGORY_E2E_SERVICE, DISTRIBUTION_STATUS_DISTRIBUTED).execute().body();
+            Response<List<SDCServiceTemplate>> response = this.sdcCatalog.listServices(CATEGORY_E2E_SERVICE, DISTRIBUTION_STATUS_DISTRIBUTED).execute();
+            if (response.isSuccessful()) {
+                return response.body();
+            } else {
+                logger.info(String.format("Can not get distributed e2e service templates[code=%s, message=%s]", response.code(), response.message()));
+                return Collections.emptyList();
+            }
         } catch (IOException e) {
             logger.error("Visit SDC Catalog occur exception");
             throw new SDCCatalogException("SDC Catalog is not available.", e);
         ServiceTemplateInput serviceTemplateInput = fetchServiceTemplateInput(tosca);
         for (NodeTemplate nodeTemplate : tosca.getNodeTemplates()) {
             String nodeUUID = nodeTemplate.getMetaData().getValue("UUID");
-            SDCServiceTemplate template = sdcCatalog.getService(nodeUUID).execute().body();
-            String toscaModelURL = template.getToscaModelURL();
+            String toscaModelURL = getToscaUrl(nodeUUID);
             if (toscaModelURL == null) {
                 continue;
             }
         return serviceTemplateInput;
     }
 
+    private String getToscaUrl(String nodeUUID) throws IOException {
+        Response<SDCServiceTemplate> response = sdcCatalog.getService(nodeUUID).execute();
+        if (response.isSuccessful()) {
+            SDCServiceTemplate template = response.body();
+            return template.getToscaModelURL();
+        } else {
+            logger.info(String.format("Cannot get tosca model for node template[%s]", nodeUUID));
+            return null;
+        }
+    }
+
 //    private List<ServiceTemplateInput> extractInputs(String toPath, List<ServiceTemplateInput> serviceTemplateInputs) throws JToscaException, IOException {
 //        ToscaTemplate tosca = translateToToscaTemplate(toPath);
 //        ServiceTemplateInput serviceTemplateInput = fetchServiceTemplateInput(tosca);
     @Override
     public List<VimInfo> listVim() {
         try {
-            return aaiService.listVimInfo().execute().body().getCloudRegion();
+            Response<VimInfoRsp> response = aaiService.listVimInfo().execute();
+            if (response.isSuccessful()) {
+                return response.body().getCloudRegion();
+            } else {
+                logger.info(String.format("Can not get vim info[code=%s, message=%s]", response.code(), response.message()));
+                return Collections.emptyList();
+            }
         } catch (IOException e) {
             logger.error("Visit AAI occur exception");
             throw new AAIException("AAI is not available.", e);
 
     public static <T> T create(Class<T> clazz) {
         String msbUrl = getMsbAddress();
         Retrofit retrofit = new Retrofit.Builder()
-                .baseUrl("http://" + msbUrl+"/api/")
+                .baseUrl("http://" + msbUrl+"/")
                 .addConverterFactory(JacksonConverterFactory.create())
                 .build();
         return retrofit.create(clazz);