__del__ pattern?

[Chris Curvey]

I need to ensure that there is only one instance of my python class on
my machine at a given time. (Not within an interpreter -- that would
just be a singleton -- but on the machine.) These instances are
created and destroyed, but there can be only one at a time.

So when my class is instantiated, I create a little lock file, and I
have a __del__ method that deletes the lock file. Unfortunately, there
seem to be some circumstances where my lock file is not getting
deleted. Then all the jobs that need that "special" class start
queueing up requests, and I get phone calls in the middle of the night.

Is there a better pattern to follow than using a __del__ method? I
just need to be absolutely, positively sure of two things:

1) There is only one instance of my special class on the machine at a
time.
2) If my special class is destroyed for any reason, I need to be able
to create another instance of the class.

[Michael Hudson]

br************* **********@yaho o.com writes:

Chris Curvey wrote:

I need to ensure that there is only one instance of my python class on
my machine at a given time. (Not within an interpreter -- that would
just be a singleton -- but on the machine.) These instances are
created and destroyed, but there can be only one at a time.

So when my class is instantiated, I create a little lock file, and I
have a __del__ method that deletes the lock file. Unfortunately, there
seem to be some circumstances where my lock file is not getting
deleted. Then all the jobs that need that "special" class start
queueing up requests, and I get phone calls in the middle of the night.

For a reasonably portable solution, leave the lock file open.
On most systems, you cannot delete an open file,

Uh, you can on unix -- what else did you have in mind for "most
systems"?

Cheers,
mwh

--
Well, yes. I don't think I'd put something like "penchant for anal
play" and "able to wield a buttplug" in a CV unless it was relevant
to the gig being applied for... -- Matt McLeod, asr

[Leonhard Vogt]

> So when my class is instantiated, I create a little lock file, and I

have a __del__ method that deletes the lock file. Is there a better pattern to follow than using a __del__ method? I
just need to be absolutely, positively sure of two things:

1) There is only one instance of my special class on the machine at a
time.
2) If my special class is destroyed for any reason, I need to be able
to create another instance of the class.

Just some ideas

1) You could open a socket listening to a port
* Not sure what happens if the interpreter dies
* There cold be conflicts with other programs

2) Update the lockfile every xxx. If the lockfile
is older than e.g. 2*xxx disregard it.

3) Write the process id into the lockfile and check
if a process with this id is alive.
* I don't know if / how this can be done in python

Leonhard

[Bryan Olson]

BranoZ wrote:

br************* **********@yaho o.com wrote:

For a reasonably portable solution, leave the lock file open.
On most systems, you cannot delete an open file,..
On most UNIXes, you can delete an open file.
Even flock-ed. This is BTW also an hack around flock.

Yes, sorry; my bad.
Use file that is writeable by A and B in a directory that is
writeable only by root.

Is that portable? What's the sequence the program should try?
--
--Bryan

[BranoZ]

Bryan Olson wrote:

> Use file that is writeable by A and B in a directory that is
> writeable only by root.
Is that portable?

I have the feeling that you are asking if it works on Windows.
No idea! I have only user experience with Windows.

On UNIX it is as portable as 'flock', which means all modern
Unices (be careful about NFS).
What's the sequence the program should try?

1.
open a file, which name was previously agreed on
(like /var/tmp/<prog-name>-<user-name>)

If it fails, report error and exit. System error or
somebody has created unaccessible file by the same name.

2.
Try to aquire a flock on the descriptor from step 1.

If it fails, some running process already has the lock, exit

3.
lock will be released and lockfile closed automaticaly by OS
on process exit.

import sys, fcntl

try:
lockfile=open('/var/tmp/test1', 'w')
fcntl.flock(loc kfile.fileno(),
fcntl.LOCK_EX | fcntl.LOCK_NB)
except IOError:
print sys.exc_info()[1]
sys.exit(-1)

You can flock any open file, no matter if it is read/write/append.

BranoZ

[Jorgen Grahn]

On Tue, 16 Aug 2005 08:03:58 -0400, Peter Hansen <pe***@engcorp. com> wrote:

Tom Anderson wrote:

On Mon, 15 Aug 2005, Peter Hansen wrote:

Using '' instead of 'localhost' means bind to *all* interfaces, not
just the loopback one.

Doesn't '' mean 'bind to the *default* interface'?

What does "default" mean, and is that definition in conflict with what I
said?

The docs say it means INADDR_ANY. They don't say what that means, so
you'd have to read up on the C socket calls to learn more.

Or some helpful soul will clarify for the class... :-)

INADDR_ANY means "every network interface you can find". This includes the
local loopback and all physical and logical network interfaces.

/Jorgen

--
// Jorgen Grahn <jgrahn@ Ph'nglui mglw'nafh Cthulhu
\X/ algonet.se> R'lyeh wgah'nagl fhtagn!