lem_server Namespace Reference

Classes
class	ConnInfo

Functions
def	is_allowed_ip (ip)
def	pop_old_conns (q)
def	nConns (d)
def	pop_fronts (d)
def	get_tag ()
def	is_complete_query (msg)
def	ok200 ()
def	ok200_html ()
def	unimp501 ()
def	status_text ()
def	handle_status (client, args)
def	handle_releases (client, args)
def	handle_backlog (client, args)
def	handle_ids (client, args)
def	handle_status_html (client, args)
def	failsafe_arg (cmd, args, name)
def	handle_get_work (client, args)
def	handle_return_results (client, args, postdata)
def	handle_pid (client, args, postdata)
def	handle_query (sockStr, client)
def	startup (port)
def	close_old_connections ()
def	shed_load ()

Variables
int	gVerbosity = 0
list	gIPWhitelist
	gPIDQueue = defaultdict(deque)
	gGetWorkQueue = defaultdict(deque)
dictionary	gWorkInProgress = {}
dictionary	gClientMap = {}
int	gSeqNo = 0
int	gErrCount = 0
int	gBusyTime = 0
int	gIdleTime = 0
	gIdList = defaultdict(lambda: 0)
dictionary	gClientList = {}
dictionary	gWorkerList = {}
int	gLastSeqNo = 0
	gLastStatus = time.time()
int	kMinPort = 1024
int	kMaxPort = 1031
int	kNumPorts = kMaxPort-kMinPort+1
list	serverSock = [startup(port) for port in range(kMinPort, kMaxPort+1)]
	ep = select.epoll()
dictionary	socketMap = {}
	inbox = defaultdict(lambda: '')
	outbox = defaultdict(lambda: '')
	statusTime = time.time()
	t1 = time.time()
	t2 = time.time()
	events = ep.poll(60)
	fileno
	mask
	ss = socketMap[fileno]
	clientSock
	addr
	cs = gClientMap[fileno]
	x = cs.recv(4096)
	msgs = handle_query(inbox[cs], cs)
	msg = outbox[cs]
	n = cs.send(msg)

Function Documentation

def lem_server.close_old_connections

(

)

Definition at line 464 of file lem_server.py.

References pop_old_conns().

def close_old_connections():
    toClose = []
    nClient = 0
    nWorker = 0
    # Clear out old connections
    for rel in gPIDQueue.keys():
        toClose += pop_old_conns(gPIDQueue[rel])
    nClient = len(toClose)
    for rel in gGetWorkQueue.keys():
        toClose += pop_old_conns(gGetWorkQueue[rel])
    nWorker = len(toClose) - nClient

    if nClient > 0:
        print 'Closing', nClient, 'client connections that reached their timeout'

    if nWorker > 0 and gVerbosity > 0:
        print 'Closing', nWorker, 'worker connections that reached their timeout'

    for info in toClose:
        gClientMap.pop(info.client.fileno())
        info.client.close()

# -----------------------------------------------------------------------------

def lem_server.failsafe_arg	(		cmd,
			args,
			name
	)

Definition at line 299 of file lem_server.py.

Referenced by handle_backlog(), handle_get_work(), handle_pid(), and handle_return_results().

def failsafe_arg(cmd, args, name):
    if name in args: return args[name]
    print 'Error:', cmd, 'without', name, args
    return None

# -----------------------------------------------------------------------------

def lem_server.get_tag

(

)

Definition at line 141 of file lem_server.py.

References makeTrainCVSamples.int, and submit_syst.str.

Referenced by handle_get_work(), and handle_pid().

def get_tag():
    global gSeqNo

    n = gSeqNo
    gSeqNo += 1

    return str(int(time.time())) + '.' + str(os.getpid()) + '.' + str(n)

# -----------------------------------------------------------------------------

def lem_server.handle_backlog	(		client,
			args
	)

Definition at line 257 of file lem_server.py.

References failsafe_arg(), ok200(), and submit_syst.str.

def handle_backlog(client, args):
    if not 'rel' in args:
        count = {}
        for rel in gPIDQueue.keys():
            N = len(gPIDQueue[rel])
            if N > 0: count[rel] = N

        msg = ok200()
        if len(count) == 0:
            msg += 'No backlog\n'
        else:
            msg += 'Backlogs:\n'
            for rel in count.keys():
                msg += rel+': '+str(count[rel])+'\n'
        return {client: msg}

    # Otherwise a release /was/ specified, return machine-readable result
    rel = failsafe_arg('backlog', args, 'rel')

    count = len(gPIDQueue[rel])

    return {client: ok200()+str(count)+'\n'}

# -----------------------------------------------------------------------------

def lem_server.handle_get_work	(		client,
			args
	)

Definition at line 306 of file lem_server.py.

References append(), failsafe_arg(), get_tag(), min(), ok200(), and unimp501().

def handle_get_work(client, args):
    global gQueuedPIDRequest, gGetWorkQueue, gWorkInProgress, gVerbosity

    workerID = failsafe_arg('get_work', args, 'id')
    rel = failsafe_arg('get_work', args, 'rel')
    timeout = failsafe_arg('get_work', args, 'timeout')

    if not workerID or not rel or not timeout:
        return {client: unimp501()}

    # No work to give out right now
    if len(gPIDQueue[rel]) == 0 or gPIDQueue[rel][-1].late():
        # Experimenting with not letting too many get_work calls build up
        gGetWorkQueue[rel].append(ConnInfo(client, '', min(10,timeout)))
        return {}

    # There is work, and it's recent enough
    info = gPIDQueue[rel].pop()
    # Remember we're doing this so we know who the reply goes to
    tag = get_tag()
    gWorkInProgress[tag] = info


    if gVerbosity > 0:
        print 'Handing out work under tag', tag

    return {client: ok200() + 'tag='+tag+'\n' + info.query}

# -----------------------------------------------------------------------------

def lem_server.handle_ids	(		client,
			args
	)

Definition at line 282 of file lem_server.py.

References ok200(), and submit_syst.str.

def handle_ids(client, args):
    msg = ok200()

    for key in sorted(gIdList.keys()):
        msg += key + ' : ' + str(gIdList[key])+'\n'

    return {client: msg}

# -----------------------------------------------------------------------------

def lem_server.handle_pid	(		client,
			args,
			postdata
	)

Definition at line 358 of file lem_server.py.

References append(), failsafe_arg(), get_tag(), ok200(), and unimp501().

def handle_pid(client, args, postdata):
    global gQueuedPIDRequest, gGetWorkQueue, gWorkInProgress, gVerbosity

    rel = failsafe_arg('handle_pid', args, 'rel')
    timeout = failsafe_arg('handle_pid', args, 'timeout')

    if not rel or not timeout:
        return {client: unimp501()}

    info = ConnInfo(client, postdata, timeout)

    # No recent matching worker, stick it in the queue
    if len(gGetWorkQueue[rel]) == 0 or gGetWorkQueue[rel][-1].late():
        gPIDQueue[rel].append(info)
        return {}

    # All OK, hook things up
    workerClient = gGetWorkQueue[rel].pop().client

    # Remember that we're doing this
    tag = get_tag()
    gWorkInProgress[tag] = info


    if gVerbosity > 0: print 'Handing out work under tag', tag
    return {workerClient: ok200() + 'tag='+tag+'\n' + info.query}

# -----------------------------------------------------------------------------

# Returns a map from sockets to the strings to send to them

def lem_server.handle_query	(		sockStr,
			client
	)

Definition at line 388 of file lem_server.py.

References unimp501().

def handle_query(sockStr, client):
    if gVerbosity > 0: print sockStr

    query, junk, postdata = sockStr.partition('\r\n\r\n')

    isGet = query.startswith('GET')
    isPost = query.startswith('POST')

    # Second thing after GET/POST. Drop the leading slash
    params = query.split(' ')[1][1:]
    cmd, junk, argStr = params.partition('?')

    args = {}
    for arg in argStr.split('&'):
        key, junk, val = arg.partition('=')
        args[key] = val

    if gVerbosity > 0: print 'Parameters are:', params
    if gVerbosity > 0: print 'Cmd:', cmd, 'args:', args

    shortId = 'unknown'
    if 'id' in args:
        shortId = args['id']

        # Update last contacted
        if isPost and cmd == 'pid':
            gClientList[shortId] = time.time()
        if isGet and cmd == 'get_work':
            gWorkerList[shortId] = time.time()

        # Clumsily truncate the last two numbers off the end to leave the host
        if shortId.rfind('.') > 0: shortId = shortId[:shortId.rfind('.')]
        if shortId.rfind('.') > 0: shortId = shortId[:shortId.rfind('.')]

        gIdList[shortId] += 1


    get_handlers = {
        'get_work'    : handle_get_work,
        'status'      : handle_status,
        'status.html' : handle_status_html,
        'releases'    : handle_releases,
        'backlog'     : handle_backlog,
        'ids'         : handle_ids
    }

    post_handlers = {
        'pid'            : handle_pid,
        'return_results' : handle_return_results
    }

    if isGet and cmd in get_handlers:
        return get_handlers[cmd](client, args)

    if isPost and cmd in post_handlers:
        return post_handlers[cmd](client, args, postdata)

    # Didn't hit any of the cases above
    print 'Rejecting malformed query:'
    print sockStr

    return {client: unimp501()}

# -----------------------------------------------------------------------------

def lem_server.handle_releases	(		client,
			args
	)

Definition at line 243 of file lem_server.py.

References ok200().

def handle_releases(client, args):
    rels = set()
    # TODO ideally we would also list releases with only in-progress PIDs,
    # but we don't store that information anywhere.
    for key in gPIDQueue:
        if len(gPIDQueue[key]) > 0:
            rels.add(key)

    msg = ok200()
    for rel in rels: msg += rel+'\n'
    return {client: msg}

# -----------------------------------------------------------------------------

def lem_server.handle_return_results	(		client,
			args,
			postdata
	)

Definition at line 336 of file lem_server.py.

References failsafe_arg(), ok200(), and unimp501().

def handle_return_results(client, args, postdata):
    global gQueuedPIDRequest, gGetWorkQueue, gWorkInProgress, gVerbosity

    tag = failsafe_arg('return_results', args, 'tag')

    if not tag:
        return {client: unimp501()}

    if tag not in gWorkInProgress:
        print 'Warning: Reply for unknown tag', tag
        return {client: ok200()}

    workerClient = gWorkInProgress.pop(tag).client

    if gVerbosity > 0: print 'Sending response', postdata

    # No point checking the timeout, just try to send to the client in any case
    return {client: ok200(),
            workerClient: ok200()+postdata}

# -----------------------------------------------------------------------------

def lem_server.handle_status	(		client,
			args
	)

Definition at line 238 of file lem_server.py.

References ok200(), and status_text().

def handle_status(client, args):
    return {client: ok200()+status_text()+'\n'}

# -----------------------------------------------------------------------------

def lem_server.handle_status_html	(		client,
			args
	)

Definition at line 292 of file lem_server.py.

References ok200_html(), and status_text().

def handle_status_html(client, args):
    htmlHead = '<html><head><meta charset="UTF-8"><meta http-equiv="refresh" content="60"><title>LEM server status</title></head><body>\n'
    htmlFoot = '</body></html>\n'

    return {client: ok200_html() + htmlHead + status_text() + htmlFoot}

# -----------------------------------------------------------------------------

def lem_server.is_allowed_ip

(

ip

)

Definition at line 63 of file lem_server.py.

def is_allowed_ip(ip):
    # We'll be running offsite. Don't know all those IP addresses, so just let
    # anything through for now.
    return True

    for entry in gIPWhitelist:
        if ip.startswith(entry): return True
    return False

def lem_server.is_complete_query

(

msg

)

Definition at line 151 of file lem_server.py.

References makeTrainCVSamples.int.

def is_complete_query(msg):
    # headers are always terminated by \r\n\r\n
    kTerminator = '\r\n\r\n';

    if kTerminator not in msg: return False

    headerSize = msg.find(kTerminator)+4

    cl = 'Content-Length: '
    # No content-length, therefore no body
    if cl not in msg: return True
    lpos = msg.find(cl)

    # Parse the context-length header
    newline = msg.find('\r', lpos+len(cl))
    bodyLength = int(msg[lpos+len(cl):newline])

    return len(msg) == headerSize+bodyLength

# -----------------------------------------------------------------------------

def lem_server.nConns

(

d

)

Definition at line 93 of file lem_server.py.

References sum.

Referenced by shed_load(), and status_text().

def nConns(d):
    return sum([len(x) for x in d.values()])

# Takes a dict of deques, removes the first element from every deque, and
# returns that list.

def lem_server.ok200

(

)

Definition at line 172 of file lem_server.py.

Referenced by handle_backlog(), handle_get_work(), handle_ids(), handle_pid(), handle_releases(), handle_return_results(), and handle_status().

def ok200():
    return 'HTTP/1.0 200 OK\r\n'\
           'Server: LEMServer/0.1.0\r\n'\
           'Content-Type: text/plain\r\n'\
           '\r\n'

# -----------------------------------------------------------------------------

def lem_server.ok200_html

(

)

Definition at line 180 of file lem_server.py.

Referenced by handle_status_html().

def ok200_html():
    return 'HTTP/1.0 200 OK\r\n'\
           'Server: LEMServer/0.1.0\r\n'\
           'Content-Type: text/html\r\n'\
           '\r\n'

# -----------------------------------------------------------------------------

def lem_server.pop_fronts

(

d

)

Definition at line 98 of file lem_server.py.

Referenced by shed_load().

def pop_fronts(d):
    return [x.popleft() for x in d.values() if len(x) > 0]


# When a new 'pid' request comes in, if we can't match it to a worker
# immediately, we put it here. The top level key is the release, and under each
# release is a list of requests (ConnInfo objects), ordered by age, newest
# last.

def lem_server.pop_old_conns

(

q

)

Definition at line 86 of file lem_server.py.

Referenced by close_old_connections().

def pop_old_conns(q):
    ret = []
    while len(q) > 0 and q[0].late():
        ret.append(q.popleft())
    return ret

# Sums the length of all the lists in a dict

def lem_server.shed_load

(

)

Definition at line 488 of file lem_server.py.

References nConns(), and pop_fronts().

def shed_load():
    toClose = []

    kConnLimit = 3300

    # First drop older PID requests
    while nConns(gPIDQueue) + nConns(gGetWorkQueue) + len(gWorkInProgress) > kConnLimit and nConns(gPIDQueue) > 0:
        toClose += pop_fronts(gPIDQueue)

    # If things get desperate, drop get_work requests
    while nConns(gGetWorkQueue) + len(gWorkInProgress) > kConnLimit and nConns(gGetWorkQueue) > 0:
        toClose += pop_fronts(gGetWorkQueue)

    # And finally, throw away actual work in progress (at random)
    keys = gWorkInProgress.keys()
    for key in keys:
        if len(gWorkInProgress) <= kConnLimit: break
        toClose.append(gWorkInProgress.pop(key))


    if len(toClose) > 0:
        print 'Overloaded: closing', len(toClose), 'connections'
        # Doesn't seem to recover situation. Let the restarter do its thing
        sys.exit(1)

    for info in toClose:
        gClientMap.pop(info.client.fileno())
        info.client.close()


# -----------------------------------------------------------------------------

def lem_server.startup

(

port

)

Definition at line 453 of file lem_server.py.

def startup(port):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # Reuse port immediately even if a previous instance just aborted.
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind(('', port))
    # Parameter is the length of "backlog" allowed
    s.listen(128)
    return s

# -----------------------------------------------------------------------------

def lem_server.status_text

(

)

Definition at line 199 of file lem_server.py.

References makeTrainCVSamples.int, nConns(), and submit_syst.str.

Referenced by handle_status(), and handle_status_html().

def status_text():
    global gLastSeqNo, gLastStatus

    rate = int((gSeqNo-gLastSeqNo)/(time.time()-gLastStatus))
    gLastSeqNo = gSeqNo
    gLastStatus = time.time()

    msg = time.strftime('%Y-%m-%d %H:%M:%S %Z: ')
    msg += 'Handled ' + str(gSeqNo) + ' queries ('+str(rate)+' Hz). '
    msg += str(len(gWorkInProgress)) + ' workers working, '
    msg += str(nConns(gGetWorkQueue)) + ' waiting, '
    msg += str(nConns(gPIDQueue)) + ' backlog. '
    msg += str(gErrCount) + ' errors. '
    msg += 'Server '+str(.1*int(1000*gBusyTime/(gBusyTime+gIdleTime)+.5))+'% busy. '

    # Forget about clients and workers after 10 minutes
    t0 = time.time()
    n10s = 0
    n60s = 0
    n5m = 0
    n30m = 0
    for k in gClientList.keys():
        t = gClientList[k]
        if t0 < t+10: n10s += 1
        if t0 < t+60: n60s += 1
        if t0 < t+300: n5m += 1
        if t0 < t+1800: n30m += 1
        if t0 > t+1800: gClientList.pop(k)
    for k in gWorkerList:
        if t0 > gWorkerList[k] + 600: gClientList.pop(k)

    msg += str(n10s)+'/'+str(n60s)+'/'+str(n5m)+'/'+str(n30m)+' clients active in last 10s/60s/5m/30m. '

    msg += str(len(gWorkerList)) + ' workers in last 10m.'

    return msg

# -----------------------------------------------------------------------------

def lem_server.unimp501

(

)

Definition at line 188 of file lem_server.py.

Referenced by handle_get_work(), handle_pid(), handle_query(), and handle_return_results().

def unimp501():
    return 'HTTP/1.0 501 Not Implemented\r\n'\
           'Server: LEMServer/0.1.0\r\n'\
           'Content-Type: text/plain\r\n'\
           '\r\n'\
           "I don't know how to do that\r\n"

# -----------------------------------------------------------------------------

Variable Documentation

lem_server.addr

Definition at line 573 of file lem_server.py.

lem_server.clientSock

Definition at line 573 of file lem_server.py.

lem_server.cs = gClientMap[fileno]

Definition at line 582 of file lem_server.py.

Referenced by evd::RecoBaseDrawer.DimOutOfTime(), tdslicer::TDSlicer.FillDists(), ana::PredictionInterp.FitRatios(), GausFit(), evdb::ColorScale.Palette(), plot_times(), tdslicer::TDSlicer.produce(), evdb::Colors.reconfigure(), evdb::Colors.Scale(), evdb::ColorScale.Scale(), lem::DistanceMap.SetCellScale(), calib::ThresholdCorrMap.ThresholdCorrMap(), evdb::Colors.UnpackColorScale(), VarContainer.VarContainer(), VarContainer2D.VarContainer2D(), and VarContainer3D.VarContainer3D().

lem_server.ep = select.epoll()

Definition at line 529 of file lem_server.py.

Referenced by art::ResultsProducer.doEvent(), skim::CellHitSkimmer.endRun(), art::DecrepitRelicInputSourceImplementation.eventPrincipal(), art::OutputModule.fileGranularity(), jmshower::RecoJMShower.GetCellTransDedx(), jmshower::RecoJMShower.GetPlaneDedx(), art::WorkerT< OutputModule >.module(), art::ProcessPackage< L >.postScheduleSignal(), art::ProcessPackage< L >.preScheduleSignal(), art::Path.process(), art::EndPathExecutor.process(), caf::CAFMaker.produce(), art::SamplingInput.readEvent(), art::Schedule.runTriggerPaths_(), art::WorkerInPath.runWorker(), BrightnessModelPlots.ScheduleSamples(), MEUPerDiblock.ScheduleSamples(), MEUPerFEB.ScheduleSamples(), MEUPerCell.ScheduleSamples(), ValidCalibPDF.ScheduleSamples(), ValidCalibPDF.SetEpochList(), and genie::NuElectronPXSec.XSec().

lem_server.events = ep.poll(60)

Definition at line 559 of file lem_server.py.

lem_server.fileno

Definition at line 564 of file lem_server.py.

int lem_server.gBusyTime = 0

Definition at line 129 of file lem_server.py.

dictionary lem_server.gClientList = {}

Definition at line 135 of file lem_server.py.

dictionary lem_server.gClientMap = {}

Definition at line 122 of file lem_server.py.

int lem_server.gErrCount = 0

Definition at line 127 of file lem_server.py.

lem_server.gGetWorkQueue = defaultdict(deque)

Definition at line 112 of file lem_server.py.

int lem_server.gIdleTime = 0

Definition at line 130 of file lem_server.py.

lem_server.gIdList = defaultdict(lambda: 0)

Definition at line 132 of file lem_server.py.

list lem_server.gIPWhitelist

Initial value:

= [
    # Fermilab, according to https://ipinfo.io/AS3152
    '131.225.',
    '192.190.216.',
    '198.49.208.',
    # Caltech, according to https://ipinfo.io/AS31
    # TODO maybe only the HEP cluster machines?
    '131.215.',
    '134.4.',
    '192.12.19.',
    '192.31.43.',
    '192.31.208.',
    '192.43.243.',
    '192.54.249.'
    # SMU: https://ipinfo.io/AS1832
    # UMN: https://ipinfo.io/AS217
    ]

Definition at line 45 of file lem_server.py.

int lem_server.gLastSeqNo = 0

Definition at line 197 of file lem_server.py.

lem_server.gLastStatus = time.time()

Definition at line 198 of file lem_server.py.

lem_server.gPIDQueue = defaultdict(deque)

Definition at line 106 of file lem_server.py.

int lem_server.gSeqNo = 0

Definition at line 125 of file lem_server.py.

int lem_server.gVerbosity = 0

Definition at line 42 of file lem_server.py.

dictionary lem_server.gWorkerList = {}

Definition at line 136 of file lem_server.py.

dictionary lem_server.gWorkInProgress = {}

Definition at line 119 of file lem_server.py.

lem_server.inbox = defaultdict(lambda: '')

Definition at line 535 of file lem_server.py.

int lem_server.kMaxPort = 1031

Definition at line 522 of file lem_server.py.

int lem_server.kMinPort = 1024

Definition at line 521 of file lem_server.py.

int lem_server.kNumPorts = kMaxPort-kMinPort+1

Definition at line 523 of file lem_server.py.

lem_server.mask

Definition at line 564 of file lem_server.py.

Referenced by genie::GHepRecord.Accept(), ana::FileReducer.AccumulateExposures(), calhit::RemoveBadChannels.beginRun(), calhit::CalHit.beginRun(), caf::CAFMaker.beginRun(), calhit::RemoveBadChannels.beginSubRun(), calhit::CalHit.beginSubRun(), caf::CAFMaker.beginSubRun(), daqdataformats::VERSION_NAMESPACE::RawTriggerMask.init(), ana.LogLikelihood(), novaddt::HotMapMaker.MakeMask(), novaddt.nbitMask(), nova::dbi::RunHistoryService.preBeginRun(), nova::dbi::RunHistoryService.preBeginSubrun(), daqdataformats::VERSION_NAMESPACE::RawTrigger.print(), nova::dbi::Table.SetDataTypeMask(), nutools::dbi::Table.SetDataTypeMask(), nova::dbi::RunHistory.SetSubrunDiBlockMask(), genie::GMCJDriver.SetUnphysEventMask(), genie::GEVGDriver.SetUnphysEventMask(), genie::GHepRecord.SetUnphysEventMask(), evdb::ParameterSetEditRow.SetupCheckButton(), daqdataformats::VERSION_NAMESPACE::RawNanoSlice.setValue1(), rawdata::RawTrigger.TDCT0(), and genie::GHepRecord.Vertex().

lem_server.msg = outbox[cs]

Definition at line 603 of file lem_server.py.

Referenced by ana::CovMxManager.AddSystematic(), novaddt::SendTriggerSignal.analyze(), stan::services::optimize.bfgs(), stan::math::internal::bounded< T_y, T_low, T_high, y_is_vec >.check(), stan::math::internal::bounded< T_y, T_low, T_high, true >.check(), stan::math.check_2F1_converges(), stan::math.check_3F2_converges(), stan::math.check_column_index(), stan::math.check_consistent_size(), stan::math.check_corr_matrix(), check_identifier(), stan::math.check_ldlt_factor(), stan::math.check_lower_triangular(), stan::math.check_matching_dims(), stan::math.check_positive_ordered(), stan::math.check_positive_size(), stan::math.check_range(), stan::math.check_row_index(), stan::math.check_simplex(), stan::math.check_size_match(), stan::math.check_std_vector_index(), stan::math.check_unit_vector(), stan::math.check_vector(), novaddt::SupernovaTrigger.filter(), daqdataformats::RawDAQData.generateExceptionForWrongVersion(), stan::io::dump_reader.get_int(), daqdataformats::RawMicroSlice.getNumNanoSlices(), dbutils::gui::ConfigDataTreeModel.headerData(), daqdataformats::VERSION_NAMESPACE::RawTriggerMask.init(), stan::services::util.initialize(), gov::fnal::cd::rms::RmsProducer.initialize(), stan::services::optimize.lbfgs(), main(), stan::services::optimize.newton(), stan::io::dump_reader.next(), cet::ostream_handle.operator<<(), stan::lang.parse(), stan::io.print_help_option(), nl::timing::LogFile.ProcessLog(), cet::sqlite.query(), daqdataformats::RawMicroSlice.RawMicroSlice(), gov::fnal::cd::rms::RmsConsumer.RmsConsumer(), gov::fnal::cd::rms::RmsReceiver< CONN, MSG, LSTNR >.RmsReceiver(), gov::fnal::cd::rms::RmsSender< C, M >.RmsSender(), stan::variational::advi< stan_model, stan::variational::normal_meanfield, rng_t >.run(), dbutils::gui::BasicEditorDisplay.saveChangesWithNewName(), stan::io::dump_reader.scan_dim(), stan::io::dump_reader.scan_double(), genie::PhysInteractionSelector.SelectInteraction(), gov::fnal::cd::rms::base::RmsDestination.setProperty(), daqdataformats::RawMicroSlice.setVersion(), stanc_helper(), stan::services.standalone_generate(), TEST_F(), stan::model.test_gradients(), art::Source< T >.throwDataCorruption_(), tf.TimingFitErrorHandler(), stan::io::array_var_context.validate(), stan::io::var_context.validate_dims(), stan::math.validate_non_negative_index(), stan::math::var.var(), stan::mcmc::base_leapfrog< dense_e_metric< Model, BaseRNG > >.verbose_evolve(), VerticalSlice(), warp_meta(), and stan::math.wiener_lpdf().

lem_server.msgs = handle_query(inbox[cs], cs)

Definition at line 596 of file lem_server.py.

Referenced by stan::math.algebra_solver(), expect_match(), stan::model.finite_diff_grad(), stan::model.grad_hess_log_prob(), stan::model.grad_tr_mat_times_hessian(), stan::model.gradient(), stan::model.gradient_dot_vector(), stan::model.hessian(), stan::model.hessian_times_vector(), stan::math.integrate_ode_adams(), stan::math.integrate_ode_bdf(), stan::math.integrate_ode_rk45(), is_parsable(), is_parsable_folder(), stan::model.log_prob_grad(), stan::model.log_prob_propto(), stan::math.map_rect(), stan::math::internal.map_rect_concurrent(), model_to_cpp(), stan::math::internal::map_rect_reduce< F, var, var >.operator()(), stan::math::internal::map_rect_reduce< F, double, double >.operator()(), stan::math::internal::map_rect_reduce< F, double, var >.operator()(), stan::math::internal::map_rect_reduce< F, var, double >.operator()(), TEST(), test_num_warnings(), test_parsable(), test_throws(), and test_warning().

lem_server.n = cs.send(msg)

Definition at line 604 of file lem_server.py.

lem_server.outbox = defaultdict(lambda: '')

Definition at line 536 of file lem_server.py.

list lem_server.serverSock = [startup(port) for port in range(kMinPort, kMaxPort+1)]

Definition at line 525 of file lem_server.py.

dictionary lem_server.socketMap = {}

Definition at line 530 of file lem_server.py.

lem_server.ss = socketMap[fileno]

Definition at line 572 of file lem_server.py.

lem_server.statusTime = time.time()

Definition at line 538 of file lem_server.py.

lem_server.t1 = time.time()

Definition at line 540 of file lem_server.py.

lem_server.t2 = time.time()

Definition at line 541 of file lem_server.py.

lem_server.x = cs.recv(4096)

Definition at line 585 of file lem_server.py.