Just a followup on how well this "homegrown synchronization" is
working.
It has been in use for over 6 months and there have been only a few
problems:
1) The client got all new computers and finally upgraded the operating
system. All the issues I had before with a slow startup of the
application (because tem****ary copies of the backend files had to be
created) are now moot.
2) I've actually been able to update the backend files from a
synchronization application located on a PC that is over 1200 miles
away from the server backend files. This typically takes 35 to 45
minutes as opposed to 2 minutes when doing the synchronization at the
location where the server is. However, this is not generally
recommended since a dropped line will corrupt the back-end files.
3) One instance of corruption occurred while synchronizing the server
back-end file with an update file. This occurred from a location about
20 miles from the server (typically takes 10 to 15 minutes to
synchronize). However, since the synchronization process always
creates a backup copy of the server backends, it was relatively easy
to fix this problem.
One issue I didn't consider: If a user is logged into the backend
files located on the server and not their local PC and they make
changes to data on the server backend files, how are zipped copies of
the backend files generated (which files are then sent out to all
users when they log in to MyApp and is used to replace the LOCAL copy
of the back-end files). In other words, is there a reliable way to
tell when the server back-end files have been updated? If so, I could
then just create a text file and store it in the server folder. As
part of the timer function in the SyncApp, if this text file is found,
code would be executed to create zipped copies of the server back-end
files which would then be sent to the users when they log in.
It's im****tant to note that I previously chose to send zipped copies
of the entire back-end files, not just incremental changes. If there
is a reliable way to determine if the server back-end files have been
updated, then it would be relatively easy to just invoke the code that
creates these zipped back-end files and puts them in the Server
Outbox.
Would checking to see if there is a difference in the "Date Modified"
of the server back-end files provide a reliable way to check if the
server backend files have been changed. If so the process might be as
follows"
MyApp would record the "Date Modified" of the server back-end files
when a user first logs on. Then when MyApp is closed, the "Date
Modified" is checked again. If different, then changes were made (is
this true??). If changes are made, the code generates a text file and
puts in the Server Inbox. The SyncApp is monitoring the Server
Inbox. If it finds the text file, the code will then create zipped
copies of the backend files and put them in the Server Outbox. This
whole process is exactly what the SyncApp currently does anyway,
except that an update file from a user's local PC backends is not
applied to the server back-end files.
So the question I have is, how does one reliably determine when a back-
end file has been updated (assuming that there is no code in MyApp
that does this).
|
