| package org.apache.continuum.installation; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| */ |
| |
| import org.apache.continuum.dao.InstallationDao; |
| import org.apache.continuum.utils.shell.ExecutionResult; |
| import org.apache.continuum.utils.shell.ListOutputConsumer; |
| import org.apache.continuum.utils.shell.OutputConsumer; |
| import org.apache.continuum.utils.shell.ShellCommandHelper; |
| import org.apache.maven.continuum.execution.ExecutorConfigurator; |
| import org.apache.maven.continuum.installation.AlreadyExistsInstallationException; |
| import org.apache.maven.continuum.installation.InstallationException; |
| import org.apache.maven.continuum.installation.InstallationService; |
| import org.apache.maven.continuum.model.system.Installation; |
| import org.apache.maven.continuum.model.system.Profile; |
| import org.apache.maven.continuum.profile.AlreadyExistsProfileException; |
| import org.apache.maven.continuum.profile.ProfileException; |
| import org.apache.maven.continuum.profile.ProfileService; |
| import org.apache.maven.continuum.store.ContinuumStoreException; |
| import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable; |
| import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException; |
| import org.codehaus.plexus.util.StringUtils; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| import org.springframework.stereotype.Service; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import javax.annotation.Resource; |
| |
| /** |
| * @author <a href="mailto:olamy@codehaus.org">olamy</a> |
| * @version $Id$ |
| * TODO use some cache mechanism to prevent always reading from store ? |
| * @since 13 juin 07 |
| */ |
| @Service( "installationService" ) |
| public class DefaultInstallationService |
| implements InstallationService, Initializable |
| { |
| private static final Logger log = LoggerFactory.getLogger( DefaultInstallationService.class ); |
| |
| @Resource |
| private InstallationDao installationDao; |
| |
| @Resource |
| private ProfileService profileService; |
| |
| @Resource |
| private ShellCommandHelper shellCommandHelper; |
| |
| private Map<String, ExecutorConfigurator> typesValues; |
| |
| // --------------------------------------------- |
| // Plexus lifecycle |
| // --------------------------------------------- |
| |
| public void initialize() |
| throws InitializationException |
| { |
| this.typesValues = new HashMap<String, ExecutorConfigurator>(); |
| this.typesValues.put( InstallationService.ANT_TYPE, new ExecutorConfigurator( "ant", "bin", "ANT_HOME", |
| "-version" ) ); |
| |
| this.typesValues.put( InstallationService.ENVVAR_TYPE, null ); |
| this.typesValues.put( InstallationService.JDK_TYPE, new ExecutorConfigurator( "java", "bin", "JAVA_HOME", |
| "-version" ) ); |
| this.typesValues.put( InstallationService.MAVEN1_TYPE, new ExecutorConfigurator( "maven", "bin", "MAVEN_HOME", |
| "-v" ) ); |
| this.typesValues.put( InstallationService.MAVEN2_TYPE, new ExecutorConfigurator( "mvn", "bin", "M2_HOME", |
| "-v" ) ); |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#add(org.apache.maven.continuum.model.system.Installation) |
| */ |
| public Installation add( Installation installation ) |
| throws InstallationException, AlreadyExistsInstallationException |
| { |
| try |
| { |
| return this.add( installation, false ); |
| } |
| catch ( AlreadyExistsProfileException e ) |
| { |
| // normally cannot happend here but anyway we throw the exception |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| } |
| |
| public Installation add( Installation installation, boolean automaticProfile ) |
| throws InstallationException, AlreadyExistsProfileException, AlreadyExistsInstallationException |
| { |
| if ( alreadyExistInstallationName( installation ) ) |
| { |
| throw new AlreadyExistsInstallationException( |
| "Installation with name " + installation.getName() + " already exists" ); |
| } |
| // TODO must be done in the same transaction |
| Installation storedOne; |
| try |
| { |
| String envVarName = this.getEnvVar( installation.getType() ); |
| // override with the defined var name for defined types |
| if ( StringUtils.isNotEmpty( envVarName ) ) |
| { |
| installation.setVarName( envVarName ); |
| } |
| storedOne = installationDao.addInstallation( installation ); |
| } |
| catch ( ContinuumStoreException e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| try |
| { |
| if ( automaticProfile ) |
| { |
| Profile profile = new Profile(); |
| profile.setName( storedOne.getName() ); |
| profile = profileService.addProfile( profile ); |
| profileService.addInstallationInProfile( profile, storedOne ); |
| } |
| } |
| catch ( ProfileException e ) |
| { |
| throw new InstallationException( "failed to create automatic Profile " + e.getMessage(), e ); |
| } |
| return storedOne; |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#delete(org.apache.maven.continuum.model.system.Installation) |
| */ |
| public void delete( Installation installation ) |
| throws InstallationException |
| { |
| try |
| { |
| installationDao.removeInstallation( installation ); |
| } |
| catch ( ContinuumStoreException e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#getAllInstallations() |
| */ |
| @SuppressWarnings( "unchecked" ) |
| public List<Installation> getAllInstallations() |
| throws InstallationException |
| { |
| try |
| { |
| List<Installation> installations = installationDao.getAllInstallations(); |
| return installations == null ? Collections.EMPTY_LIST : installations; |
| } |
| catch ( ContinuumStoreException e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#getInstallation(int) |
| */ |
| public Installation getInstallation( int installationId ) |
| throws InstallationException |
| { |
| try |
| { |
| return installationDao.getInstallation( installationId ); |
| } |
| catch ( ContinuumStoreException e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#getInstallation(String) |
| */ |
| public Installation getInstallation( String installationName ) |
| throws InstallationException |
| { |
| try |
| { |
| return installationDao.getInstallation( installationName ); |
| } |
| catch ( ContinuumStoreException e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#update(org.apache.maven.continuum.model.system.Installation) |
| */ |
| public void update( Installation installation ) |
| throws InstallationException, AlreadyExistsInstallationException |
| { |
| try |
| { |
| Installation stored = getInstallation( installation.getInstallationId() ); |
| if ( stored == null ) |
| { |
| throw new InstallationException( "installation with name " + installation.getName() + " not exists" ); |
| } |
| |
| stored.setName( installation.getName() ); |
| if ( alreadyExistInstallationName( installation ) ) |
| { |
| throw new AlreadyExistsInstallationException( |
| "Installation with name " + installation.getName() + " already exists" ); |
| } |
| stored.setType( installation.getType() ); |
| String envVarName = this.getEnvVar( installation.getType() ); |
| // override with the defined var name for defined types |
| if ( StringUtils.isNotEmpty( envVarName ) ) |
| { |
| installation.setVarName( envVarName ); |
| } |
| else |
| { |
| stored.setVarName( installation.getVarName() ); |
| } |
| stored.setVarValue( installation.getVarValue() ); |
| installationDao.updateInstallation( stored ); |
| } |
| catch ( ContinuumStoreException e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#getExecutorConfigurator(java.lang.String) |
| */ |
| public ExecutorConfigurator getExecutorConfigurator( String type ) |
| { |
| return this.typesValues.get( type ); |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#getEnvVar(java.lang.String) |
| */ |
| public String getEnvVar( String type ) |
| { |
| ExecutorConfigurator executorConfigurator = this.typesValues.get( type ); |
| return executorConfigurator == null ? null : executorConfigurator.getEnvVar(); |
| } |
| |
| // ------------------------------------------------------------- |
| // versions informations on jdk and builders (mvn, maven, ant ) |
| // ------------------------------------------------------------- |
| |
| /** |
| * TODO replace with calling getExecutorVersionInfo |
| * |
| * @see org.apache.maven.continuum.installation.InstallationService#getDefaultJavaVersionInfo() |
| */ |
| public List<String> getDefaultJavaVersionInfo() |
| throws InstallationException |
| { |
| try |
| { |
| Properties systemEnvVars = shellCommandHelper.getSystemEnvVars(); |
| String javaHome = (String) systemEnvVars.get( "JAVA_HOME" ); |
| // olamy : JAVA_HOME may not exist for mac users |
| if ( StringUtils.isEmpty( javaHome ) ) |
| { |
| return getJavaVersionInfo( System.getProperty( "java.home" ) ); |
| } |
| return getJavaVersionInfo( javaHome ); |
| |
| } |
| catch ( Exception e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| } |
| |
| /** |
| * TODO replace with calling getExecutorVersionInfo |
| * |
| * @see org.apache.maven.continuum.installation.InstallationService#getJavaVersionInfo(org.apache.maven.continuum.model.system.Installation) |
| */ |
| public List<String> getJavaVersionInfo( Installation installation ) |
| throws InstallationException |
| { |
| if ( installation == null ) |
| { |
| return getDefaultJavaVersionInfo(); |
| } |
| if ( StringUtils.isEmpty( installation.getVarValue() ) ) |
| { |
| return getDefaultJavaVersionInfo(); |
| } |
| try |
| { |
| return getJavaVersionInfo( installation.getVarValue() ); |
| } |
| catch ( Exception e ) |
| { |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| } |
| |
| /** |
| * @param homePath |
| * @return |
| * @throws Exception |
| */ |
| private List<String> getJavaVersionInfo( String homePath ) |
| throws Exception |
| { |
| |
| String executable = homePath + File.separator + "bin" + File.separator + "java"; |
| ListOutputConsumer outputConsumer = new ListOutputConsumer(); |
| ExecutionResult result = shellCommandHelper.executeShellCommand( null, executable, new String[] { "-version" }, |
| outputConsumer, -1, null ); |
| int exitCode = result.getExitCode(); |
| if ( exitCode != 0 ) |
| { |
| throw new Exception( |
| String.format( "failed to get java version information, %s returned exit code %s", executable, |
| exitCode ) ); |
| } |
| return outputConsumer.getList(); |
| } |
| |
| private Map<String, String> getEnvVars( Profile profile ) |
| { |
| Map<String, String> environnments = new HashMap<String, String>(); |
| if ( profile == null ) |
| { |
| return environnments; |
| } |
| if ( profile.getBuilder() != null ) |
| { |
| environnments.put( profile.getBuilder().getVarName(), profile.getBuilder().getVarValue() ); |
| } |
| if ( profile.getJdk() != null ) |
| { |
| environnments.put( profile.getJdk().getVarName(), profile.getJdk().getVarValue() ); |
| } |
| if ( profile.getEnvironmentVariables() != null ) |
| { |
| for ( Installation installation : (List<Installation>) profile.getEnvironmentVariables() ) |
| { |
| environnments.put( installation.getVarName(), installation.getVarValue() ); |
| } |
| } |
| return environnments; |
| } |
| |
| /** |
| * @see org.apache.maven.continuum.installation.InstallationService#getExecutorVersionInfo(java.lang.String, org.apache.maven.continuum.execution.ExecutorConfigurator, Profile) |
| */ |
| public List<String> getExecutorVersionInfo( String path, ExecutorConfigurator executorConfigurator, |
| Profile profile ) |
| throws InstallationException |
| { |
| if ( executorConfigurator == null || executorConfigurator.getExecutable() == null ) |
| { |
| return Collections.EMPTY_LIST; |
| } |
| |
| StringBuilder executable = new StringBuilder(); |
| |
| Map<String, String> env = new HashMap<String, String>(); |
| |
| if ( StringUtils.isNotEmpty( path ) ) |
| { |
| executable.append( path ).append( File.separator ); |
| executable.append( executorConfigurator.getRelativePath() ).append( File.separator ); |
| env.put( executorConfigurator.getEnvVar(), path ); |
| } |
| executable = executable.append( executorConfigurator.getExecutable() ); |
| |
| env.putAll( getEnvVars( profile ) ); |
| |
| ListOutputConsumer outputConsumer = new ListOutputConsumer(); |
| ExecutionResult result; |
| try |
| { |
| result = shellCommandHelper.executeShellCommand( null, executable.toString(), |
| new String[] { executorConfigurator.getVersionArgument() }, |
| outputConsumer, -1, null ); |
| } |
| catch ( Exception e ) |
| { |
| log.error( "failed to get executor version info", e ); |
| throw new InstallationException( e.getMessage(), e ); |
| } |
| int exitCode = result.getExitCode(); |
| if ( exitCode != 0 ) |
| { |
| |
| throw new InstallationException( |
| String.format( "failed to get executor version info, %s returned exit code %s", executable, |
| exitCode ) ); |
| } |
| return outputConsumer.getList(); |
| } |
| |
| private boolean alreadyExistInstallationName( Installation installation ) |
| throws InstallationException |
| { |
| List<Installation> all = getAllInstallations(); |
| for ( Installation install : all ) |
| { |
| if ( org.apache.commons.lang.StringUtils.equals( installation.getName(), install.getName() ) && |
| ( installation.getInstallationId() == 0 || |
| installation.getInstallationId() != install.getInstallationId() ) ) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| } |
