unknown wrote:
On Fri, 14 Jul 2006, Rogue Amateur wrote:
[snip]
can all of your code run as in
./my_code.rb
??
yes. running ./my_code.rb is how I normally start the software. when
run without daemonizing of any sort, this software runs properly and to
completion. there are 2 modes: interactive and service mode. I’m
trying to make the service mode run as a daemon.
Here is the code that I’m trying to process, severely cut down because
of proprietary issues.
I can’t get anything past the daemonize statement to run.
The same seems to be true with the daemon.rb code, in that it will
output only one set of envirnment data (vs the 2 that the print
statements are set up for…)
I understand that these things are 2 different actions. One does steps,
then deamonizes. the other daemonizes the whole bloody process. both
are behaving the same way, and seem to die at the same place (only 1 set
of environment output). If I could post the whole thing, I would. I
cannot.
#!/usr/bin/ruby
FileName: StrmSrvInteract.rb
Date: 2006/05/10
require(‘SimStream’)
require(‘daemonize’)
require(‘socket’)
require(‘syslog’)
include Daemonize
check if command line options. If so, use those and “run once”
else, create listener socket thread, process on loop until
listener socket send “stop”
$mode = nil # assume service mode
$mode = 1 if ARGV.length > 0
$rtr_ip = ‘127.0.0.1’
$rtr_usr = ‘george’
$OutPort = 6001 # output port for sockets
$InPort = 6000 # input port for sockets
$host = ‘localhost’
$debug = nil
$sim = nil
use syslog to properly add log messages to the log
$log = Syslog.open(“my_code”)
$log.debug(“Running my_code.”)
use alt_log to hold debug comments if any
alt_log = “#{Dir.pwd}/my_codeDebug.log”
simple_socket = "Usage: via localhost:16000, send message as " +
“\t[actionCode]\0[inputValue(s)…]\0\n” +
“Return messages to localhost:16001”
simple_usage = “Usage: #{$0} [d[:[+]sim]] [v|h|c:cmd] [s:MCA]
[p:port]\n” +
“\tUse #{$0} v to get version\nUse #{$0} h to get extended
help.”
FunctionName: process_request
proprietary code I can’t release. It never gets a chance to execute
this anyway.
FunctionName: main
begin
parse the arguments, if any, and see if in sim mode.
my_args = Hash.new
ARGV.each do |arg|
if arg =~ /
(key, value) = arg.split(":")
my_args[key] = value
else
my_args[arg] = “”
end
end
allow for ip as an input parameter no matter what the mode.
if my_args.keys.length == 1 and my_args.has_key?(“ip”)
File.open(alt_log,“a+”) { |f| f << “New IP for Router:
#{my_args[“ip”]}”} # if $debug
$rtr_ip = my_args[“ip”]
$mode = nil
elsif my_args.has_key?(“ip”)
File.open(alt_log,“a+”) { |f| f << “New IP for Router:
#{my_args[“ip”]}”} # if $debug
$rtr_ip = my_args[“ip”]
end
for debug to force in socket mode
$sim = 1
$debug = 1
log the environment, I hope…
show_env = “\n”
ENV.each_pair { |k,v| show_env += “\t#{k}: #{v}\n” }
environment = “Dir: #{Dir.pwd}\nEff UID: #{Process.euid}\n” +
“Eff GID: #{Process.egid}\nENV: #{show_env}\n”
File.open("#{Dir.pwd}/Environment.log",“a+”) { |f| f << environment }
otherwise, daemonize and move on.
daemonize()
#####IT NEVER DOES THIS STEP. AT ALL.
log the environment, I hope…
show_env = “\n”
ENV.each_pair { |k,v| show_env += “\t#{k}: #{v}\n” }
environment = “Dir: #{Dir.pwd}\nEff UID: #{Process.euid}\n” +
“Eff GID: #{Process.egid}\nENV: #{show_env}\n”
File.open("/home/RA/Environment.log",“a+”) { |f| f << environment }
File.open(alt_log,“a+”) { |f| f << “Debug mode on.” } if $debug
File.open(alt_log,“a+”) { |f| f << “Sim mode on.” } if $debug and $sim
File.open(alt_log,“a+”) { |f| f << “Socket processing.” } if $debug
puts "Debug mode on." if $debug
puts “Sim mode on.” if $debug and $sim
puts “Socket processing.” if $debug
open the router and get stream objects
puts “Opening router <#{Time.now}>…” if $debug
if $sim
$my_rtr = SimRouter.new($rtr_ip, $rtr_usr) # for form sake
$high_Def = SimStream.new($my_rtr.open, “highdef”)
$low_Def = SimStream.new($my_rtr.shell, “lowdef”)
else
begin
$my_rtr = Router.new($rtr_ip, $rtr_usr)
my_shell = $my_rtr.open
rescue
msg = “Could not open the real router. Error: <#{$!}>\n”
msg += “Pls verify router settings: RouterIP: #{$rtr_ip} User:
#{$rtr_usr}\n”
puts(msg)
$log.err(msg)
UDPSocket.open.send(“510\000Stop\0001\000”, 0, $host, $OutPort)
exit 1
end
begin
$high_Def = Stream.new(my_shell, “highdef”)
rescue
msg = “could not determine HighDef contents. Message returned was:
<#{$!}>\n”
msg += “Pls verify router settings: RouterIP: #{$rtr_ip} User:
#{$rtr_usr}\n”
$log.err(msg)
$my_rtr.close
UDPSocket.open.send(“510\000Stop\0001\000”, 0, $host, $OutPort)
exit 1
end
begin
$low_Def = Stream.new(my_shell, “lowdef”)
rescue
msg = “could not determine LowDef contents. Message returned was:
<#{$!}>\n”
msg += “Pls verify router settings: RouterIP: #{$rtr_ip} User:
#{$rtr_usr}\n”
$log.err(msg)
$my_rtr.close
UDPSocket.open.send(“510\000Stop\0001\000”, 0, $host, $OutPort)
exit 1
end
end
puts “done opening router <#{Time.now}>” if $debug
assume socket-based service
server = UDPSocket.open
server.bind(nil, $InPort)
stop_stat = 1
last_word = “”
do this just once, to let gvpmanager know you’re up.
UDPSocket.open.send(“520\0”, 0, $host, $OutPort) if !$mode
while stop_stat
my_reply, my_from = server.recvfrom(64)
if my_reply =~ /^510/
# stop if told to stop
stop_stat = nil
last_word = my_reply
puts “Told to stop <#{Time.now}>…” if $debug
elsif my_reply =~ /^505/
the rest of the acting code has been deleted to protect the guilty.
Please understand that it never does the above noted steps.
# process_request
# output to socket
end
do the last clean up pieces for the socket based mode.
File.open(alt_log,“a+”) { |f| f << last_word } if !$mode and $debug
UDPSocket.open.send("#{last_word}0\0", 0, $host, $OutPort) if !$mode
msg = “Socket Service stopped. Please see system log for any error
messages.”
puts msg if !$mode
rescue RuntimeError, StandardError => boom
msg = “Runtime processing error. Software threw an error <#{boom}>.”
$log.err(msg)
puts (msg) if $mode
if defined? $my_rtr and !$my_rtr.nil?
$my_rtr.close
end
UDPSocket.open.send(“510\000Stop\0001\000”, 0, $host, $OutPort) if
!$mode
exit 1
rescue Exception => e
require ‘tmpdir’
tmp = Dir.tmpdir
this = File.basename $0
pid = Process.pid
deathlog = File.join tmp, "#{ this }.#{ pid }"
m, c, b = e.message, e.class, e.backtrace.join("\n")
msg = "%s (%s)\n%s" % [m, c, b]
open(deathlog, "w"){|f| f.puts msg}
end
that being said this will accomplish what
