• either use the RTC SCM configuration and get the information in Jenkins and RTC updated, independent on where you start the build,
• OR use other SCMs and only have information on both sides when you start the build from RTC, but not when starting from Jenkins

What I did is probably not the nicest thing ever, but it works to have the build status information on both sides, independent from where you start the build. I wrote an Ant script to update RTC. The script is executed after the actual build is finished to get the correct status.

I actually used a 2nd Jenkins job to do this because I did not figure out how to run an ant task as post-build-step, but I am sure it could also be done in this way

All it does is collect the status information and if the build was not triggered from RTC it posts the status and a link to Jenkins to RTC

So here we go:

1. Create an RTC build engine and definition (in the RTC configuration in Eclipse, see IBM help)
   
   
2. Install the RTC build toolkit on the Jenkins machine
   
3. Install Ant on the Jenkins machine
4. Store the content at the end of the post to a file on the Jenkins machine, e.g. to build.xml
5. Create a passwordFile according to this description: https://jazz.net/help-dev/clm/index.jsp?re=1&topic=/com.ibm.team.build.doc/topics/tcreatepasstxt.html&scope=null
   
   
6. Create a new Jenkins job without SCM
7. Add an Ant build step with the following settings:
   Set the "Ant build file" path to the file just created (build.xml)
   Set the "Target" to
   

   -lib C:\IBM\TeamConcertBuild\buildsystem\buildtoolkit
   all

8. Add a post-build step "Trigger parameterized build on other projects" to the job that is actually connected to RTC.
   Set the project to build on the job name of the previously created job
   Set "Trigger when build is" to "Complete" to always run the job
   Add "Predefined parameters" and set to the following to hand over the parameters to the other job
   
   

   		rtcRepositoryAddress=https://<your_RTC_server>/ccm
   		rtcBuildDefinitionId=<build definition name>
   		rtcBuildEngineId=<build engine name>
   		jenkinsJobBuildURL=${BUILD_URL}
   		jenkinsJobDisplayName=${BUILD_DISPLAY_NAME}
   		buildResultUUID=${buildResultUUID}
   		

<project name="postResultsToRTC">
    <description>
        Ant script to post Jenkins build results to IBM CLM

        Parameters to be set for the Ant call
        -lib C:\IBM\TeamConcertBuild\buildsystem\buildtoolkit
        all

        Further parameters to be set (in Jenkins or via -Dxxx in the Ant call)
            rtcRepositoryAddress
            rtcBuildDefinitionId
            rtcBuildEngineId
            jenkinsJobBuildURL - build URL of job to report to ALM
            jenkinsJobDisplayName - displayed name in ALM
            buildResultUUID - buildResultUUID (set in original job)
    </description>

    <import file="C:\IBM\TeamConcertBuild\buildsystem\buildtoolkit\BuildToolkitTaskDefs.xml" /> 

    <!-- set global properties for this build -->
    <property name="userId" value="TODO: Add user name" />
    <property name="thisBuildState" value="nothing" />

    <property environment="env"/>
    <!-- passwordFile is created according to following information: 
    https://jazz.net/help-dev/clm/index.jsp?re=1&topic=/com.ibm.team.build.doc/topics/tcreatepasstxt.html&scope=null -->
    <property name="passwordFile" value="${env.JENKINS_HOME}\${userId}-password" />
    <property name="tempFile" value="c:\temp\tempBuildState_${env.BUILD_ID}.json" />            

    <echo message="buildResultUUID: ${buildResultUUID}"/>

    <!-- if buildResultUUID was already set, the build was started by IBM RTC (not by Jenkins) 
    and no information needs to be posted to RTC as this is done automatically -->
    <condition property="runScript">
            <length string="${buildResultUUID}" trim="true" length="0" />
    </condition>

    <!-- 
    <echo if="${runScript}" message="Build was started from Jenkins, information is posted to IBM RTC"/>
    <echo unless="${runScript}" message="Build was started from IBM RTC, no actions are performed. No information needs to be posted to RTC as this is done automatically"/>
    -->

    <target name="all" if="${runScript}" >
        <echo message="Transferring build results of previous build to IBM CLM"/>
        <echo message="Please note that this is a temporary solution and has several restrictions. Only a link to Jenkins will be published."/>
        <echo message="Transferring data of the following job: ${jenkinsJobBuildURL}"/>
        <echo message="...to the following RTC server:"/>
        <echo message="RTC server address:   ${rtcRepositoryAddress}"/>
        <echo message="RTC build engine:     ${rtcBuildEngineId}"/>
        <echo message="RTC build definition: ${rtcBuildDefinitionId}"/>

        <!-- Tell RTC that a build has started and get the buildResultUUID -->
        <startTeamBuild buildDefinitionId="${rtcBuildDefinitionId}"
            engineId="${rtcBuildEngineId}"
            label="${jenkinsJobDisplayName}"
            autoComplete="false"
            resultUUIDProperty="newBuildResultUUID"
            repositoryAddress="${rtcRepositoryAddress}"
            userId="${userId}"
            passwordFile="${passwordFile}"/>

        <!-- publish a link in RTC to the build in Jenkins -->
        <linkPublisher buildResultUUID="${newBuildResultUUID}"
            verbose="true"
            label="${jenkinsJobDisplayName}"
            url="${jenkinsJobBuildURL}"
            repositoryAddress="${rtcRepositoryAddress}"
            userId="${userId}"
            passwordFile="${passwordFile}" />

        <!-- Get Jenkins status of current build. Use API Token for access 
             (in Jenkins click on your name in the top right corner and go to settings) -->
        <get src="${jenkinsJobBuildURL}api/json" 
            dest="${tempFile}" 
            username="${userId}"
            password="<TODO: Add the users Jenkins API Token, not the password itself>"    />

        <script language="javascript">
        <![CDATA[

            load('nashorn:mozilla_compat.js')

            importClass(java.io.File);
            importClass(java.io.FileReader);
            importClass(java.io.BufferedReader);
            importClass(java.io.FileWriter);
            importClass(java.io.BufferedWriter);

            var file = new File(postResultsToRTC.getProperty("tempFile"));
            fr = new FileReader(file);
            br = new BufferedReader(fr);

            // Read the file. 
            // This assumes the file has no line breaks and is one line.

            var json = br.readLine();

            // Evaluate the JSON.
            var struct = eval("(" + json + ")");

            // Set each property in the project environment.
            echo = postResultsToRTC.createTask("echo");
            echo.setMessage(struct["result"]);
            echo.perform();

            // Map state as:
            // - Jenkins status can be SUCCESS or FAILURE
            // - IBM RTC status may be OK, ERROR or WARNING.
            if (struct["result"] === "SUCCESS") {
                postResultsToRTC.setProperty("thisBuildState","OK");
            }
            else {
                postResultsToRTC.setProperty("thisBuildState","ERROR");
            }
        ]]>
        </script>

        <!-- tell RTC that the build has finished -->
        <completeTeamBuild status="${thisBuildState}"
            buildResultUUID="${newBuildResultUUID}"
            repositoryAddress="${rtcRepositoryAddress}"
            userId="${userId}"
            passwordFile="${passwordFile}"
            verbose="true" />

        <!-- remove temporary file -->
        <delete file="${tempFile}"
            quiet="true"/>
    </target>  
</project>