Java tutorial
/** * Copyright (C) 2015 Orange * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * http://www.apache.org/licenses/LICENSE-2.0 * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.francetelecom.clara.cloud.environment.impl; import com.francetelecom.clara.cloud.commons.BusinessException; import com.francetelecom.clara.cloud.commons.DateHelper; import com.francetelecom.clara.cloud.commons.TechnicalException; import com.francetelecom.clara.cloud.core.service.ManageEnvironment; import com.francetelecom.clara.cloud.core.service.SecurityUtils; import com.francetelecom.clara.cloud.core.service.exception.ApplicationReleaseNotFoundException; import com.francetelecom.clara.cloud.core.service.exception.EnvironmentNotFoundException; import com.francetelecom.clara.cloud.coremodel.*; import com.francetelecom.clara.cloud.environment.log.LogService; import com.francetelecom.clara.cloud.model.DeploymentProfileEnum; import com.francetelecom.clara.cloud.model.TechnicalDeployment; import com.francetelecom.clara.cloud.model.TechnicalDeploymentInstance; import com.francetelecom.clara.cloud.paas.activation.ManagePaasActivation; import com.francetelecom.clara.cloud.services.dto.EnvironmentDetailsDto; import com.francetelecom.clara.cloud.services.dto.EnvironmentDto; import com.francetelecom.clara.cloud.services.dto.EnvironmentDto.EnvironmentStatusEnum; import com.francetelecom.clara.cloud.services.dto.EnvironmentDto.EnvironmentTypeEnum; import com.francetelecom.clara.cloud.services.dto.EnvironmentOpsDetailsDto; import com.francetelecom.clara.cloud.services.dto.LinkDto; import com.francetelecom.clara.cloud.techmodel.cf.App; import com.francetelecom.clara.cloud.techmodel.cf.Route; import org.apache.commons.lang3.Validate; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.slf4j.MDC; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Isolation; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import java.net.URL; import java.util.*; /** * Manages environment */ @Service("manageEnvironment") public class ManageEnvironmentImpl implements ManageEnvironment { private static final Logger log = LoggerFactory.getLogger(ManageEnvironmentImpl.class); /** * Key in logback context for environment label when available */ private static final String LOG_KEY_ENVNAME = "env_name"; /** * Key in logback context for environment UID when available */ private static final String LOG_KEY_ENVUID = "env_uid"; @Autowired private SecurityUtils securityUtils; @Autowired private ManageEnvironmentImplUtils utils; @Value("${paas.schedule.databasePurge.retentionDelayInDay}") private Integer purgeRetentionDelayInDay; @Autowired private EnvironmentRepository environmentRepository; @Autowired private ManagePaasActivation managePaasActivation; @Autowired private ApplicationReleaseRepository applicationReleaseRepository; @Autowired private LogService logService; @Autowired private EnvironmentMapper environmentMapper; @Override public String createEnvironment(String releaseUID, EnvironmentTypeEnum requestedType, String ownerSsoId, String label, List<String> configRoleUIDs) throws BusinessException { Validate.notNull(releaseUID, "cannot create TDI : releaseUid should not be null"); long start = System.currentTimeMillis(); EnvironmentTypeEnum type = requestedType; if (requestedType != EnvironmentTypeEnum.PRODUCTION && requestedType != EnvironmentTypeEnum.DEVELOPMENT) { type = EnvironmentTypeEnum.PRODUCTION; log.warn("Requested environment type " + requestedType + " is not currently supported; actual type will be " + type); } String environmentUID; try { MDC.put(LOG_KEY_ENVNAME, label); log.debug("createEnvironment: releaseUID={} type={} label={}", new Object[] { releaseUID, type.name(), label }); synchronized (releaseUID.intern()) { // Synchronized this part to avoid pultiple creation of the same // environment Validate.notNull(type, "cannot create TDI : environment type should not be null"); environmentUID = utils.createTDI(releaseUID, DeploymentProfileEnum.valueOf(type.name()), ownerSsoId, label, configRoleUIDs); } MDC.put(LOG_KEY_ENVUID, environmentUID); // this log is used by splunk dashboard log.info("[STATS] Duration : " + (System.currentTimeMillis() - start) + "ms for createEnvironment#1(" + releaseUID + ", " + type + ", " + ownerSsoId + ", " + label + ")"); start = System.currentTimeMillis(); Environment justCreatedEnvironment = environmentRepository.findByUid(environmentUID); // // Start Activate Here // managePaasActivation.activate(justCreatedEnvironment.getTechnicalDeploymentInstance().getId()); // this log is used by splunk dashboard log.info("[STATS] Duration : " + (System.currentTimeMillis() - start) + "ms for createEnvironment#2(" + releaseUID + ", " + type + ", " + ownerSsoId + ", " + label + ")"); log.info(justCreatedEnvironment.toLogString()); } finally { MDC.remove(LOG_KEY_ENVNAME); MDC.remove(LOG_KEY_ENVUID); } return environmentUID; } @Override public String createEnvironment(String releaseUID, EnvironmentTypeEnum requestedType, String ownerSsoId, String label) throws BusinessException { return createEnvironment(releaseUID, requestedType, ownerSsoId, label, null); } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public EnvironmentDto findEnvironmentByUID(String uid) throws EnvironmentNotFoundException { Environment environment = environmentRepository.findByUid(uid); if (environment == null) { String message = "Environment with UID[" + uid + "] does not exist."; log.info(message); throw new EnvironmentNotFoundException(message); } // assert user is authorize to perform action assertHasReadPermissionFor(environment); return environmentMapper.toEnvironmentDto(environment); } private void assertHasWritePermissionFor(Environment environment) { securityUtils.assertHasWritePermissionFor(environment); } private void assertHasReadPermissionFor(Environment environment) { securityUtils.assertHasReadPermissionFor(environment); } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public EnvironmentDetailsDto findEnvironmentDetails(String uid) throws EnvironmentNotFoundException { Environment environment = environmentRepository.findByUid(uid); if (environment == null) { String message = "Environment with UID[" + uid + "] does not exist."; log.info(message); throw new EnvironmentNotFoundException(message); } assertHasReadPermissionFor(environment); return toEnvironmentDetailsDto(environment); } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public EnvironmentOpsDetailsDto findEnvironmentOpsDetailsByUID(String uid) throws EnvironmentNotFoundException { Environment environment = environmentRepository.findByUid(uid); if (environment == null) { String message = "Environment with UID[" + uid + "] does not exist."; log.info(message); throw new EnvironmentNotFoundException(message); } assertHasReadPermissionFor(environment); return createEnvironmentOpsDetailsDto(environment); } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public List<EnvironmentDto> findEnvironments() { if (securityUtils.currentUserIsAdmin()) { return environmentMapper.toEnvironmentDtoList(environmentRepository.findAllActive()); } else { return environmentMapper.toEnvironmentDtoList( environmentRepository.findAllPublicOrPrivateByMember(securityUtils.currentUser().getValue())); } } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public List<EnvironmentDto> findMyEnvironments() { return environmentMapper.toEnvironmentDtoList( environmentRepository.findAllActiveByApplicationMember(securityUtils.currentUser().getValue())); } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public List<EnvironmentDto> findEnvironmentsByAppRelease(String releaseUID) throws ApplicationReleaseNotFoundException { ApplicationRelease applicationRelease = applicationReleaseRepository.findByUID(releaseUID); if (applicationRelease == null) { throw new ApplicationReleaseNotFoundException("ApplicationRelease#" + releaseUID); } // cannot see if not authorized if (securityUtils.currentUserIsAdmin()) { return environmentMapper .toEnvironmentDtoList(environmentRepository.findAllActiveByApplicationReleaseUid(releaseUID)); } else { return environmentMapper.toEnvironmentDtoList( environmentRepository.findAllPublicOrPrivateByMemberAndByApplicationRelease(releaseUID, securityUtils.currentUser().getValue())); } } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public void startEnvironment(String uid) throws EnvironmentNotFoundException { try { MDC.put(LOG_KEY_ENVUID, uid); log.debug("startEnvironment: uid={}", new Object[] { uid }); Environment environment = environmentRepository.findByUid(uid); assertHasWritePermissionFor(environment); MDC.put(LOG_KEY_ENVNAME, environment.getLabel()); if (environment.isStopped()) { managePaasActivation.start(environment.getTechnicalDeploymentInstance().getId()); // TODO status should be set by managePaasActivation environment.setStatus(EnvironmentStatus.STARTING); } else if (environment.isStarting() || environment.isRunning()) { log.info("Environment '" + environment.getUID() + "' is already started or is starting (ignoring call)"); } else if (environment.isFailed()) { log.warn("Environment '" + environment.getUID() + "' is failed but (anyway) we try to start it..."); managePaasActivation.start(environment.getTechnicalDeploymentInstance().getId()); // TODO status should be set by managePaasActivation environment.setStatus(EnvironmentStatus.STARTING); } else { throw new TechnicalException( "Calling start on environment which has a bad status: " + environment.getStatus()); } } finally { MDC.remove(LOG_KEY_ENVNAME); MDC.remove(LOG_KEY_ENVUID); } } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public void stopEnvironment(String uid) throws EnvironmentNotFoundException { try { MDC.put(LOG_KEY_ENVUID, uid); log.debug("stopEnvironment: uid={}", new Object[] { uid }); Environment environment = environmentRepository.findByUid(uid); assertHasWritePermissionFor(environment); MDC.put(LOG_KEY_ENVNAME, environment.getLabel()); if (environment.isRunning()) { managePaasActivation.stop(environment.getTechnicalDeploymentInstance().getId()); // TODO status should be set by managePaasActivation environment.setStatus(EnvironmentStatus.STOPPING); } else if (environment.isStopping() || environment.isStopped()) { log.info("Environment '" + environment.getUID() + "' is already stopped or is stopping (ignoring call)"); } else if (environment.isFailed()) { log.warn("Environment '" + environment.getUID() + "' is failed but (anyway) we try to stop it..."); managePaasActivation.stop(environment.getTechnicalDeploymentInstance().getId()); // TODO status should be set by managePaasActivation environment.setStatus(EnvironmentStatus.STOPPING); } else { throw new TechnicalException( "Calling stop on environment which has a bad status: " + environment.getStatus()); } } finally { MDC.remove(LOG_KEY_ENVNAME); MDC.remove(LOG_KEY_ENVUID); } } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public void deleteEnvironment(String uid) throws EnvironmentNotFoundException { try { MDC.put(LOG_KEY_ENVUID, uid); log.debug("deleteEnvironment: uid={}", new Object[] { uid }); Environment environment = environmentRepository.findByUid(uid); assertHasWritePermissionFor(environment); MDC.put(LOG_KEY_ENVNAME, environment.getLabel()); if (environment.isRemoved() || environment.isRemoving()) { log.info("Environment '" + environment.getUID() + "' is already deleted or deletion is in progress (ignoring call)"); } else { managePaasActivation.delete(environment.getTechnicalDeploymentInstance().getId()); // TODO status should be set by managePaasActivation environment.setStatus(EnvironmentStatus.REMOVING); } } finally { MDC.remove(LOG_KEY_ENVNAME); MDC.remove(LOG_KEY_ENVUID); } } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public void forceStatusForAndEnvironment(String uid, EnvironmentStatus newStatus) throws EnvironmentNotFoundException { Environment environment = environmentRepository.findByUid(uid); if (environment == null) { String message = "Environment with UID[" + uid + "] does not exist."; log.info(message); throw new EnvironmentNotFoundException(message); } environment.updateStatus(newStatus, "", 100); } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public List<Environment> findOldRemovedEnvironments() { log.info("*** find old environment (purgeRetentionDelayInDay={})", purgeRetentionDelayInDay); // find removed environment older than N day return environmentRepository .findRemovedOlderThanNDays(DateHelper.getDateDeltaDay(-purgeRetentionDelayInDay)); } @Override @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public void purgeRemovedEnvironment(String uid) throws EnvironmentNotFoundException { Environment environment = environmentRepository.findByUid(uid); if (environment == null) { String message = "Environment with UID[" + uid + "] does not exist."; log.info(message); throw new EnvironmentNotFoundException(message); } assertHasWritePermissionFor(environment); environmentRepository.delete(environment); } // // Utils // // ================================================================================================================================ // TOM private Map<String, List<LinkDto>> getEnvironmentLinkDtos(Environment env) { TechnicalDeployment td = env.getTechnicalDeploymentInstance().getTechnicalDeployment(); Map<String, List<LinkDto>> linkDtoMap = new HashMap<String, List<LinkDto>>(); linkDtoMap.putAll(getEnvironmentAccessUrlsLinkDtos(td, linkDtoMap)); linkDtoMap.putAll(getEnvironmentLogsUrlsLinkDtos(env, linkDtoMap)); linkDtoMap.putAll(getEnvironmentWspLinkDtos(td, linkDtoMap)); linkDtoMap.putAll(getEnvironmentDiagToolsUrlsLinkDtos(env, linkDtoMap)); return linkDtoMap; } private Map<String, List<LinkDto>> getEnvironmentAccessUrlsLinkDtos(TechnicalDeployment td, Map<String, List<LinkDto>> linkDtoMap) { for (Route route : td.listXaasSubscriptionTemplates(Route.class)) { linkDtoMap.putAll(addLinkDtoForLogicalModelItemInLinkDtosMap(linkDtoMap, route.getLogicalModelId(), route.getFullHttpAccessUrl(), LinkDto.LinkTypeEnum.ACCESS_LINK, LinkDto.TargetUserEnum.PAAS_USER, null)); } return linkDtoMap; } private Map<String, List<LinkDto>> getEnvironmentLogsUrlsLinkDtos(Environment env, Map<String, List<LinkDto>> linkDtoMap) { TechnicalDeployment td = env.getTechnicalDeploymentInstance().getTechnicalDeployment(); Set<App> apps = td.listXaasSubscriptionTemplates(App.class); for (App app : apps) { URL logsUrl = logService.getAppLogsUrl(app.getExternalReference()); linkDtoMap.putAll(addLinkDtoForLogicalModelItemInLinkDtosMap(linkDtoMap, app.getLogicalModelId(), logsUrl, LinkDto.LinkTypeEnum.LOGS_LINK, LinkDto.TargetUserEnum.PAAS_USER, null)); } Set<Route> routes = td.listXaasSubscriptionTemplates(Route.class); for (Route route : routes) { URL logsUrl = logService.getRouteLogsUrl(route.getUri()); linkDtoMap.putAll(addLinkDtoForLogicalModelItemInLinkDtosMap(linkDtoMap, route.getLogicalModelId(), logsUrl, LinkDto.LinkTypeEnum.LOGS_LINK, LinkDto.TargetUserEnum.PAAS_USER, null)); } return linkDtoMap; } private Map<String, List<LinkDto>> getEnvironmentWspLinkDtos(TechnicalDeployment td, Map<String, List<LinkDto>> linkDtoMap) { return linkDtoMap; } private Map<String, List<LinkDto>> getEnvironmentDiagToolsUrlsLinkDtos(Environment env, Map<String, List<LinkDto>> linkDtoMap) { TechnicalDeploymentInstance tdi = env.getTechnicalDeploymentInstance(); TechnicalDeployment td = tdi.getTechnicalDeployment(); // In fact this is the TD name that is used for the paasEnvName field // (see splunk configuration) Set<App> apps = td.listXaasSubscriptionTemplates(App.class); List<String> appNAmes = new ArrayList<String>(); for (App app : apps) { appNAmes.add(app.getExternalReference()); } String[] array = appNAmes.toArray(new String[appNAmes.size()]); URL logsUrl = logService.getEnvironmentLogsUrl(array); // paas logs linkDto linkDtoMap.putAll(addLinkDtoForLogicalModelItemInLinkDtosMap(linkDtoMap, td.getName(), logsUrl, LinkDto.LinkTypeEnum.LOGS_LINK, LinkDto.TargetUserEnum.PAAS_USER, null)); return linkDtoMap; } private Map<String, List<LinkDto>> addLinkDtoForLogicalModelItemInLinkDtosMap( Map<String, List<LinkDto>> linkDtoMap, String key, URL url, LinkDto.LinkTypeEnum linktype, LinkDto.TargetUserEnum targetUser, Map<String, String> serviceBinding) { if (url != null && key != null) { List<LinkDto> linkDtoList; // Link Dto creation LinkDto appsLinksDto = new LinkDto(); appsLinksDto.setLinkType(linktype); appsLinksDto.setTargetUser(targetUser); appsLinksDto.setUrl(url); appsLinksDto.setServiceBindings(serviceBinding); // get list of LinkDto associated with the key linkDtoList = getLinkDtoInMap(linkDtoMap, key); // Add new LinkDto to the list of LinkDto linkDtoList.add(appsLinksDto); // Add the List of LinkDtos into the map with "key" as key linkDtoMap.put(key, linkDtoList); } return linkDtoMap; } /* * get LinkDto into List<LinkDto> if no List exist with key, it returns a * new empty List else it returns the list corresponding to the key */ private List<LinkDto> getLinkDtoInMap(Map<String, List<LinkDto>> linkDtoMap, String key) { List<LinkDto> linkDtoList; if (linkDtoMap.get(key) == null) { linkDtoList = new ArrayList<LinkDto>(); } else { linkDtoList = linkDtoMap.get(key); } return linkDtoList; } private EnvironmentDetailsDto toEnvironmentDetailsDto(Environment env) throws EnvironmentNotFoundException { if (env == null) { throw new EnvironmentNotFoundException(); } String uid = env.getUID(); String internalName = env.getInternalName(); String label = env.getLabel(); ApplicationRelease applicationRelease = env.getApplicationRelease(); Application application = applicationRelease.getApplication(); String appLabel = application.getLabel(); String appReleaseUid = applicationRelease.getUID(); String releaseVersion = applicationRelease.getReleaseVersion(); PaasUser envPaasUser = env.getPaasUser(); String envPaasUserSsoId = envPaasUser.getSsoId().getValue(); String paasUserName = envPaasUser.getFirstName(); Date envCreationDate = env.getCreationDate(); String envTypeName = env.getType().name(); EnvironmentTypeEnum envTypeEnum = EnvironmentTypeEnum.valueOf(envTypeName); String envStatusName = env.getStatus().name(); EnvironmentStatusEnum envStatusEnum = EnvironmentStatusEnum.valueOf(envStatusName); String envStatusMessage = env.getStatusMessage(); int envStatusPercent = env.getStatusPercent(); String envComment = env.getComment(); TechnicalDeploymentInstance envTdi = env.getTechnicalDeploymentInstance(); TechnicalDeployment envTdiTd = envTdi.getTechnicalDeployment(); String envTdiTdName = envTdiTd.getName(); EnvironmentDetailsDto dto = new EnvironmentDetailsDto(uid, internalName, label, appLabel, appReleaseUid, releaseVersion, envPaasUserSsoId, paasUserName, envCreationDate, envTypeEnum, envStatusEnum, envStatusMessage, envStatusPercent, envComment, envTdiTdName); dto.setEditable(securityUtils.hasWritePermissionFor(env)); dto.setLinkDtoMap(getEnvironmentLinkDtos(env)); return dto; } private EnvironmentOpsDetailsDto createEnvironmentOpsDetailsDto(Environment env) throws EnvironmentNotFoundException { EnvironmentOpsDetailsDto dto = new EnvironmentOpsDetailsDto(env.getUID(), null, env.getLabel(), env.getApplicationRelease().getApplication().getLabel(), env.getApplicationRelease().getUID(), env.getApplicationRelease().getReleaseVersion(), env.getPaasUser().getSsoId().getValue(), env.getPaasUser().getFirstName(), env.getCreationDate(), EnvironmentTypeEnum.valueOf(env.getType().name()), EnvironmentStatusEnum.valueOf(env.getStatus().name()), env.getStatusMessage(), env.getStatusPercent(), env.getComment(), env.getTechnicalDeploymentInstance().getName()); dto.setLinkDtoMap(getEnvironmentLinkDtos(env)); return dto; } @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) @Override public Environment update(EnvironmentDetailsDto environmentDetailsDto) { try { MDC.put(LOG_KEY_ENVUID, environmentDetailsDto.getUid()); MDC.put(LOG_KEY_ENVNAME, environmentDetailsDto.getLabel()); log.debug("updateEnvironment: uid={}", new Object[] { environmentDetailsDto.getUid() }); Environment environment = environmentRepository.findByUid(environmentDetailsDto.getUid()); assertHasWritePermissionFor(environment); environment.setComment(environmentDetailsDto.getComment()); return environment; } finally { MDC.remove(LOG_KEY_ENVNAME); MDC.remove(LOG_KEY_ENVUID); } } @Override public Long countEnvironments() { if (securityUtils.currentUserIsAdmin()) { return environmentRepository.countActive(); } else { return environmentRepository.countPublicOrPrivateByMember(securityUtils.currentUser().getValue()); } } @Override public Long countMyEnvironments() { return environmentRepository.countActiveByApplicationMember(securityUtils.currentUser().getValue()); } @Override public Long countEnvironmentsByApplicationRelease(String releaseUID) throws ApplicationReleaseNotFoundException { ApplicationRelease applicationRelease = applicationReleaseRepository.findByUID(releaseUID); if (applicationRelease == null) { throw new ApplicationReleaseNotFoundException("ApplicationRelease#" + releaseUID); } // cannot see if not authorized if (securityUtils.currentUserIsAdmin()) { return environmentRepository.countActiveByApplicationReleaseUid(releaseUID); } else { return environmentRepository.countAllPublicOrPrivateByMemberAndByApplicationRelease(releaseUID, securityUtils.currentUser().getValue()); } } @Override public boolean isEnvironmentLabelUniqueForRelease(String ssoid, String searchEnvironmentLabel, String releaseUID) { return environmentRepository.findByApplicationReleaseUIDAndLabel(releaseUID, searchEnvironmentLabel) == null; } // // Getters and setters that might be necessary for spring injection ? // Please remove them if unneeded // public void setPurgeRetentionDelayInDay(Integer purgeRetentionDelayInDay) { this.purgeRetentionDelayInDay = purgeRetentionDelayInDay; } public void setEnvironmentRepository(EnvironmentRepository repository) { this.environmentRepository = repository; } public void setManagePaasActivation(ManagePaasActivation managePaasActivation) { this.managePaasActivation = managePaasActivation; } public void setApplicationReleaseRepository(ApplicationReleaseRepository repository) { this.applicationReleaseRepository = repository; } public void setLogService(LogService logService) { this.logService = logService; } public void setUtils(ManageEnvironmentImplUtils utils) { this.utils = utils; } public void setEnvironmentMapper(EnvironmentMapper environmentMapper) { this.environmentMapper = environmentMapper; } }