Hi,
I’m writing a simple UDP listening server. It works great using this
PORT = 1234
server = UDPSocket.open
server.bind(“127.0.0.1”, PORT)
server_thread = Thread.start(server) do |server|
100.times { #do something }
end
server_thread.join
The above was based off some code from the Ruby 1.9 book - I have a
problem
now trying to take it a step further.
How do I get the above to run permanently or until some other condition
besides (100) is reached?
When I run this on my remote server over SSH it works but if I ctrl-z or
exit ssh, the process seems to be in memory but isn’t actually working.
I’d
like to run it and have it go into memory until it is killed and return
me
to the ssh command.
I tried leaving off the server_thread.join but then it just quits. Could
someone explain exactly what Thread.start is doing here.
thanks!
-c
Craig Williams wrote:
end
exit ssh, the process seems to be in memory but isn’t actually working. I’d
like to run it and have it go into memory until it is killed and return me
to the ssh command.
I tried leaving off the server_thread.join but then it just quits. Could
someone explain exactly what Thread.start is doing here.
thanks!
-c
It does exactly what you think it will do. It starts a thread, runs the
block and exits when the block is completed.
If you want it to wait around for things to happen, like something being
fed down a socket, you just need to make a call to an async function,
like IO.read(server) which will wait around until there is something to
read.
I can’t explain why your process is still in memory. To me, it should
have exited and dropped off the face of the planet.
=======================================================================
This email, including any attachments, is only for the intended
addressee. It is subject to copyright, is confidential and may be
the subject of legal or other privilege, none of which is waived or
lost by reason of this transmission.
If the receiver is not the intended addressee, please accept our
apologies, notify us by return, delete all copies and perform no
other act on the email.
Unfortunately, we cannot warrant that the email has not been
altered or corrupted during transmission.
On 15.03.2009 22:35, Craig Williams wrote:
server_thread = Thread.start(server) do |server|
100.times { #do something }
end
server_thread.join
First of all, why are you using a thread here? Do you have other work
that needs to be done concurrently?
The above was based off some code from the Ruby 1.9 book - I have a problem
now trying to take it a step further.
How do I get the above to run permanently or until some other condition
besides (100) is reached?
Depends on the condition. If you want this to run indefinitely you can
simply do
loop do
…
end
When I run this on my remote server over SSH it works but if I ctrl-z or
exit ssh, the process seems to be in memory but isn’t actually working. I’d
like to run it and have it go into memory until it is killed and return me
to the ssh command.
“Go into memory”??? All programs are executed in memory. What you
probably rather need is a demon, i.e. a program that continues to work
even if the terminal gets removed (ssh close).
I tried leaving off the server_thread.join but then it just quits. Could
someone explain exactly what Thread.start is doing here.
In your example above the thread is completely superfluous since you do
not do anything concurrently. A plain old infinite loop would do the
same job. Basically your code is equivalent to
PORT = 1234
server = UDPSocket.open
server.bind(“127.0.0.1”, PORT)
100.times { #do something }
Kind regards
robert
thanks Robert,
A simple loop…do will work and yes, a daemon is what I want to create.
I’ll
look it up and see if I can find some theory around this in Ruby. I
should
have said a TSR right 
Is it good practice in Ruby to sleep when in an infinite loop? or will
Ruby
protect me from that kind of issue?
thanks,
-c
On Sun, Mar 15, 2009 at 6:22 PM, Robert K.
On Mar 15, 2009, at 10:35 PM, Craig Williams wrote:
end
When I run this on my remote server over SSH it works but if I ctrl-
z or
ctrl-z suspends the current job, and moves it to the background
thanks!
-c
See the amazing new SF reel: Invasion of the man eating cucumbers from
outer space.
On congratulations for a fantastic parody, the producer replies :
“What parody?”
Tommy N.
[email protected]
thanks everyone - I found the Daemons wrapper and a simple loop was well
simple 
and it works great.
I also know what ctrl-z does now … learning is fun
-c
Is it good practice in Ruby to sleep when in an infinite loop? or will
Ruby
Dunno why you would sleep a program when you don’t have to o_O
sleeping is most useful when working with Threads, though in some cases
there may be a reason you’d wish to have the program wait for a few
seconds I suppose.