It's all about the answers!

Ask a question
QuestionsTagsUsersBadges
Guidelines | FAQ
Follow this question
Question details

×42,883
×12,009

question asked: Dec 08 '13, 12:32 a.m.
question was seen: 5,001 times
last updated: Dec 14 '13, 11:15 a.m.

Related questions

RTC - Imported CC UCM code into RTC now need to rebase entire stream from Dev to Integration Stream

0
w h (19●18●24) | asked Dec 08 '13, 12:32 a.m.

We have an RTC model like this:  Dev Stream with Admin Workspace.  Int Stream with Admin Workspace.  The Int Stream Admin workspace also has a flow target to the Dev Stream. The model is developers connect to Dev Stream and send changes, at some point the changes are accepted into the Int Stream's Admin Workspace, then flow into the Int Stream. 

We've copied main-latest CC code into the Dev and Int Stream -- the code is not the same and we will need to merge, as the Int Stream also has changes from other streams (Not Dev).  How can we 'rebase' the Dev stream, and send those changes to the Int Stream so it will force a merge and we can address the differences? Since we do not have change sets, will baselining the component in Dev Stream, then accepting that into Int Stream's Admin Workspace, then delivering it to the Int Stream accomplish this?

Thanks

Comments
w h commented Dec 08 '13, 9:51 a.m. | edited Dec 08 '13, 9:52 a.m.

Amending:

When we copied the respective main-latest CC code into the Dev and Int Streams, we created a change set for each - so Dev stream had a change set of say 3700 files, and Int stream had a change set of say 3800 files.  I believe when we change the flow target of our Admin Workspace off the Int stream to point to the Dev stream, it would see that change set of 3700 files and RTC will attempt to auto merge, or let us know of merge conflicts. We will find out soon!

One answer

Most liked answers ↑|Newest answers|Oldest answers

1
permanent link
Geoffrey Clemm (30.1k●3●30●35) | answered Dec 13 '13, 7:15 p.m.
FORUM ADMINISTRATOR / FORUM MODERATOR / JAZZ DEVELOPER
When you say "we copied main-latest code into the Dev and Int Stream", does that mean that you started with an two empty RTC sandboxes, copied the files from ClearCase Dev into one sandbox, copied the files from ClearCase Int into the other sandbox, and then "shared" those sandboxes into RTC?   If so, you have created in Int an evil twins of all of the files and directories in Dev, and an attempt to merge the two will generate a very long list of "evil twin" conflicts. 

What you really want to do is use the ClearCase synchronizer to import the label/baseline that is the common ancestor of both the Dev and Int streams.   Create a snapshot of that configuration, and then create synchronized streams for the Dev and Int streams, using that snapshot as a base (the "create sync stream" wizards prompts you for that snapshot").   Then you will get a reasonable merge when you merge those two streams.
Comments
w h commented Dec 13 '13, 10:26 p.m.

That's what we did. I think we are seeing these "evil twin" conflicts now.  We've already been using the structure for  a week now.


1. Assuming we can't go back and run this ClearCase synchronizer, what are our options? We've had to do a Merge with Proposed when we synced Dev and Int up which sounds like this evil twin conflict.

2. If we can go back, are there some guidelines for this ClearCase synchronizer? 

Thanks

1
Geoffrey Clemm commented Dec 14 '13, 11:15 a.m. | edited Dec 14 '13, 11:15 a.m.
FORUM ADMINISTRATOR / FORUM MODERATOR / JAZZ DEVELOPER

First, have you been doing work in both the imported Dev stream and the imported Int stream, or just the imported Dev stream?  
And if you haven't done so yet, I'd suggest creating a snapshot of the pre-merge configuration of your Dev stream, and similarly, a snapshot of the pre-merge configuration of your Int stream (it is likely that you want to just discard the merge ... "Resolve with Proposed" will just throw away one side of the merge, which is unlikely to be what you want.

As a rough outline, after you have discarded the results of the merge, I'd compare the current state of the Dev stream with the initial state of the Dev stream (i.e. its state when you first imported it), and then compare the current state of the In stream with its initial state (i.e. when you first imported it).  

Assuming the results of the compare look right (i.e. contain all the changes you've made since the import) and the number of changes are not too excessive, then create a "patch" containing all of the change sets from the Dev compare (you can multi-select a set of change sets, and request that a "patch" be created for them), and another "patch" containing all of the change sets from the Int compare.   Then use the CC synchronizer as described in my first comment (there is comprehensive on-line help for setting up and using the CC synchronizer).   Then apply the patches you created above to the Dev and Int streams created by the CC Synchronizer.   And then do a regular RTC merge of the resulting Dev and Int streams.

Your answer

Register or to post your answer.


Dashboards and work items are no longer publicly available, so some links may be invalid. We now provide similar information through other means. Learn more here.