One approach is to associate one of your rel-stream workspaces with both
the rel-stream and with the bugfix-stream. You would accept changes
from both of these streams, but you would deliver only to the rel-stream.

I have requested additional GUI support for this use case in workitem
33114. If you think this would make your development easier, please
register your support for that workitem (there is not currently a
"voting" system in place for workitems, so just adding a comment
indicating your support would be fine).

Cheers,
Geoff

sunil.k.kuuram wrote:

Hello,

We were brainstorming on how to carry out bugfixes in parallel with
ongoing enhancements. The bugfix stream needs to deliver to the
ongoing rel stream, but that would accumulate the bugfix workspace
with enhancements from ongoing rel stream (since outgoing changes
cannot be delivered without accepting incoming). That would make it
difficult to go forward with further bugfixes as the stream has
untested work from ongoing release stream.

What is the best approach to port changes from one stream to the other
while preserving the source stream/workspace's configuration?

Any suggestions highly appreciated.

Thanks
Sunil

Hi Sunil,

You have the right idea. Your repository workspace is usually closely related to one stream or the other, but when it comes to flowing change sets between streams, you can think of the repository workspace as sitting in the middle. It can take as much or as little from one stream, and even add some new stuff, and then delivers the change sets back to the other.


First take a look at Section 2.4 in https://jazz.net/learn/LearnItem.jsp?href=content/docs/source-control/streamdev/index.html. It has an example of backporting a bugfix from a rel stream to a maintenece stream, but the same principals can be applied in the other direction.

It sounds like to me you want your rel stream to be a superset of your maintenece stream. To simplify here are some steps that should do what you want.

1. From a repository workspace that's normally collaborating with the bugfix stream, you write a change set that fixes your bugfix stream and you deliver it there. Everything is good. Now you want to also deliver this patch to the rel stream as well.

2. Create a workspace off of your rel stream, then change the flow target to your bugfix stream. Accept the change set that you had just delivered to the bugfix stream into your workspace.

2a. Assuming that you've always been doing it this way since day one, you should not have 'gap' problems since the rel-stream will always have all the change sets that are also in bugfix stream.

2a-continued. You may notice that the change set you wrote for the bug fix stream needs to be merged with the enhancements in the rel stream in order to apply correctly. Go ahead and write additional code in a new change set to do the merge. Deliver the original change set and the merge to your rel stream. Voila, the rel stream contains the bug fix change set and you have not contaminated your bugfix stream.

2b (alternative to 2a), like the example in the streamdev tutorial, you may not want to accept the exact change set, but just its contents in a patch. In this case, you copy its contents into a new change set (and write any additional code that would be the merge as well). And deliver this to the rel stream. Notice that in this case, the rel stream does not contain the same change set as in the bugfix stream.


Going back to what I said at the very beginning, you don't actually need to create a new workspace in step 2 since your repository workspace sits between the streams.

1. You made your change set to fix a bug and delivered it to your bugfix stream.

2. Change flow target to the rel stream. Accept everything, and merge if you need to. Deliver the change set and the merge to the rel stream.

3. Change your flow target back to the bugfix stream... but you don't need to deliver the enhancements back here! Instead, replace the components in your repository workspace with the latest from the bugfix stream. That puts your repository workspace back into sync with the bugfix stream.