def reporting(self):
try:
while 1:
time.sleep(.5)
self.seconds_since_last_poll += .5
if self.seconds_since_last_poll < self.poll_interval and not self.exited:
continue
self.seconds_since_last_poll = 0
try:
rpc_connection = CONNECT.sim_client()
#rpc_connection=DUMMY_RPC()
except:
print "Failed to get rpc_connection for reporting"
pass
else:
events = self.simulation_event_queue.Consume_All()
for event_function, event_data in events:
#print "events func=%s data=%s"%(repr(event_function),repr(event_data))
try:
ret = event_function(self.pid, rpc_connection,
self.session, event_data)
#print "ret=%s"%ret
except EXIT_REPORTING_EXCEPTION:
raise EXIT_REPORTING_EXCEPTION
except:
pass
for poll_function in self.polled_events:
#try:
poll_function(self.pid, rpc_connection, self.session)
#except: pass
except EXIT_REPORTING_EXCEPTION:
pass
def run(self):
# set up signal handling
signal.signal(signal.SIGTERM, self.kill)
signal.signal(signal.SIGINT, self.kill)
# make the reporting thread
self.reporting_thread = threading.Thread()
self.reporting_thread.run = self.reporting
self.reporting_thread.start()
# launch the process and capture the pid
pipe = popen2.Popen4(self.cmd)
self.input, self.pid = pipe.fromchild, pipe.pid
# report that we have started the program
rpc_connection = None
try:
rpc_connection = CONNECT.mon_client()
self.report_start(self.pid, rpc_connection, self.session)
except:
print "MON_WRAPPER_ENGINE: Failed to report start"
rpc_connection.close()
else:
rpc_connection.close()
# parse and pipe input
while 1:
line = ""
try:
line = self.input.readline()
except IOError:
continue
if line == "": break # cmd died, break to find out why
print line,
sys.stdout.flush()
line = line.strip()
for regexp, match_func, act_func in self.simulation_events:
match = regexp.match(line)
try:
event_data = match_func(match)
except:
pass
else:
self.simulation_event_queue.Produce((act_func, event_data))
# end of process detect exit code
exit_code = pipe.wait()
print "\ngot exit code %d - should exit in at most a couple of seconds" % exit_code
self.simulation_event_queue.Produce(
(self.report_exit, (exit_code, time.time())))
self.reporting_thread.join()
def reporting(self):
try:
while 1:
time.sleep(.5)
self.seconds_since_last_poll += .5
if self.seconds_since_last_poll < self.poll_interval and not self.exited:
continue
self.seconds_since_last_poll = 0
print "MON ------ Polling ----------------"
try:
if not self.rpc_connection_active:
print "MON ------- Connection inactive reconnecting ---------"
self.rpc_connection = CONNECT.mon_client(10)
self.rpc_connection_active = 1
#rpc_connection=DUMMY_RPC()
except:
print "MON ------ Failed to get rpc_connection for reporting --------"
traceback.print_exc()
self.rpc_connection.close()
self.rpc_connection = None
self.rpc_connection_active = 0
time.sleep(10)
pass
else:
events = self.simulation_event_queue.Consume_All()
for event_function, event_data in events:
#print "events func=%s data=%s"%(repr(event_function),repr(event_data))
try:
ret = event_function(self.pid, self.rpc_connection,
self.session, event_data)
#print "ret=%s"%ret
except EXIT_REPORTING_EXCEPTION:
raise EXIT_REPORTING_EXCEPTION
except:
print "MON ------ Error doing reporting event -------"
traceback.print_exc()
self.rpc_connection = None
self.rpc_connection_active = 0
continue
for poll_function in self.polled_events:
try:
poll_function(self.pid, self.rpc_connection,
self.session)
except:
print "MON ------ Error doing poll function ------"
traceback.print_exc()
except EXIT_REPORTING_EXCEPTION:
self.rpc_connection.close()
self.rpc_connection = None
pass
usernames = sys.argv[1:]
if len(usernames) < 1: raise Exception
except:
print "Usage: %s [-f file] username [username ...]" % sys.argv[0]
sys.exit(1)
if not filename:
print "Select image rectangle to send"
filename = os.tmpnam() + ".jpg"
os.system("import %s -quality 100" % filename)
try:
data = open(filename, "rb").read()
except IOError:
print "Image file %s not found" % imageFile
sys.exit(0)
# try to send it
client = 0
try:
client = CONNECT.send_client()
client.Send_Picture(usernames, data)
except SOCKET.COMMAND_EXCEPTION, e:
print "ERROR: %s" % e
client.close()
sys.exit(1)
else:
client.close()
path = os.path.normpath(pwd + "/" + path)
print "renormalized path to %s" % path
r = re.compile("^/solver/(vol[0-9])/.+$")
match = r.match(path)
if not match:
print "path does not start properly with /solver/vol{0,1,2,3}"
sys.exit(1)
volume = match.group(1)
return volume, path
from pd.common import CONNECT
if cmd == "create":
volume, path = parse_path(sys.argv[2])
disk = CONNECT.disk_client(volume)
print disk.Create(path)
print disk.Set_Quota(path, "100G")
elif cmd == "destroy":
volume, path = parse_path(sys.argv[2])
disk = CONNECT.disk_client(volume)
print disk.Destroy(path)
elif cmd == "setquota":
volume, path = parse_path(sys.argv[2])
quota = sys.argv[3]
disk = CONNECT.disk_client(volume)
print disk.Set_Quota(path, quota)
elif cmd == "list":
volume = sys.argv[2]
disk = CONNECT.disk_client(volume)
print "%-40s %10s %10s %10s" % ("Volume", "Used", "Avail", "Repr")
text += (" <td>%s</td>\n" % c)
text += (" </tr>\n")
text += ("</table>\n")
return text
# grab fields
form = cgi.FieldStorage()
username_filter = ""
state_filter = ""
print "Content-type: text/html\n\n"
# get session list
client = CONNECT.sim_client()
sessions = client.Session_List()
client = None
# grab form options
if form.has_key("username_filter"):
username_filter = form["username_filter"].value
if form.has_key("state_filter"): state_filter = form["state_filter"].value
# make the filter regular expressions
filter_conditions = [("username", re.compile(username_filter)),
("state", re.compile(state_filter))]
# make a list of accepted sessions
accepted_sessions = []
for i in sessions.keys():
run_directory = os.path.dirname(binary)
print run_directory
if run_directory == "." or run_directory == "": run_directory = os.getcwd()
node_count = int(nodes_str)
sim_command = binary + " " + " ".join(command)
os.chdir(run_directory)
#############################
# make a mon session
#############################
from pd.common import CONNECT
mon = None
mon_sessiond = None
try:
mon = CONNECT.mon_client()
mon_session = mon.Create_Session(os.environ["USER"])['id']
mon.Label_Session(mon_session, name)
except:
mon.close()
else:
mon.close()
if not mon_session:
print "Failed to register mon session, server possibly not running"
sys.exit(1)
#############################
# write the script file
#############################
script = """#!/bin/tcsh
cd %s
#!/usr/bin/python
from pd.common import CONNECT
client = CONNECT.host_client()
hosts = client.Host_List().items()
print "/-----------------+------------\\"
print "| %-15s | %-10s |" % ("Host", "User")
print "|-----------------+------------|"
hosts.sort(lambda x, y: cmp(x[0], y[0]))
for host in hosts:
hostname = host[0]
user = ""
if host[1].has_key("user"):
user = host[1]["user"]
if user == None:
user = ""
print "| %-15s | %-10s |" % (hostname, user)
print "\\-----------------+------------/"