class RequestHandler(pyjsonrpc.HttpRequestHandler):
""" RPC request handler """
@pyjsonrpc.rpcmethod
def add(self, num1, num2): # pylint: disable=no-self-use
""" Test method """
print "add is called with %d and %d" % (num1, num2)
return num1 + num2
""" Get news summaries for a user """
@pyjsonrpc.rpcmethod
def getNewsSummariesForUser(self, user_id, page_num):
return operations.getNewsSummariesForUser(user_id, page_num)
""" Log user news clicks """
@pyjsonrpc.rpcmethod
def logNewsClickForUser(self, user_id, news_id):
return operations.logNewsClickForUser(user_id, news_id)
# Threading HTTP Server
HTTP_SERVER = pyjsonrpc.ThreadingHttpServer(server_address=(SERVER_HOST,
SERVER_PORT),
RequestHandlerClass=RequestHandler)
print "Starting HTTP server on %s:%d" % (SERVER_HOST, SERVER_PORT)
HTTP_SERVER.serve_forever()
@pyjsonrpc.rpcmethod
def introns(self, name):
if not h.has_key(name):
return []
retv = []
r = h[name]
for i in r.Introns():
if i.stop - i.start > 60:
j = i.tail(60)
v = [Tools.translate_coordinate(j, d) for d in DataS3.query(j)]
retv.append({
"chr": j.chr,
"id": j.id,
"start": j.start,
"end": j.end,
"strand": j.strand,
"v": v
})
return retv
@pyjsonrpc.rpcmethod
def list(self):
return genelist
http_server = pyjsonrpc.ThreadingHttpServer(server_address=('localhost', 7000),
RequestHandlerClass=RequestHandler)
print("Starting HTTP server ...")
print("URL: http://localhost:7000")
http_server.serve_forever()
# set up classifier model
loadVocabAndModel()
class RequestHandler(pyjsonrpc.HttpRequestHandler):
@pyjsonrpc.rpcmethod
def classify(self, text):
# first predict via corpus
prediction = classDetect(text)
# if can't predict, use machine learning method
if prediction == '0':
text_series = pd.Series([text])
vocabTransformation = np.array(
list(vocab_processor.transform(text_series)))
prediction = classifier.predict(vocabTransformation)
prediction = str(prediction['classes'][0])
prediction = newsClasses[prediction]
return prediction
# Threading HTTP-Server
http_server = pyjsonrpc.ThreadingHttpServer(
server_address=(NEWS_CLASSIFIER_SERVER['HOST'],
NEWS_CLASSIFIER_SERVER['PORT']),
RequestHandlerClass=RequestHandler)
print "Starting HTTP server ..."
print "URL: http://%s:%d" % (NEWS_CLASSIFIER_SERVER['HOST'],
NEWS_CLASSIFIER_SERVER['PORT'])
http_server.serve_forever()
def returntransfers(self):
conn = sqlite3.connect(database)
c = conn.cursor()
c.execute('SELECT * FROM transfers')
results = c.fetchall()
print "printing transfers"
print '\nindividual records'
for result in results:
print result
return results
http_server = pyjsonrpc.ThreadingHttpServer(
server_address = ('10.0.3.112', 5050),
#server_address = ('192.168.1.7', 5050),
RequestHandlerClass = RequestHandler
)
print "resetting database"
resetDatabase()
print "Starting HTTP server ..."
print "URL: http://10.0.3.112:5050"
#print "URL: 192.168.1.7:5050"
try:
http_server.serve_forever()
except KeyboardInterrupt:
http_server.shutdown()
print "Stopping HTTP Server"
bundle_path = base_path + container + "/bundle/"
with pushd(bundle_path):
run_cmd_timed(
"gnome-terminal -- /usr/local/sbin/runc restore --image-path checkpoint --work-path checkpoint %s"
% container)
return retvar
@pyjsonrpc.rpcmethod
def lazy_restore(self, client_ip, container):
print "> lazy-restore: %s from %s" % (container, client_ip)
bundle_path = base_path + container + "/bundle/"
with pushd(bundle_path):
run_cmd_timed(
"gnome-terminal -- /usr/local/sbin/runc restore --image-path checkpoint --work-path checkpoint --lazy-pages %s"
% container)
run_cmd_timed(
"criu lazy-pages --page-server --address %s --port 27000 -vv -D checkpoint -W checkpoint"
% client_ip)
return retvar
if __name__ == "__main__":
svr = pyjsonrpc.ThreadingHttpServer(
# server_address = ('0.0.0.0', 9000), RequestHandlerClass = MigrateService)
server_address=('0.0.0.0', 9000),
RequestHandlerClass=CloudMigrateService)
print "- start migrate server..."
print "- note: the cloud version should run under TMUX"
svr.serve_forever()
@pyjsonrpc.rpcmethod
def files_ls(self, user_container_name, dir, recursive=False):
check_containername(user_container_name, 'user_container_name')
check_pathname(dir, 'dir')
container = data_container_name(user_container_name)
file = absolute_userpath(dir)
return filemanager.listfiles(container, file, recursive)
def handler(signum, frame):
sys.exit(0)
signal.signal(signal.SIGTERM, handler)
signal.signal(signal.SIGINT, handler)
dockermanager = DockerManager()
filemanager = FileManager()
sysout("Starting watchdog")
timeout = TimeoutManager(5, dockermanager.stop_container)
timeout.start()
http_server = pyjsonrpc.ThreadingHttpServer(server_address=('0.0.0.0', 5001),
RequestHandlerClass=DockerBridge)
sysout("Starting JSONRPC")
http_server.serve_forever()
class RequestHandler(pyjsonrpc.HttpRequestHandler):
@pyjsonrpc.rpcmethod
def createWallet(self):
"""Create a random key and a address for
user
"""
wt = wallet.Wallet()
wt.createWallet()
result = json.dumps({'address': wt.address, 'priv': wt.priv})
return result
PORT = 8778
DOMAIN = 'localhost'
# Threading HTTP-Server
http_server = pyjsonrpc.ThreadingHttpServer(
server_address=(DOMAIN, PORT),
RequestHandlerClass=RequestHandler
)
print "Starting HTTP server ..."
print "URL: http://{}:{}".format(DOMAIN, PORT)
http_server.serve_forever()
self.rpcserwer.register_function(self.ster)
self.rpcserwer.register_function(self.podl)
self.rpcserwer.register_function(self.temp)
self.rpcserwer.register_function(self.stat)
self.rpcserwer.register_function(self.nagl)'''
a = THutils.odczytaj_parametr_konfiguracji(
constants.OBSZAR_KONFIGURACJI_OGOLNE, 'wysylanie_firebase')
if a in ['True', 'true', 'TRUE']:
firebase_mozna_wysylac = True
else:
import naglosnienie
wewy = wejsciawyjscia.WejsciaWyjscia(wyjscia=True)
#mcp_wyjscie1 = Adafruit_MCP230xx.Adafruit_MCP230XX(address=0x20, num_gpios=16)
naglosnienie = naglosnienie.Naglosnienie(wewy)
'''self.rpcserwer.register_function(self.nagl)
self.rpcserwer.register_function(self.stat)'''
try:
'''self.rpcserwer.serve_forever()
'''
API_KEY = os.getenv(constants.APIKEY)
http_server = pyjsonrpc.ThreadingHttpServer(
server_address=(moje_ip, int(os.getenv(constants.PORT_SERWERA_V2))),
RequestHandlerClass=RequestHandlerDlaJSONRPC)
print "Starting HTTP server ..."
http_server.serve_forever()
except:
e = sys.exc_info()[0]
logger.warning('Nieobslugiwany blad servera: ' + str(e))
#!/usr/bin/env python
# coding: utf-8
# pip install python-jsonrpc
import pyjsonrpc
from time import sleep
class RequestHandler(pyjsonrpc.HttpRequestHandler):
@pyjsonrpc.rpcmethod
def add(self, a, b):
return a + b
# Threading HTTP-Server
http_server = pyjsonrpc.ThreadingHttpServer(server_address=('127.0.0.1', 2725),
RequestHandlerClass=RequestHandler)
print "Starting HTTP server ..."
print "URL: http://140.143.232.165:34222"
http_server.serve_forever()
sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'common'))
import mongodb_client
SERVICE_HOST = 'localhost'
SERVICE_PORT = 4040
class RequestHandler(pyjsonrpc.HttpRequestHandler):
"""Test Methos"""
@pyjsonrpc.rpcmethod
def add(self, a, b):
print "add is called with %d and %d" % (a, b)
return a + b
@pyjsonrpc.rpcmethod
def getNewsSummariesForUser(self, user_id, page_num):
return operations.getNewsSummariesForUser(user_id, page_num)
@pyjsonrpc.rpcmethod
def logNewsClickForUser(self, user_id, news_id):
return operations.logNewsClickForUser(user_id, news_id)
http_server = pyjsonrpc.ThreadingHttpServer(server_address=(SERVICE_HOST,
SERVICE_PORT),
RequestHandlerClass=RequestHandler)
print "Starting HTTp server on %s:%d" % (SERVICE_HOST, SERVICE_PORT)
http_server.serve_forever()
