Very Computer

I have a couple of large Solaris 7/8 boxen onto which very large files
are written daily.  I've been charged with the task of moving these files
as theyre finished being written to a number of other boxes, running NT,
VMS and Solaris. Moving them isnt the problem, ill probably end up using
scp or rsync.

The problem is that part of the charge is that they are to be moved one at a
time, as they're finished being written. Since they arent being appended
by the application thats writing them (an in-house blob of perl, csh and
python nastiness over which I have zero control) when they're done, I'm
having trouble figuring out the best way to note their finished-ness before
moving them.  I was considering using gnufind's -mmin flag for a fairly
decent amount of granularity in this case, but I'd rather not use something
thats in any way resource intensive if I can at all avoid it.

I'm pretty good with shellscripts (sh,ksh,bash), not very good with perl,
absolutely terrible with C(++), and unfortunately the options for
implementation on these Solaris machines ends right there.

Has anyone else ever come across a similar problem?  Is there some kind of
function or utility under Solaris that I'm missing?

Thanks in advance,

abbie

Scott

There are a few ways that you can do this.

First, take a look at the process that is writing the files, is there a
way to
make it to the work for you, ie have it tell you when it is done. If so,
you
can then just check for each files completion based on the process.
        If that isn't possible, observe the writing process to see how it
behaves while it works, it may be as simple as checking the modifcation
times
on the file and when it comes up twice at the same time, it is ok to
start the
copy.
        You will be able to use a shell script or perl to accomplish the tasks
easily.
        Since you didn't include all of the information to help more completly
I hope that this helps you along to a solution

        Alan

Quote:> Well, its interesting to me at least...

> I have a couple of large Solaris 7/8 boxen onto which very large files
> are written daily.  I've been charged with the task of moving these files
> as theyre finished being written to a number of other boxes, running NT,
> VMS and Solaris. Moving them isnt the problem, ill probably end up using
> scp or rsync.

> The problem is that part of the charge is that they are to be moved one at a
> time, as they're finished being written. Since they arent being appended
> by the application thats writing them (an in-house blob of perl, csh and
> python nastiness over which I have zero control) when they're done, I'm
> having trouble figuring out the best way to note their finished-ness before
> moving them.  I was considering using gnufind's -mmin flag for a fairly
> decent amount of granularity in this case, but I'd rather not use something
> thats in any way resource intensive if I can at all avoid it.

> I'm pretty good with shellscripts (sh,ksh,bash), not very good with perl,
> absolutely terrible with C(++), and unfortunately the options for
> implementation on these Solaris machines ends right there.

> Has anyone else ever come across a similar problem?  Is there some kind of
> function or utility under Solaris that I'm missing?

> Thanks in advance,

> abbie

Sr. UNIX Administrator / MIS
Advanced Fibre Communications

However, if the program always

Opens a new file for writing,
Writes to it a while.
Closes the file forever

Then you could use 'fuser' or 'lsof' to see which files are no longer
open and move them.

If the program can do something between those two extremes, then you're
going to have to find out about it.

--

Unix System Administrator                    Taos - The SysAdmin Company
Got some Dr Pepper?                           San Francisco, CA bay area
         < This line left intentionally blank to confuse you. >

--
Rich Teer

President,
Rite Online Inc.

Voice: +1 (250) 979-1638
URL: http://www.rite-online.net

Quote:> Well, its interesting to me at least...

> I have a couple of large Solaris 7/8 boxen onto which very large files
> are written daily.  I've been charged with the task of moving these files
> as theyre finished being written to a number of other boxes, running NT,
> VMS and Solaris. Moving them isnt the problem, ill probably end up using
> scp or rsync.

> The problem is that part of the charge is that they are to be moved one
> at a time, as they're finished being written. Since they arent being
> appended by the application thats writing them (an in-house blob of perl,
> csh and python nastiness over which I have zero control) when they're
> done, I'm having trouble figuring out the best way to note their
> finished-ness before moving them.  I was considering using gnufind's
> -mmin flag for a fairly decent amount of granularity in this case, but
> I'd rather not use something thats in any way resource intensive if I can
> at all avoid it.

> I'm pretty good with shellscripts (sh,ksh,bash), not very good with perl,
> absolutely terrible with C(++), and unfortunately the options for
> implementation on these Solaris machines ends right there.

> Has anyone else ever come across a similar problem?  Is there some kind
> of function or utility under Solaris that I'm missing?

> Thanks in advance,

These are basic text files, right?

--
-- Rob Prowel (A.K.A. da wiseguy)
URL:  http://www.prowel.com/