/*
* 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.
*
*/
package org.apache.tools.ant.taskdefs.optional.starteam;
import com.starbase.starteam.Folder;
import com.starbase.starteam.Item;
import com.starbase.starteam.Status;
import com.starbase.starteam.View;
import com.starbase.starteam.ViewConfiguration;
import java.io.IOException;
import java.util.Enumeration;
import org.apache.tools.ant.BuildException;
/**
* Checks files into a StarTeam project.
* Optionally adds files and in the local tree that
* are not managed by the repository to its control.
* Created: Sat Dec 15 20:26:07 2001
*
* @version 1.0
*
* @ant.task name="stcheckin" category="scm" product="Starteam"
*/
public class StarTeamCheckin extends TreeBasedTask {
/**
* Constructor for StarTeamCheckin.
*/
public StarTeamCheckin() {
// we want this to have a false default, unlike for Checkin.
setRecursive(false);
}
private boolean createFolders = true;
/**
* The comment which will be stored with the checkin.
*/
private String comment = null;
/**
* holder for the add Uncontrolled attribute. If true, all
* local files not in StarTeam will be added to the repository.
*/
private boolean addUncontrolled = false;
/**
* Sets the value of createFolders
*
* @param argCreateFolders Value to assign to this.createFolders
*/
public void setCreateFolders(boolean argCreateFolders) {
this.createFolders = argCreateFolders;
}
/**
* Get the comment attribute for this operation
* @return value of comment.
*/
public String getComment() {
return this.comment;
}
/**
* Optional checkin comment to be saved with the file.
* @param comment Value to assign to comment.
*/
public void setComment(String comment) {
this.comment = comment;
}
/**
* Get the value of addUncontrolled.
* @return value of addUncontrolled.
*/
public boolean isAddUncontrolled() {
return this.addUncontrolled;
}
/**
* if true, any files or folders NOT in StarTeam will be
* added to the repository. Defaults to "false".
* @param addUncontrolled Value to assign to addUncontrolled.
*/
public void setAddUncontrolled(boolean addUncontrolled) {
this.addUncontrolled = addUncontrolled;
}
/**
* This attribute tells whether unlocked files on checkin (so that
* other users may access them) checkout or to leave the checkout status
* alone (default).
* @see #setUnlocked(boolean)
*/
private int lockStatus = Item.LockType.UNCHANGED;
/**
* Set to do an unlocked checkout; optional, default is false;
* If true, file will be unlocked so that other users may
* change it. If false, lock status will not change.
* @param v true means do an unlocked checkout
* false means leave status alone.
*/
public void setUnlocked(boolean v) {
if (v) {
this.lockStatus = Item.LockType.UNLOCKED;
} else {
this.lockStatus = Item.LockType.UNCHANGED;
}
}
/**
* Override of base-class abstract function creates an
* appropriately configured view. For checkins this is
* always the current or "tip" view.
*
* @param raw the unconfigured <code>View</code>
* @return the snapshot <code>View</code> appropriately configured.
*/
protected View createSnapshotView(View raw) {
return new View(raw, ViewConfiguration.createTip());
}
/**
* Implements base-class abstract function to define tests for
* any preconditons required by the task.
*
* @exception BuildException thrown if both rootLocalFolder
* and viewRootLocalFolder are defined
*/
protected void testPreconditions() throws BuildException {
}
/**
* Implements base-class abstract function to emit to the log an
* entry describing the parameters that will be used by this operation.
*
* @param starteamrootFolder
* root folder in StarTeam for the operation
* @param targetrootFolder
* root local folder for the operation
* (whether specified by the user or not).
*/
protected void logOperationDescription(
Folder starteamrootFolder, java.io.File targetrootFolder) {
log((this.isRecursive() ? "Recursive" : "Non-recursive")
+ " Checkin from"
+ (null == getRootLocalFolder() ? " (default): " : ": ")
+ targetrootFolder.getAbsolutePath());
log("Checking in to: " + starteamrootFolder.getFolderHierarchy());
logIncludes();
logExcludes();
if (this.lockStatus == Item.LockType.UNLOCKED) {
log(" Items will be checked in unlocked.");
} else {
log(" Items will be checked in with no change in lock status.");
}
if (this.isForced()) {
log(" Items will be checked in in accordance with repository "
+ "status and regardless of lock status.");
} else {
log(" Items will be checked in regardless of repository status "
+ "only if locked.");
}
}
/**
* Implements base-class abstract function to perform the checkout
* operation on the files in each folder of the tree.
*
* @param starteamFolder the StarTeam folder to which files
* will be checked in
* @param targetFolder local folder from which files will be checked in
* @exception BuildException if any error occurs
*/
protected void visit(Folder starteamFolder, java.io.File targetFolder)
throws BuildException {
try {
if (null != getRootLocalFolder()) {
starteamFolder.setAlternatePathFragment(
targetFolder.getAbsolutePath());
}
Folder[] foldersList = starteamFolder.getSubFolders();
Item[] stFiles = starteamFolder.getItems(getTypeNames().FILE);
// note, it's important to scan the items BEFORE we make the
// UnmatchedFileMap because that creates a bunch of NEW
// folders and files (unattached to repository) and we
// don't want to include those in our traversal.
UnmatchedFileMap ufm =
new CheckinMap().init(
targetFolder.getAbsoluteFile(), starteamFolder);
for (int i = 0, size = foldersList.length; i < size; i++) {
Folder stFolder = foldersList[i];
java.io.File subfolder =
new java.io.File(targetFolder, stFolder.getName());
ufm.removeControlledItem(subfolder);
if (isRecursive()) {
visit(stFolder, subfolder);
}
}
for (int i = 0, size = stFiles.length; i < size; i++) {
com.starbase.starteam.File stFile =
(com.starbase.starteam.File) stFiles[i];
processFile(stFile);
ufm.removeControlledItem(
new java.io.File(targetFolder, stFile.getName()));
}
if (this.addUncontrolled) {
ufm.processUncontrolledItems();
}
} catch (IOException e) {
throw new BuildException(e);
}
}
/**
* provides a string showing from and to full paths for logging
*
* @param remotefile the Star Team file being processed.
*
* @return a string showing from and to full paths
*/
private String describeCheckin(com.starbase.starteam.File remotefile) {
StringBuffer sb = new StringBuffer();
sb.append(remotefile.getFullName())
.append(" --> ")
.append(getFullRepositoryPath(remotefile));
return sb.toString();
}
/**
* Processes (checks-out) <code>stFiles</code>files from StarTeam folder.
*
* @param eachFile repository file to process
* @param targetFolder a java.io.File (Folder) to work
* @throws IOException when StarTeam API fails to work with files
*/
private void processFile(com.starbase.starteam.File eachFile)
throws IOException {
String filename = eachFile.getName();
// If the file doesn't pass the include/exclude tests, skip it.
if (!shouldProcess(filename)) {
log("Excluding " + getFullRepositoryPath(eachFile));
return;
}
boolean checkin = true;
int fileStatus = (eachFile.getStatus());
// We try to update the status once to give StarTeam
// another chance.
if (fileStatus == Status.MERGE || fileStatus == Status.UNKNOWN) {
eachFile.updateStatus(true, true);
fileStatus = (eachFile.getStatus());
}
if (fileStatus == Status.MODIFIED) {
log("Checking in: " + describeCheckin(eachFile));
} else if (fileStatus == Status.MISSING) {
log("Local file missing: " + describeCheckin(eachFile));
checkin = false;
} else {
if (isForced()) {
log("Forced checkin of " + describeCheckin(eachFile)
+ " over status " + Status.name(fileStatus));
} else {
log("Skipping: " + getFullRepositoryPath(eachFile)
+ " - status: " + Status.name(fileStatus));
checkin = false;
}
}
if (checkin) {
eachFile.checkin(this.comment, this.lockStatus,
this.isForced(), true, true);
}
}
/**
* handles the deletion of uncontrolled items
*/
private class CheckinMap extends UnmatchedFileMap {
protected boolean isActive() {
return StarTeamCheckin.this.addUncontrolled;
}
/**
* This override adds all its members to the repository. It is assumed
* that this method will not be called until all the items in the
* corresponding folder have been processed, and that the internal map
* will contain only uncontrolled items.
*/
void processUncontrolledItems() throws BuildException {
if (this.isActive()) {
Enumeration e = this.keys();
while (e.hasMoreElements()) {
java.io.File local = (java.io.File) e.nextElement();
Item remoteItem = (Item) this.get(local);
remoteItem.update();
// once we find a folder that isn't in the repository,
// we know we can add it.
if (local.isDirectory()) {
Folder folder = (Folder) remoteItem;
log("Added uncontrolled folder "
+ folder.getFolderHierarchy()
+ " from " + local.getAbsoluteFile());
if (isRecursive()) {
UnmatchedFileMap submap =
new CheckinMap().init(local, folder);
submap.processUncontrolledItems();
}
} else {
com.starbase.starteam.File remoteFile =
(com.starbase.starteam.File) remoteItem;
log("Added uncontrolled file "
+ TreeBasedTask.getFullRepositoryPath(remoteFile)
+ " from " + local.getAbsoluteFile());
}
}
}
}
}
}
|
