Build 设置RTC Jazz生成定义的全局属性

我在RTC/Jazz中有几个构建定义，我使用一个变量在各种构建定义中设置DB Release

• 构建库
• 构建服务器应用程序
• 构建运行测试服务器
• 构建客户端应用程序
• 构建运行测试客户端

在所有定义中，我都使用属性DB_模式

DB_SCHEMA = 8.1

一旦我们更新了数据库并使用了新的模式，我就必须将Build属性设置为

DB_SCHEMA = 8.2

现在我必须更新所有生成定义。。。如果我忘了一个或拼错了什么，我的老板就会生我的气——开玩笑，但老实说，我不想犯错误

-->如何定义可用于所有构建定义的全局属性？

我不知道，因此您可以考虑开发一个程序：

• 使用
• 对于每个生成定义，将属性设置为预期值（如所示）

---

好的，这里是我的解决方案：
一部分是RTC适配器，用于处理与RTC基座之间的连接：
（它提供了更多与此解决方案无关的getter/setter-我清除了它们）
RTC适配器 另一部分是工人阶级，我称之为BuildDefinitionHelper（多好的名字，哈哈）
BuildDefinitionHelper

公共类BuildDefinitionHelper{
/**
*@param args
*/
公共静态void main（字符串[]args）{
new BuildDefinitionHelper（）.startUp（）；//启动不太好，但我不介意
}
私有最终字符串[]adaPublishDefinitionList=新字符串[]{
“发布ada-40”，
“每晚发布ada-40”，
“发布ada-54”，
“每晚发布ada-54”，
“发布ada-56”，
“每晚发布ada-56”，
“发布ada-58”，
“每晚发布ada-58”，
};  
私有最终字符串BUILD\u NR=“BUILD\u NR”；
专用最终字符串MAJOR=“MAJOR”；
私有最终字符串MINOR=“MINOR”；
私有void启动（）{
最终国际专业=57；
最终整型小调=11；
最终整数构建=1；
//连接
如果（RtcAdapter.inst（）.connect（））{
//获取所需资源-这里使用单例很有帮助（请参见上文）
IProgressMonitor pMon=RtcAdapter.inst（）.getMonitor（）；
ITeamBuildClient buildClient=RtcAdapter.inst（）.getBuildClient（）；
试试{
对于（字符串adaPublish:adaPublishDefinitionList）{
//获取生成定义
IBuildDefinition workingCopy=getBuildDefinition（adaPublish、buildClient、pMon）；
//设置属性
字符串propMajor=GetFormattedIntegrater（主）；
字符串propMinor=GetFormattedInteger（次要）；
String propBuild=GetFormattedIntegrater（构建）；
setBuildProperty（主要、propMajor、工作副本）；
setBuildProperty（次要、propMinor、工作副本）；
setBuildProperty（构建编号、propBuild、工作副本）；
//存储更改
saveBuildDefinition（workingCopy、buildClient、pMon）；
}
}捕获（IllegalArgumentException e）{
e、 printStackTrace（）；
}捕获（TeamRepositoryException e）{
e、 printStackTrace（）；
}
//最后：断开连接
RtcAdapter.inst（）.disconnect（）；
}
}
私有void saveBuildDefinition（IBuildDefinition、ITeamBuildClient buildClient、IProgressMonitor progressMonitor）引发TeamBuildDuplicateItemException、IllegalArgumentException、TeamRepositoryException{
buildClient.save（定义，progressMonitor）；
}
私有字符串GetFormattedInteger（int值）{
如果（value>=0&&value=10&&value Hello VonC再次出现-你是一个非常聪明的人-这个解决方案对我很有用！！！我仍然对你能做什么和你能做什么印象深刻！这是一个很好的答案！（但需要一些努力^^）好的，我现在实现了你的答案-花了相当长的时间，但现在我完成了（花时间是因为我在做一些不同的事情，而不是因为很难做到）…现在对我们来说效果很好！再次感谢！@MartinFrank Great！您能为实现的主要部分添加一个答案吗？很抱歉再次询问，但您能为计划制表器中的“enabled”（已启用）按钮添加属性吗？您的解决方案效果非常好，我想扩大此方法-现在我可以启用/禁用所有夜间构建作业。。。因此，当我知道服务器将关闭时，我可以停止它…我甚至可以++你的回答这是一个非常好的答案，使我的工作更容易！！好吧，我必须对你说-你在很多情况下都帮了很大的忙-我真的很高兴你在StackOverFlow上！！！没问题：我每天都在这里（）
IBuildDefinition definition = (IBuildDefinition) buildDefinition.getWorkingCopy();
definition.setProperty("propertyName","");
definition = buildClient.save(definition, monitor); 

public class RtcAdapter {

//yes i know - having hardcoded user/pass is bad, ignore this - image it's in a property file or set by a popup dialog
private static final String repositoryURI = "https://xxxxxxxxxxxx/ccm";
private static final String userId = "xxxxxxxxxxx";
private static final String password = "xxxxxxxxxx";
private static final String projectAreaName = "xxxxxxxxxx";

private ITeamRepository teamRepository = null;
private IProgressMonitor monitor = new NullProgressMonitor();
private IProjectArea projectArea = null;
private ITeamBuildClient buildClient = null;

//i'm implementing a singleton class - you can argue with mie if it's a good approach
private static final RtcAdapter inst = new RtcAdapter();

private RtcAdapter(){       
    super();
}

public ITeamRepository getTeamRepository() {
    return teamRepository;
}

public IProgressMonitor getMonitor() {
    return monitor;
}

public IProjectArea getProjctArea(){
    return projectArea;
}

public ITeamBuildClient getBuildClient(){
    return buildClient;
}

private void setTeamRepository(ITeamRepository teamRepositoryIn) {
    teamRepository = teamRepositoryIn;
}

/**
 * 
 * @param repositoryURI
 * @param userId
 * @param password
 * @param monitor
 * @return
 * @throws TeamRepositoryException 
 */

private ITeamRepository login(String repositoryURI, String userId,String password, IProgressMonitor monitor) throws TeamRepositoryException {       

    ITeamRepository teamRepository = TeamPlatform.getTeamRepositoryService().getTeamRepository(repositoryURI);
    teamRepository.registerLoginHandler(new LoginHandler(userId, password));
    teamRepository.login(monitor);
    return teamRepository;
}

/**
 * LoginHandler required by login function
 *
 */
private static class LoginHandler implements ILoginHandler, ILoginInfo {

    private String fUserId;
    private String fPassword;

    private LoginHandler(String userId, String password) {
        fUserId = userId;
        fPassword = password;
    }

    public String getUserId() {
        return fUserId;
    }

    public String getPassword() {
        return fPassword;
    }

    public ILoginInfo challenge(ITeamRepository repository) {
        return this;
    }

}

public static RtcAdapter inst() {
    return inst;
}

public boolean connect() {

    TeamPlatform.startup();

    System.out.println("Team Platform Startup");
    try {
        IProgressMonitor monitor = new NullProgressMonitor();
        setTeamRepository(login(repositoryURI, userId, password, monitor));
        System.out.println("Logged in");            

        IProcessClientService processClient= (IProcessClientService) getTeamRepository().getClientLibrary(IProcessClientService.class);
        URI uri= URI.create(projectAreaName.replaceAll(" ", "%20"));
        projectArea = (IProjectArea) processClient.findProcessArea(uri, null, RtcAdapter.inst().getMonitor() );

        buildClient = (ITeamBuildClient) getTeamRepository().getClientLibrary(ITeamBuildClient.class);

        System.out.println("projet area = "+projectArea.getName() );
    } catch (TeamRepositoryException e) {
        System.out.println("TeamRepositoryException : " + e.getMessage());
        e.printStackTrace();
        return false;
    } catch (Exception e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
        return false;
    }
    return true;
}

public void disconnect(){
    System.out.println("Logged out");
    TeamPlatform.shutdown();
}

}

public class BuildDefinitionHelper {

/**
 * @param args
 */
public static void main(String[] args) {
    new BuildDefinitionHelper().startUp();  //not-so-nice startup, but i don't mind
}

private final String[] adaPublishDefinitionList = new String[]{
        "publish ada develop-40",
        "publish ada develop-40 nightly",
        "publish ada develop-54",
        "publish ada develop-54 nightly",
        "publish ada develop-56",
        "publish ada develop-56 nightly",
        "publish ada develop-58",
        "publish ada develop-58 nightly",
};  

private final String BUILD_NR = "BUILD_NR";
private final String MAJOR = "MAJOR";
private final String MINOR = "MINOR";

private void startUp() {

    final int major = 57;
    final int minor = 11;
    final int build = 1;

    //connect
    if (RtcAdapter.inst().connect() ){

        //getting  required resources - a singleton is helpful here (look above)
        IProgressMonitor pMon = RtcAdapter.inst().getMonitor();         
        ITeamBuildClient buildClient = RtcAdapter.inst().getBuildClient();

        try {               

            for (String adaPublish: adaPublishDefinitionList ){                 
                //get build definition
                IBuildDefinition workingCopy = getBuildDefinition(adaPublish, buildClient, pMon);   

                //seting properties
                String propMajor = getFormattededInteger(major);
                String propMinor = getFormattededInteger(minor);
                String propBuild = getFormattededInteger(build);

                setBuildProperty(MAJOR, propMajor, workingCopy);
                setBuildProperty(MINOR, propMinor, workingCopy);
                setBuildProperty(BUILD_NR, propBuild, workingCopy);

                //store changes
                saveBuildDefinition(workingCopy, buildClient, pMon);
            }

        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (TeamRepositoryException e) {
            e.printStackTrace();
        }

        //at the end: disconnect
        RtcAdapter.inst().disconnect();         
    }

}

private void saveBuildDefinition(IBuildDefinition definition, ITeamBuildClient buildClient, IProgressMonitor progressMonitor) throws TeamBuildDuplicateItemException, IllegalArgumentException, TeamRepositoryException {
    buildClient.save(definition, progressMonitor);
}

private String getFormattededInteger(int value) {
    if (value >= 0 && value <= 9){
        return "00"+value;
    }
    if (value >= 10 && value <= 99){
        return "0"+value;
    }
    return ""+value;
}

private IBuildDefinition getBuildDefinition(String buildDefinitionName, ITeamBuildClient buildClient, IProgressMonitor progressMonitor) throws IllegalArgumentException, TeamRepositoryException {
    IBuildDefinition buildDefinition = buildClient.getBuildDefinition(buildDefinitionName, progressMonitor );
    IBuildDefinition definition = (IBuildDefinition) buildDefinition.getWorkingCopy();
    return definition;
}

private void setBuildProperty(String propertyName, String propertyValue, IBuildDefinition definition ) throws TeamBuildDuplicateItemException, IllegalArgumentException, TeamRepositoryException {
    definition.setProperty(propertyName,propertyValue);
    System.out.println("set "+propertyName+" to "+ propertyValue+" in Build Definition "+definition.getId() );
}

private void printBuildDefinition(String[] buildDefinitionList, ITeamBuildClient buildClient, IProgressMonitor progressMonitor) throws IllegalArgumentException, TeamRepositoryException {
    for (String buildDefinitionName: buildDefinitionList ){
        IBuildDefinition buildDefinition = buildClient.getBuildDefinition(buildDefinitionName, progressMonitor );
        IBuildDefinition definition = (IBuildDefinition) buildDefinition.getWorkingCopy();
        System.out.println("name = "+buildDefinitionName+" definition = "+definition);
    }
}

}