def save_token_request(signed_blind_token):
print("[RequestHandler - request_sign_blind_token - save_token_request] Saving the register token request of \n "
"user_id='%s' for ballot_id='%s' with signed_blind_ballot='%s...'" % (user_id, ballot_id, str(signed_blind_token)[0:20]) )
# We should save our processed request.
hash = SHA256.new()
hash.update(str(blind_token).encode())
blind_token_hash = hash.hexdigest()
defer = databasequery.insert_into_register_token_blind_token_hash_user_id_ballot_id(blind_token_hash, user_id, ballot_id)
# Cool, saving worked. Return singed token to user.
def return_result(ignored):
print("[RequestHandler - request_sign_blind_token - returnResult] Computation completed, returning signed token to the client. ")
# Pickle the signed token to return over the wire
encoded_signed_blind_token = pickle.dumps(signed_blind_token)
return { 'ok' : encoded_signed_blind_token }
def return_result_errback(failure):
print("[RequestHandler - request_sign_blind_token - return_result_errback] There was an error saving the token.")
raise failure.raiseException()
defer.addCallback(return_result).addErrback(return_result_errback)
return defer
def queryCallback(l):
p = string.join([
], "<br>")
request.write( "<html>")
request.write(title_string)
request.write("Patients:<p>")
request.write("<ul>")
print l
for (pid,pname,did) in l:
request.write('<li>PID: %(rpid)s Name: %(pname)s'
% { 'rpid': renderPatientID(pid), 'pname': pname })
if did:
request.write(' Device: %s' % renderDeviceID(did))
request.write("</ul>")
request.write("""<form method="post" action="/patients/newdevice">
</form>
""")
if 1:
request.write('</html>')
request.finish()
else:
query = ("select deviceid from patient, patientdevice where patient.patientid='%s' and patientdevice.patientid = patient.patientid" % self.patientid)
print query
defer = dbpool.runQuery(query)
defer.addCallback(queryDevicesCallback)
def runQueryPatientRequest(self):
deviceid = self.headers['did']
(ipaddr, udpport) = self.addr
if self.headers.has_key('dtype'):
dtype = self.headers['dtype']
else:
dtype = '<unknown>'
def updateDevice():
query = "replace into device (deviceid, dtype, ipaddr) values ('%s', '%s', '%s')" % (deviceid, dtype, ipaddr)
if verbose: print 'updateDevice: ', query
defer = dbpool.runQuery(query)
defer.addCallback(self.nullCallback)
def queryCallback(l):
if (len(l) > 0):
(pid, name) = l[0]
response = '200 OK\r\n' + 'PID: ' + pid + '\r\nName: ' + name + '\r\n'
if verbose: print 'queryCallback response=', response
port.write(response, self.addr)
updateDevice()
return
query = ("select patient.patientid, name from patient, patientdevice where patientdevice.deviceid='%s' and patientdevice.patientid = patient.patientid"
% (deviceid, ))
if verbose: print query
defer = dbpool.runQuery(query)
defer.addCallback(queryCallback)
def test_writeSequence(self):
"""
Write a sequence of L{bytes} to a L{DatagramProtocol}.
"""
class SimpleDatagramProtocol(DatagramProtocol):
def __init__(self):
self.defer = Deferred()
def datagramReceived(self, data, addr):
self.defer.callback(data)
reactor = self.buildReactor()
protocol = SimpleDatagramProtocol()
defer = protocol.defer
port = self.getListeningPort(reactor, protocol)
address = port.getHost()
dataToWrite = (b"some", b"bytes", b"to", b"write")
def gotData(data):
self.assertEqual(b"".join(dataToWrite), data)
defer.addCallback(gotData)
defer.addErrback(err)
defer.addCallback(lambda ignored: reactor.stop())
port.writeSequence(dataToWrite, ("127.0.0.1", address.port))
self.runReactor(reactor)
def checkCPU( self ): if ( self.state == 0 or self.p_transport is None or self.p_transport.pid is None ): print 'checkCPU: no child process atm' return defer = utils.getProcessOutput( '/bin/bash', [ '-c', 'cat /proc/%d/status | grep SleepAVG' % self.p_transport.pid ] ) defer.addCallback( self.sleepAVGReply ) defer.setTimeout( 2, self.sleepAVGTimeout )
def service_handle_request(self):
# get the accessor object for this service
ac = provenance_accessor.ProvenanceAccessor()
# call autosuggest method of accessor - this returns a tuple: a defered and a string!
defer = ac.get_provenanceInfo()
# add callback to do the output when finishing
defer.addCallback(self.output_callback)
def service_handle_request(self): # get the accessor object for this service ac = provenance_accessor.ProvenanceAccessor() # call autosuggest method of accessor - this returns a tuple: a defered and a string! defer = ac.get_provenanceInfo() # add callback to do the output when finishing defer.addCallback(self.output_callback)
def next(self):
# if we have something in the queue, and an available reducer, take care of it
if len(self.queue)>0 and self.count < self.pool_size:
url, success, err, headers = self.queue.pop(0)
def succeed(*args, **kwargs):
log.debug("ClientQueue: success, queue size %d, reqs out %d" % (len(self.queue), self.count))
self.count -= 1
try:
success(*args, **kwargs)
except Exception, e:
log.err("Exception '%s' in ClientQueue callback; moving on" % str(e))
self.next()
def fail(*args, **kwargs):
log.debug("ClientQueue: failure, queue size %d, reqs out %d" % (len(self.queue), self.count))
self.count -= 1
try:
err(*args, **kwargs)
except:
log.err("Exception in ClientQueue errback; moving on")
self.next()
self.count += 1
defer = getPageWithHeaders(url, headers=headers).deferred
defer.addCallback(succeed)
defer.addErrback(fail)
def test_writeSequence(self):
"""
Write a sequence of L{bytes} to a L{DatagramProtocol}.
"""
class SimpleDatagramProtocol(DatagramProtocol):
def __init__(self):
self.defer = Deferred()
def datagramReceived(self, data, addr):
self.defer.callback(data)
reactor = self.buildReactor()
protocol = SimpleDatagramProtocol()
defer = protocol.defer
port = self.getListeningPort(reactor, protocol)
address = port.getHost()
dataToWrite = (b"some", b"bytes", b"to", b"write")
def gotData(data):
self.assertEqual(b"".join(dataToWrite), data)
defer.addCallback(gotData)
defer.addErrback(err)
defer.addCallback(lambda ignored: reactor.stop())
port.writeSequence(dataToWrite, ("127.0.0.1", address.port))
self.runReactor(reactor)
def runRegisterDeviceRequest(self):
deviceid = self.headers['did']
ipaddr = self.headers['ip']
dtype = self.headers['type']
expires = self.headers['expires']
query = ("replace into device (deviceid, ipaddr, dtype, expires) values ('%s', '%s', '%s', date_add(NOW(), interval %d second))"
% (deviceid, ipaddr, dtype, expires))
print query
defer = dbpool.runQuery(query)
defer.addCallback(self.dbCallback)
def servicesCallback(l):
request.write('<a href="/services"><h2>Services</h2></a><p>')
request.write('<ul>')
for (did, sname, stype, ipaddr, port) in l:
request.write('<li> %s on %s (%s:%s:%s)' % (renderSType(sname), renderDeviceID(did), stype, ipaddr, port))
request.write('</ul>')
query = "select patient.name, patient.patientid, patientdevice.deviceid, dtype from patient left join patientdevice on patientdevice.patientid = patient.patientid left join device on patientdevice.deviceid = device.deviceid"
print query
defer = dbpool.runQuery(query)
defer.addCallback(patientsCallback)
def runRegisterServiceRequest(self):
print 'runRegisterServiceRequest'
deviceid = self.headers['did']
sname = self.headers['svn']
stype = self.headers['svt']
port = self.headers['svp']
query = ("replace into service (sname, stype, deviceid, port, expires) values ('%s', '%s', '%s', '%s', date_add(NOW(), interval %d second))"
% (sname, stype, deviceid, port, 3600))
print query
defer = dbpool.runQuery(query)
defer.addCallback(self.dbCallback)
def update_last_user_level(self, user_id, request):
"""内部接口:更新战力排行榜中第50名用户的等级"""
timer = Timer(user_id)
req = mission_pb2.UpdateLastUserLevelReq()
req.ParseFromString(request)
defer = mission_business.update_last_user_level()
defer.addCallback(self._update_last_user_level_succeed, req, timer)
defer.addErrback(self._update_last_user_level_failed, req, timer)
return defer
def checkCPU(self):
if (self.state == 0 or self.p_transport is None
or self.p_transport.pid is None):
print 'checkCPU: no child process atm'
return
defer = utils.getProcessOutput('/bin/bash', [
'-c',
'cat /proc/%d/status | grep SleepAVG' % self.p_transport.pid
])
defer.addCallback(self.sleepAVGReply)
defer.setTimeout(2, self.sleepAVGTimeout)
def add(self, ip, port, checks=None):
defer = self.request(method='add',
data={
'proxy': '{}:{}'.format(ip, port),
})
if checks:
defer.addCallback(
lambda x: self.add_proxy_check_callback(x, checks))
yield defer
return True
def finish_mission(self, user_id, request):
timer = Timer(user_id)
req = mission_pb2.FinishMissionReq()
req.ParseFromString(request)
defer = DataBase().get_data(user_id)
defer.addCallback(self._calc_finish_mission, req, timer)
defer.addCallback(self._finish_mission_succeed, req, timer)
defer.addErrback(self._finish_mission_failed, req, timer)
return defer
def requestAvatarId(self, credentials):
publickey = base64.b64encode(credentials.blob)
print publickey
# SQL Injection ...
defer = self.dbpool.runQuery(
"SELECT account FROM publickeys WHERE publickey = '%s'" %
publickey)
defer.addCallback(self._cbRequestAvatarId, credentials)
defer.addErrback(self._ebRequestAvatarId)
# return "sqale" とか変えすと認証無条件で通る
return defer
def render_POST(self, request):
pname = request.args['pname'][0]
pid = request.args['pid'][0]
print 'args=', request.args
print 'request.received_headers', request.received_headers
def nprPostCallback(l):
request.write('<html>Patient <a href="/patients/%s">%s</a> added.</html>' % (pid, pname))
request.finish()
query = "insert into patient (patientid, name) values ('%s', '%s')" % (pid, pname)
print query
defer = dbpool.runQuery(query)
defer.addCallback(nprPostCallback)
return server.NOT_DONE_YET
def perspective_getSubmissions(self):
"""Return all submissions by user"""
def _cbGotSubmissions(submissions):
subs_full = [] # List of (timestamp, problem_no, result)
for problem_subs in submissions:
if problem_subs:
for prob, lang, ts, result in problem_subs:
subs_full.append((ts, prob, lang, result))
subs_full.sort()
return subs_full
defer = self.profile.getSubmissions(self.id)
defer.addCallback(_cbGotSubmissions)
return defer
def addUpdateListCallbacks(self, success=None, failure=None, both=False):
if 'updateList' in self.defers:
defer = self.defers['updateList']
if not both:
if isinstance(success, types.FunctionType):
defer.addCallback(success)
if isinstance(failure, types.FunctionType):
defer.addErrback(failure)
else:
if isinstance(success, types.FunctionType):
defer.addBoth(success)
def devicesCallback(l):
request.write('<html>')
request.write('<head><META HTTP-EQUIV=Refresh CONTENT=\"10; URL=/\">')
request.write('<body>')
request.write(title_string)
request.write('<a href="/devices"><h2>Devices</h2></a><p></html>')
request.write('<ul>')
for (did, dtype, ipaddr) in l:
request.write('<li> %s: (%s) at %s' % (renderDeviceID(did), dtype, ipaddr))
request.write('</ul>')
query = ("select device.deviceid, sname, stype, ipaddr, port from service, device where service.deviceid = device.deviceid")
print query
defer = dbpool.runQuery(query)
defer.addCallback(servicesCallback)
def render_GET(self, request):
def queryCallback(l):
request.write("<html>")
request.write(title_string)
request.write("Service %s<br>\r\n" % self.sname)
for (sname, stype, deviceid, ipaddr, port, status) in l:
request.write('Service %s on device %s (%s:%s:%s) status is %s<br>\r\n'
% (sname, deviceid, stype, ipaddr, port, status) )
request.write("</html>")
request.finish()
query = ("select sname, stype, service.deviceid, ipaddr, port, status from service, device where service.deviceid = device.deviceid and sname='%s'" % self.sname)
print query
defer = dbpool.runQuery(query)
defer.addCallback(queryCallback)
return server.NOT_DONE_YET
def render_GET(self, request):
def queryCallback(l):
p = string.join([ 'PID: ' + renderPatientID(pid) + ' Name: ' + name for (pid, name) in l], "<br>")
request.write( "<html>")
request.write(title_string)
request.write("Patients:<br>")
request.write(p)
request.write('<p><a href="/patients/add">Add patient</a>')
request.write("</html>")
request.finish()
query = ("select patientid, name from patient")
print query
defer = dbpool.runQuery(query)
defer.addCallback(queryCallback)
return server.NOT_DONE_YET
def render_GET(self, request):
def queryCallback(l):
print l
request.write("<html>")
request.write(title_string)
request.write("Device %s<br>" % (self.name))
p = string.join([ 'DID: %s Type: %s Address: %s <br>' % (renderDeviceID(did), dtype, ipaddr)
for (did, dtype, ipaddr) in l], "\r\n")
request.write(p)
request.write('</html>\r\n')
request.finish()
query = ("select deviceid, dtype, ipaddr from device where deviceid='%s'" % self.name)
print query
defer = dbpool.runQuery(query)
defer.addCallback(queryCallback)
return server.NOT_DONE_YET
def runQueryServiceRequest(self):
result_columns = ('sname', 'stype', 'ipaddr', 'port', 'service.status')
result_headers = ('SVN', 'SVT', 'IP', 'Port', 'Status')
def queryServiceCallback(l):
for res in l:
response = string.join([ '%s: %s\r\n' % (hn, cv) for (hn, cv) in zip(result_headers, res) ], '')
print 'queryServiceCallback response=', response
port.write('200 OK\r\n' + response, self.addr)
return
query = 'select %s from service, device where service.deviceid=device.deviceid ' % string.join(result_columns, ',')
for (hn, cn) in (('svn', 'sname'), ('svt', 'stype'), ('did', 'deviceid'), ('pid', 'patientid')):
if self.headers.has_key(hn) and self.headers[hn] != '*':
query = query + ('and %s = "%s" ' % (cn, self.headers[hn]))
print query
defer = dbpool.runQuery(query)
defer.addCallback(queryServiceCallback)
def render_GET(self, request):
def queryCallback(l):
print l
request.write("<html><head><META HTTP-EQUIV=Refresh CONTENT=\"10; URL=/devices/\"></head>")
request.write(title_string)
request.write("<body>Devices:<br>")
for (did, dtype, ipaddr) in l:
request.write( 'DID: <a %(rdid)s Type: %(dtype)s Address: %(ipaddr)s <br>'
% { 'rdid': renderDeviceID(did), 'dtype': dtype, 'ipaddr': ipaddr} )
request.write('\r\n</html>\r\n')
request.finish()
query = ("select deviceid, dtype, ipaddr from device")
print query
defer = dbpool.runQuery(query)
defer.addCallback(queryCallback)
return server.NOT_DONE_YET
def service_handle_request(self):
""" entrypoint for GET requests to native autosuggest api """
# init an instance of input parser to extract GET input data
ip = ioparseformat.InputParser()
# extract get info
idict = ip.parseUnstructuredGetData(self.request) #
urid = idict.get('id')
ranked = idict.get('ranked')
checked = idict.get('checked')
# get the accessor object for this service
ac = registry_accessor.RegistryAccessor()
# call autosuggest method of accessor - this returns a tuple: a defered and a string!
defer = ac.get_presentationInfo(urid=urid,ranked=ranked,checked=checked)
# add callback to do the output when finishing
defer.addCallback(self.output_callback)
def runRegisterServiceAttributesRequest(self):
deviceid = self.headers['did']
sname = self.headers['svn']
port = self.headers['svp']
stype = self.headers['svt']
status = self.headers['status']
expires = self.headers['expires']
begin_query = 'update service set '
end_query = " where deviceid='%s' and port=%d'" % (deviceid, port)
updates = []
for k, v in [('sname', sname), ('stype', stype), ('status', status)]:
if v:
updates.append( "%s='%s'" % (k, v))
query = begin_query + string.join(updates, ', ') + end_query
print query
defer = dbpool.runQuery(query)
defer.addCallback(self.dbCallback)
def render_GET(self, request):
def queryCallback(l):
request.write("<html>")
request.write(title_string)
request.write("Services:<br>")
for (sname, stype, deviceid, ipaddr, port, status) in l:
dict = { 'sname': sname, 'deviceid': deviceid, 'stype': stype,
'ipaddr': ipaddr, 'port': port, 'status': status }
request.write('Service <a href="/services/%(sname)s">%(sname)s</a>' % dict)
request.write('\t on device <a href="/devices/%(deviceid)s" (%(stype)s:%(ipaddr)s:%(port)s)' % dict)
request.write(' status is %(status)s<br>\r\n' % dict)
request.write("</html>")
request.finish()
query = ("select sname, stype, service.deviceid, ipaddr, port, status from service, device where service.deviceid = device.deviceid")
print query
defer = dbpool.runQuery(query)
defer.addCallback(queryCallback)
return server.NOT_DONE_YET
def service_handle_request(self):
""" entrypoint for GET requests to native autosuggest api """
# init an instance of input parser to extract GET input data
ip = ioparseformat.InputParser()
# extract get info
idict = ip.parseUnstructuredGetData(self.request) # this returns a flat dict of key-value pairs
term = idict.get('term') # this will return None if no such key
maxitems = idict.get('maxitems') # NOTE: accessor is not requested to honor the maxitems option!
ranked = idict.get('ranked') #if true, then results should be ranked according to their backlinks.
checked = idict.get('checked') # get the node filter
# get the accessor object for this service
ac = dbpedia_accessor.DbpediaAccessor()
# call autosuggest method of accessor - this returns a tuple: a defered and a string!
defer = ac.get_suggestions(term=term,maxitems=maxitems,ranked=ranked,checked=checked)
# add callback to do the output when finishing
defer.addCallback(self.output_callback)
def render_GET(self, request):
def patientsCallback(l):
request.write('<a href="/patients"><h2>Patients</h2></a><p></html>')
request.write('<ul>')
for (name, pid, did, dtype) in l:
request.write('<li> %s: %s' % (renderPatientID(pid), name))
if did:
request.write(' on %s device %s' % (dtype, renderDeviceID(did)))
request.write('</ul>')
request.write('</body>')
request.write('</html>')
request.finish()
def servicesCallback(l):
request.write('<a href="/services"><h2>Services</h2></a><p>')
request.write('<ul>')
for (did, sname, stype, ipaddr, port) in l:
request.write('<li> %s on %s (%s:%s:%s)' % (renderSType(sname), renderDeviceID(did), stype, ipaddr, port))
request.write('</ul>')
query = "select patient.name, patient.patientid, patientdevice.deviceid, dtype from patient left join patientdevice on patientdevice.patientid = patient.patientid left join device on patientdevice.deviceid = device.deviceid"
print query
defer = dbpool.runQuery(query)
defer.addCallback(patientsCallback)
def devicesCallback(l):
request.write('<html>')
request.write('<head><META HTTP-EQUIV=Refresh CONTENT=\"10; URL=/\">')
request.write('<body>')
request.write(title_string)
request.write('<a href="/devices"><h2>Devices</h2></a><p></html>')
request.write('<ul>')
for (did, dtype, ipaddr) in l:
request.write('<li> %s: (%s) at %s' % (renderDeviceID(did), dtype, ipaddr))
request.write('</ul>')
query = ("select device.deviceid, sname, stype, ipaddr, port from service, device where service.deviceid = device.deviceid")
print query
defer = dbpool.runQuery(query)
defer.addCallback(servicesCallback)
query = ("select deviceid, dtype, ipaddr from device")
print query
defer = dbpool.runQuery(query)
defer.addCallback(devicesCallback)
return server.NOT_DONE_YET
def service_handle_request(self):
""" entrypoint for GET requests to native autosuggest api """
# init an instance of input parser to extract GET input data
ip = ioparseformat.InputParser()
# extract get info
idict = ip.parseUnstructuredGetData(self.request) #
urid = idict.get('id')
ranked = idict.get('ranked')
checked = idict.get('checked')
# get the accessor object for this service
ac = registry_accessor.RegistryAccessor()
# call autosuggest method of accessor - this returns a tuple: a defered and a string!
defer = ac.get_presentationInfo(urid=urid,
ranked=ranked,
checked=checked)
# add callback to do the output when finishing
defer.addCallback(self.output_callback)
def render_GET(self, request):
def nprCallback(l):
print 'nprCallback', l
request.write("<html>")
request.write(title_string)
request.write("""<h1>New Patient</h1>
<form method="post" action="/patients/add">
<table>
<tr><td>Patient Name<td><input type="text" name="pname"></input></tr>
<tr><td>Patient ID<td><input type="text" name="pid"></input></tr>
</table>
<input type="submit" name="Add">
</form>
""")
request.finish()
query = 'select deviceid from device'
print query
defer = dbpool.runQuery(query)
defer.addCallback(nprCallback)
return server.NOT_DONE_YET
def main():
# Blackboard
bb = btree.BlackBoard()
# Start benchmark ###################################
start = btree.Sequence(bb)
start.add(ConnectRelay())
if START_BT: start.add(AllocateDomains())
start.add(ConfigureGlassfish())
pl = btree.ParallelNode()
start.add(pl)
pl.add(StartGlassfish())
if INIT_DB: pl.add(StartDatabase())
start.add(StartRain())
start.add(ConnectRain())
start.add(TriggerRain())
start.add(startController())
# Stop benchmark ####################################
stop = btree.Sequence(bb)
stop.add(ConnectRelay())
stop.add(StopGlassfishRain())
# Execute Behavior Trees ############################
if START_BT:
print 'Running start bt'
defer = start.execute()
else:
print 'Running stop bt'
defer = stop.execute()
# Finished callback to clean up
defer.addCallback(finished)
# Start the Twisted reactor
reactor.run()
def sentIcqMessage(self, user, message):
defer = self.sendMessage(user, message=message, wantAck=1, offline=1)
defer.addCallback(self.onMessageSent)
return defer
def updateDevice():
query = "replace into device (deviceid, dtype, ipaddr) values ('%s', '%s', '%s')" % (deviceid, dtype, ipaddr)
if verbose: print 'updateDevice: ', query
defer = dbpool.runQuery(query)
defer.addCallback(self.nullCallback)
def main():
logger.log(sonarlog.SYNC, 'starting BTree')
# Blackboard with hosts manager
bb = btree.BlackBoard()
bb.hosts = hosts.RelayHosts()
# Use the domain setup type configuration in the domains module to fill hosts
for entry in conf_domains.initial_domains_setup_types:
bb.hosts.add_host(*entry)
# Add load drivers to hosts
bb.hosts.add_host('load0', 'load')
bb.hosts.add_host('load1', 'load')
# Start benchmark ###################################
start = btree.Sequence(bb)
# Log sync marker
start.add(behaviors.SyncMarker('start of startup sequence'))
# Stop everything
start.add(behaviors.ShutdownAllDomains())
# Add bheaviors to start and initialize the domains
start.add(behaviors.AllocateDomains(controller))
# Connect with all relay services
start.add(behaviors.ConnectRelay())
# Configure glassfish
start.add(behaviors.ConfigureGlassfish())
# Start Glassfish and Database
pl = btree.ParallelNode(bb)
pl.add(behaviors.StartGlassfish())
pl.add(behaviors.StartDatabase())
start.add(pl)
# Start Rain and connect with its control service
start.add(behaviors.StartRain())
start.add(behaviors.ConnectRain())
# Start controller
start.add(behaviors.StartController(controller))
# Trigger load generation in Rain
start.add(behaviors.TriggerRain())
# Stop benchmark ####################################
stop = btree.Sequence(bb)
stop.add(behaviors.ConnectRelay())
stop.add(behaviors.StopGlassfishRain())
# Execute Behavior Trees ############################
if START_BT:
print 'Running start BTree'
defer = start.execute()
else:
print 'Running stop BTree'
defer = stop.execute()
# Finished callback to clean up
defer.addCallback(finished)
# Start the Twisted reactor
reactor.run()
