/*
* 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.ccm;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Execute;
import org.apache.tools.ant.taskdefs.ExecuteStreamHandler;
import org.apache.tools.ant.types.Commandline;
/**
* Creates new Continuus ccm task and sets it as the default.
*
* @ant.task name="ccmcreatetask" category="scm"
*/
public class CCMCreateTask extends Continuus implements ExecuteStreamHandler {
private String comment = null;
private String platform = null;
private String resolver = null;
private String release = null;
private String subSystem = null;
private String task = null;
/**
* Constructor for CCMCreateTask.
*/
public CCMCreateTask() {
super();
setCcmAction(COMMAND_CREATE_TASK);
}
/**
* Executes the task.
* <p>
* Builds a command line to execute ccm and then calls Exec's run method
* to execute the command line.
* </p>
* @throws BuildException on error
*/
public void execute() throws BuildException {
Commandline commandLine = new Commandline();
int result = 0;
// build the command line from what we got the format
// as specified in the CCM.EXE help
commandLine.setExecutable(getCcmCommand());
commandLine.createArgument().setValue(getCcmAction());
checkOptions(commandLine);
result = run(commandLine, this);
if (Execute.isFailure(result)) {
String msg = "Failed executing: " + commandLine.toString();
throw new BuildException(msg, getLocation());
}
//create task ok, set this task as the default one
Commandline commandLine2 = new Commandline();
commandLine2.setExecutable(getCcmCommand());
commandLine2.createArgument().setValue(COMMAND_DEFAULT_TASK);
commandLine2.createArgument().setValue(getTask());
log(commandLine.describeCommand(), Project.MSG_DEBUG);
result = run(commandLine2);
if (result != 0) {
String msg = "Failed executing: " + commandLine2.toString();
throw new BuildException(msg, getLocation());
}
}
/**
* Check the command line options.
*/
private void checkOptions(Commandline cmd) {
if (getComment() != null) {
cmd.createArgument().setValue(FLAG_COMMENT);
cmd.createArgument().setValue("\"" + getComment() + "\"");
}
if (getPlatform() != null) {
cmd.createArgument().setValue(FLAG_PLATFORM);
cmd.createArgument().setValue(getPlatform());
} // end of if ()
if (getResolver() != null) {
cmd.createArgument().setValue(FLAG_RESOLVER);
cmd.createArgument().setValue(getResolver());
} // end of if ()
if (getSubSystem() != null) {
cmd.createArgument().setValue(FLAG_SUBSYSTEM);
cmd.createArgument().setValue("\"" + getSubSystem() + "\"");
} // end of if ()
if (getRelease() != null) {
cmd.createArgument().setValue(FLAG_RELEASE);
cmd.createArgument().setValue(getRelease());
} // end of if ()
}
/**
* Get the value of comment.
* @return value of comment.
*/
public String getComment() {
return comment;
}
/**
* Specifies a comment.
*
* @param v Value to assign to comment.
*/
public void setComment(String v) {
this.comment = v;
}
/**
* Get the value of platform.
* @return value of platform.
*/
public String getPlatform() {
return platform;
}
/**
* Specifies the target platform.
*
* @param v Value to assign to platform.
*/
public void setPlatform(String v) {
this.platform = v;
}
/**
* Get the value of resolver.
* @return value of resolver.
*/
public String getResolver() {
return resolver;
}
/**
* Specifies the resolver.
*
* @param v Value to assign to resolver.
*/
public void setResolver(String v) {
this.resolver = v;
}
/**
* Get the value of release.
* @return value of release.
*/
public String getRelease() {
return release;
}
/**
* Specify the CCM release.
*
* @param v Value to assign to release.
*/
public void setRelease(String v) {
this.release = v;
}
/**
* Get the value of subSystem.
* @return value of subSystem.
*/
public String getSubSystem() {
return subSystem;
}
/**
* Specifies the subsystem.
*
* @param v Value to assign to subSystem.
*/
public void setSubSystem(String v) {
this.subSystem = v;
}
/**
* Get the value of task.
* @return value of task.
*/
public String getTask() {
return task;
}
/**
* Specifies the task number used to checkin
* the file (may use 'default').
*
* @param v Value to assign to task.
*/
public void setTask(String v) {
this.task = v;
}
/**
* /comment -- comments associated to the task
*/
public static final String FLAG_COMMENT = "/synopsis";
/**
* /platform flag -- target platform
*/
public static final String FLAG_PLATFORM = "/plat";
/**
* /resolver flag
*/
public static final String FLAG_RESOLVER = "/resolver";
/**
* /release flag
*/
public static final String FLAG_RELEASE = "/release";
/**
* /release flag
*/
public static final String FLAG_SUBSYSTEM = "/subsystem";
/**
* -task flag -- associate checkout task with task
*/
public static final String FLAG_TASK = "/task";
// implementation of org.apache.tools.ant.taskdefs.ExecuteStreamHandler interface
/**
*
* @throws IOException on error
*/
public void start() throws IOException {
}
/**
*
*/
public void stop() {
}
/**
*
* @param param1 the output stream
* @exception java.io.IOException on error
*/
public void setProcessInputStream(OutputStream param1) throws IOException {
}
/**
*
* @param is the input stream
* @exception java.io.IOException on error
*/
public void setProcessErrorStream(InputStream is) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
String s = reader.readLine();
if (s != null) {
log("err " + s, Project.MSG_DEBUG);
} // end of if ()
}
/**
* read the output stream to retrieve the new task number.
* @param is InputStream
* @throws IOException on error
*/
public void setProcessOutputStream(InputStream is) throws IOException {
String buffer = "";
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
buffer = reader.readLine();
if (buffer != null) {
log("buffer:" + buffer, Project.MSG_DEBUG);
String taskstring = buffer.substring(buffer.indexOf(' ')).trim();
taskstring = taskstring.substring(0, taskstring.lastIndexOf(' ')).trim();
setTask(taskstring);
log("task is " + getTask(), Project.MSG_DEBUG);
} // end of if ()
} catch (NullPointerException npe) {
log("error procession stream , null pointer exception", Project.MSG_ERR);
npe.printStackTrace();
throw new BuildException(npe.getClass().getName());
} catch (Exception e) {
log("error procession stream " + e.getMessage(), Project.MSG_ERR);
throw new BuildException(e.getMessage());
} // end of try-catch
}
}
|
