package org.apache.maven.scm.provider.clearcase.command.checkout;
/*
* 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 java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import org.apache.maven.scm.ScmException;
import org.apache.maven.scm.ScmFileSet;
import org.apache.maven.scm.ScmVersion;
import org.apache.maven.scm.command.checkout.AbstractCheckOutCommand;
import org.apache.maven.scm.command.checkout.CheckOutScmResult;
import org.apache.maven.scm.provider.ScmProviderRepository;
import org.apache.maven.scm.provider.clearcase.command.ClearCaseCommand;
import org.apache.maven.scm.provider.clearcase.repository.ClearCaseScmProviderRepository;
import org.apache.maven.scm.providers.clearcase.settings.Settings;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;
/**
* @author <a href="mailto:wim.deblauwe@gmail.com">Wim Deblauwe</a>
* @author <a href="mailto:frederic.mura@laposte.net">Frederic Mura</a>
*
*/
public class ClearCaseCheckOutCommand
extends AbstractCheckOutCommand
implements ClearCaseCommand
{
private Settings settings = null;
// ----------------------------------------------------------------------
// AbstractCheckOutCommand Implementation
// ----------------------------------------------------------------------
/** {@inheritDoc} */
protected CheckOutScmResult executeCheckOutCommand( ScmProviderRepository repository, ScmFileSet fileSet,
ScmVersion version, boolean recursive )
throws ScmException
{
if ( getLogger().isDebugEnabled() )
{
getLogger().debug( "executing checkout command..." );
}
ClearCaseScmProviderRepository repo = (ClearCaseScmProviderRepository) repository;
File workingDirectory = fileSet.getBasedir();
if ( version != null && getLogger().isDebugEnabled() )
{
getLogger().debug( version.getType() + ": " + version.getName() );
}
if ( getLogger().isDebugEnabled() )
{
getLogger().debug( "Running with CLEARCASE " + settings.getClearcaseType() );
}
ClearCaseCheckOutConsumer consumer = new ClearCaseCheckOutConsumer( getLogger() );
CommandLineUtils.StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer();
int exitCode;
Commandline cl;
String projectDirectory = "";
try
{
// Since clearcase only wants to checkout to a non-existent directory, first delete the working dir
// if it already exists
FileUtils.deleteDirectory( workingDirectory );
// First create the view
String viewName = getUniqueViewName( repo, workingDirectory.getAbsolutePath() );
String streamIdentifier = getStreamIdentifier( repo.getStreamName(), repo.getVobName() );
cl = createCreateViewCommandLine( workingDirectory, viewName, streamIdentifier );
if ( getLogger().isInfoEnabled() )
{
getLogger().info( "Executing: " + cl.getWorkingDirectory().getAbsolutePath() + ">>" + cl.toString() );
}
exitCode =
CommandLineUtils.executeCommandLine( cl, new CommandLineUtils.StringStreamConsumer(), stderr );
if ( exitCode == 0 )
{
File configSpecLocation;
if ( !repo.isAutoConfigSpec() )
{
configSpecLocation = repo.getConfigSpec();
if ( version != null && StringUtils.isNotEmpty( version.getName() ) )
{
// Another config spec is needed in this case.
//
// One option how to implement this would be to use a name convention for the config specs,
// e.g. the tag name could be appended to the original config spec name.
// If the config spec from the SCM URL would be \\myserver\configspecs\someproj.txt
// and the tag name would be mytag, the new config spec location could be
// \\myserver\configspecs\someproj-mytag.txt
//
throw new UnsupportedOperationException(
"Building on a label not supported with user-specified config specs" );
}
}
else
{
// write config spec to temp file
String configSpec;
if ( !repo.hasElements() )
{
configSpec = createConfigSpec( repo.getLoadDirectory(), version );
}
else
{
configSpec = createConfigSpec( repo.getLoadDirectory(), repo.getElementName(), version );
}
if ( getLogger().isInfoEnabled() )
{
getLogger().info( "Created config spec for view '" + viewName + "':\n" + configSpec );
}
configSpecLocation = writeTemporaryConfigSpecFile( configSpec, viewName );
// When checking out from ClearCase, the directory structure of the
// SCM system is repeated within the checkout directory. E.g. if you check out the
// project "my/project" to "/some/dir", the project sources are actually checked out
// to "my/project/some/dir".
projectDirectory = repo.getLoadDirectory();
// strip off leading / to make the path relative
if ( projectDirectory.startsWith( "/" ) )
{
projectDirectory = projectDirectory.substring( 1 );
}
}
cl = createUpdateConfigSpecCommandLine( workingDirectory, configSpecLocation, viewName );
if ( getLogger().isInfoEnabled() )
{
getLogger().info( "Executing: " + cl.getWorkingDirectory().getAbsolutePath()
+ ">>" + cl.toString() );
}
exitCode = CommandLineUtils.executeCommandLine( cl, consumer, stderr );
}
}
catch ( CommandLineException ex )
{
throw new ScmException( "Error while executing clearcase command.", ex );
}
catch ( IOException ex )
{
throw new ScmException( "Error while deleting working directory.", ex );
}
if ( exitCode != 0 )
{
return new CheckOutScmResult( cl.toString(), "The cleartool command failed.", stderr.getOutput(), false );
}
return new CheckOutScmResult( cl.toString(), consumer.getCheckedOutFiles(), projectDirectory );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
/**
* Creates a temporary config spec file with the given contents that will be
* deleted on VM exit.
*
* @param configSpecContents The contents for the file
* @param viewName The name of the view; used to determine an appropriate file
* name
* @throws IOException
*/
protected File writeTemporaryConfigSpecFile( String configSpecContents, String viewName )
throws IOException
{
File configSpecLocation = File.createTempFile( "configspec-" + viewName, ".txt" );
FileWriter fw = new FileWriter( configSpecLocation );
try
{
fw.write( configSpecContents );
}
finally
{
try
{
fw.close();
}
catch ( IOException e )
{
// ignore
}
}
configSpecLocation.deleteOnExit();
return configSpecLocation;
}
/**
* Creates a config spec that loads the given loadDirectory and uses the
* given version tag
*
* @param loadDirectory the VOB directory to be loaded
* @param version ClearCase label type; notice that branch types are not
* supported
* @return Config Spec as String
*/
protected String createConfigSpec( String loadDirectory, ScmVersion version )
{
// create config spec
StringBuilder configSpec = new StringBuilder();
configSpec.append( "element * CHECKEDOUT\n" );
if ( version != null && StringUtils.isNotEmpty( version.getName() ) )
{
configSpec.append( "element * " + version.getName() + "\n" );
configSpec.append( "element -directory * /main/LATEST\n" );
// configSpec.append( "element * /main/QualityControl_INT/RAD7_Migration/LATEST\n" );
}
else
{
configSpec.append( "element * /main/LATEST\n" );
}
configSpec.append( "load " + loadDirectory + "\n" );
return configSpec.toString();
}
protected String createConfigSpec( String loadDirectory, String elementName, ScmVersion version )
{
// create config spec
StringBuilder configSpec = new StringBuilder();
configSpec.append( "element * CHECKEDOUT\n" );
if ( version != null && StringUtils.isNotEmpty( version.getName() ) )
{
configSpec.append( "element * " + version.getName() + "\n" );
configSpec.append( "element * " + elementName + "\n" );
}
else
{
configSpec.append( "element * /main/LATEST\n" );
}
configSpec.append( "load " + loadDirectory + "\n" );
return configSpec.toString();
}
// private static Commandline createDeleteViewCommandLine( ClearCaseScmProviderRepository repository,
// File workingDirectory )
// {
// Commandline command = new Commandline();
//
// command.setWorkingDirectory( workingDirectory.getAbsolutePath() );
//
// command.setExecutable( "cleartool" );
//
// command.createArg().setValue( "rmview" );
// command.createArg().setValue( "-force" );
// command.createArg().setValue( "-tag" );
// if ( isClearCaseLT() )
// {
// command.createArg().setValue( getViewStore() );
// }
// else
// {
// command.createArg().setValue( getUniqueViewName( repository, workingDirectory.getAbsolutePath() ) );
// }
//
// return command;
// }
protected Commandline createCreateViewCommandLine( File workingDirectory, String viewName, String streamIdentifier )
throws IOException
{
Commandline command = new Commandline();
// We have to execute from 1 level up from the working dir, since we had to delete the working dir
command.setWorkingDirectory( workingDirectory.getParentFile().getAbsolutePath() );
command.setExecutable( "cleartool" );
command.createArg().setValue( "mkview" );
command.createArg().setValue( "-snapshot" );
command.createArg().setValue( "-tag" );
command.createArg().setValue( viewName );
if ( isClearCaseUCM() )
{
command.createArg().setValue( "-stream" );
command.createArg().setValue( streamIdentifier );
}
if ( !isClearCaseLT() )
{
if ( useVWS() )
{
command.createArg().setValue( "-vws" );
command.createArg().setValue( getViewStore() + viewName + ".vws" );
}
}
command.createArg().setValue( workingDirectory.getCanonicalPath() );
return command;
}
/**
* Format the stream identifier for ClearCaseUCM
* @param streamName
* @param vobName
* @return the formatted stream identifier if the two parameter are not null
*/
protected String getStreamIdentifier( String streamName, String vobName )
{
if ( streamName == null || vobName == null )
{
return null;
}
return "stream:" + streamName + "@" + vobName;
}
protected Commandline createUpdateConfigSpecCommandLine( File workingDirectory, File configSpecLocation,
String viewName )
{
Commandline command = new Commandline();
command.setWorkingDirectory( workingDirectory.getAbsolutePath() );
command.setExecutable( "cleartool" );
command.createArg().setValue( "setcs" );
command.createArg().setValue( "-tag" );
command.createArg().setValue( viewName );
command.createArg().setValue( configSpecLocation.getAbsolutePath() );
return command;
}
private String getUniqueViewName( ClearCaseScmProviderRepository repository, String absolutePath )
{
String uniqueId;
int lastIndexBack = absolutePath.lastIndexOf( '\\' );
int lastIndexForward = absolutePath.lastIndexOf( '/' );
if ( lastIndexBack != -1 )
{
uniqueId = absolutePath.substring( lastIndexBack + 1 );
}
else
{
uniqueId = absolutePath.substring( lastIndexForward + 1 );
}
return repository.getViewName( uniqueId );
}
protected String getViewStore()
{
String result = null;
if ( settings.getViewstore() != null )
{
result = settings.getViewstore();
}
if ( result == null )
{
result = "\\\\" + getHostName() + "\\viewstore\\";
}
else
{
// If ClearCase LT are use, the View store is identify by the
// username.
if ( isClearCaseLT() )
{
result = result + getUserName() + "\\";
}
}
return result;
}
protected boolean isClearCaseLT()
{
return ClearCaseScmProviderRepository.CLEARCASE_LT.equals( settings.getClearcaseType() );
}
protected boolean isClearCaseUCM()
{
return ClearCaseScmProviderRepository.CLEARCASE_UCM.equals( settings.getClearcaseType() );
}
/**
* @return the value of the setting property 'useVWS'
*/
protected boolean useVWS()
{
return settings.isUseVWSParameter();
}
private String getHostName()
{
String hostname;
try
{
hostname = InetAddress.getLocalHost().getHostName();
}
catch ( UnknownHostException e )
{
// Should never happen
throw new RuntimeException( e );
}
return hostname;
}
private String getUserName()
{
String username;
username = System.getProperty( "user.name" );
return username;
}
public void setSettings( Settings settings )
{
this.settings = settings;
}
}