This sounds very much like a manual process requiring human intervention. Am I correct? Or can I use the build process to perform these tasks automatically?

Hi Geoffrey,

Thanks, I understand the loss of SCM control over the files and am
advising against it. I have also pointed out to the customer 3.0
will offer several benefits we are eager to leverage - cross
repository changesets, policies on rebaselining and possibly,
although I am not optimistic, the abiliity to use read/write
permissions on directories/files within a component.

All that being said, assume the customer doesn't care about the items
remaining under source control through-out the entire process.
Further assume there is no common connectivity across the board. To
top it off, assume this is a 1.0.1.1 environment today and for the
foreseeable future.

There is code in RTC SCM. At times, this code will be exported and
thrown "over the fence" onto a ftp server. Various
individuals, none with access to the RTC server, will retrieve those
files, although none would be working on same file. The files are
modified on their local workstations (where they may or may not use
some source control system of their own) and then placed back on the
ftp server. They then want to import those files back into RTC SCM.

In other words, the customer is looking for us to provide a bridge
between RTC and "any" external development using the RTC
build engine to do exports and imports of the source code.

Is it doable? Can it be automated using the build system to execute
SCM command line scripts to do the export and import?

After those questions are answered, of course, the question becomes is
it advisable and more importantly, is there an alternative solution
which would be better? The big issue is the customer doesn't want to
add thousands of potential users to the project and maintain those ids
nor can they require these "external" developers to use RTC
for source control.

I look forward to your reply. Thank you.

Developing a solution for a customer which involves a few hoops.
Assume a basic SCM scenario with one component and the mainline
stream. A group of users would be in RTC and use it as normally. A
second group of external users would have no access to RTC or would
have a different implementation of RTC with no connections between
the two.

As the internal team worked on code, they would deliver and generate
baselines as normal. When a bug was found, the bug and latest
baseline would need to be distributed to the external team to be
resolved.

Our assumption at this point would be to utilize the build engine (no
actual compiling) to place the latest baseline code out on a file
server where external users could retrieve it. They would modify the
code and upon completion update the file server with the new files. I
would assume we could then run a build which would retrieve the files
and execute a command to import these files back into RTC.

There are a number of issues I am concerned with using such an
approach - the first being is it technically feasible and efficient?
Add to that the possibility for simultaneous development both
internally and externally, files being modified both under SCM and
outside of SCM, the concern that external users are modifying the
correct code base, and how we manage to track the various changes
within RTC without losing version history and I begin to question my
long-term sanity.

Is anyone doing anything like this? What is Rationals standard
approach to managing source code in RTC when part of the team has no
access to SCM? What else can go wrong in the above scenario? What
can go right? Is there an alternative approach I am missing? Would
ClearCase be a better solution given the scenario?