Versioning Results

Question

We need to regularly synchronize dozens of binaries (project executables and DLLs) between many developers in several different places so that each developer has a modern environment for building and testing. Due to the nature of the project, updates should be performed frequently and on demand (nightly updates are not enough). This is not very, but we got stuck with him for a while.

We settled on using the regular version (source code) management system: put everything in it as binary files, get the latest version before testing and updating the updated DLL after testing.

It works great, but the version control client has many features that don't make sense to us, and people get confused sometimes.

Are there any tools more suitable for the task? Or maybe a completely different approach?

Update:

I need to clarify that this is not a tightly integrated project - it looks more like an extensible system with a bunch of "plug-ins", including third-party ones. We need to make sure that these plugin modules work perfectly with the latest versions of each other and the kernel. Central construction was initially considered as suggested, but this is not an option.

Answer 1

I would probably look at rsync.

Just create a .CMD file containing an rsync call with all the correct parameters and let people call it. rsync is very smart when deciding which part of the files to transfer, so it will be very fast, even if large files are involved.

What rsync does not do is conflict resolution (or even detection), but in the scenario you described it is more like reading from the central location rsync is intended for.

Answer 2

Another option is unison

Answer 3

You should look into continuous integration and have some kind of centralized build process. I can only imagine what kind of hell you are going through with your current approach.

Obviously, this does not help synchronize your local files, but I think you have more problems with your process.

Answer 4

Building a project should be a centralized process to provide better control in the near future. Anyway, this is what I do.

• Create regular repositories for source files, resources, documentation, etc. for each project.
• Create a resource repository. There will be the latest binary versions for each project, as well as any necessary resources, files, etc. Keep a good folder structure for each project so that developers can “link” to files directly.
• Create a repository for final buidls that will keep the actual stable release. This will ensure stability of files executed automatically (if possible) from verified sources. This will be a product, a real version for integration testing, etc.

Until you are perfect, you can identify well established protocols. Check your latest dll here, create a “real” version from the latest source here.

Answer 5

How about embedding the string "what" in executables and libraries. Then you can synchronize the desired version list with the manifest.

We try to use CVS id strings as part of the string.

const char cvsid[] = "@(#)INETOPS_filter_ip_$Revision: 1.9 $";

Command input

what filter_ip | grep INETOPS

returns

INETOPS_filter_ip_$Revision: 1.9 $

We do this for all the results, so that we can see if the versions in the set of libraries and executables match the list in the associated manifest.

NTN.

amuses

Rob

Answer 6

Subversion works great with binary files, is pretty fast and scriptable. VisualSVN and TortoiseSVN dealing with Subversion is easy.

You can configure the folder that was extracted from Subversion with all your binaries (which all developers can click and update), and then just type "svn update" at the command line or use TortoiseSVN: right-click on the folder, click " Update SVN "and it will update all files and let you know what has changed.