source: fedd/fedd_spewlog.py @ c6d6c43

#!/usr/bin/env python

import sys
import time

from federation.proof import proof
from federation.remote_service import service_caller
from federation.client_lib import client_opts, exit_with_fault, RPCException, \
        wrangle_standard_options, do_rpc, get_experiment_names, save_certfile

class spew_opts(client_opts):
    def __init__(self):
        client_opts.__init__(self)
        self.add_option("--experiment_cert", dest="exp_certfile",
                action='callback', callback=self.expand_file, type='str',
                help="experiment name certificate file")
        self.add_option("--experiment_name", dest="exp_name",
                type="string", help="human readable experiment name")
        self.add_option("--logfile", dest="logfile", default=None,
                action='callback', callback=self.expand_file, type='str',
                help="File to write log to")
        self.add_option('--update_time', dest='update', type='int', default=10,
                help='how often to update the printed log')

# Keep requesting experiment status and printing updates to the log until the
# experiment is done being created.
parser = spew_opts()
(opts, args) = parser.parse_args()

try:
    cert, fid, url = wrangle_standard_options(opts)
except RuntimeError, e:
    sys.exit("%s" %e)

if opts.exp_name and opts.exp_certfile:
    sys.exit("Only one of --experiment_cert and --experiment_name permitted");
elif opts.exp_certfile:
    exp_id = { 'fedid': fedid(file=opts.exp_certfile) }
elif opts.exp_name:
    exp_id = { 'localname' : opts.exp_name }
else:
    sys.exit("specify one of --experiment_cert and --experiment_name")

if opts.logfile:
    try:
        out = open(opts.logfile, "w")
    except IOError,e:
        sys.exit("Cannot open logfile: %s" %e)
else:
    out = sys.stdout

req = { 'experiment': exp_id }

status = "starting"
log = ""
log_offset = 0
update = opts.update
while status == 'starting':
    try:
        resp_dict = do_rpc(req,
                url, opts.transport, cert, opts.trusted, 
                serialize_only=opts.serialize_only,
                tracefile=opts.tracefile,
                caller=service_caller('Info'), responseBody="InfoResponseBody")
    except RPCException, e:
        exit_with_fault(e, 'Info (spewlog)', opts)
    except RuntimeError, e:
        sys.exit("Error processing RPC: %s" % e)

    proof = proof.from_dict(resp_dict.get('proof', {}))
    if proof and opts.auth_log:
        log_authentication(opts.auth_log, 'Info (spewlog)', 'succeeded', proof)

    if not opts.serialize_only:
        status = resp_dict.get('experimentStatus', None)
    else:
        status = "active"
    log = resp_dict.get('allocationLog', None)
    if not status:
        sys.exit("No status in Info response??")
    if log:
        if len(log) > log_offset:
            print >>out, log[log_offset:],
            out.flush()
            log_offset = len(log)
    if status == 'starting': 
        time.sleep(update)
print >>out
print >>out, status
out.close()