/**
* 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;
}
}