def start(self):
"""This method fires up the daemon server based on initialized parameters of the class"""
# initialize the server instance with given resources
try:
print("Firing up TRex REST daemon @ port {trex_port} ...\n".format(
trex_port=self.trex_daemon_port))
logger.info(
"Firing up TRex REST daemon @ port {trex_port} ...".format(
trex_port=self.trex_daemon_port))
logger.info("current working dir is: {0}".format(self.TREX_PATH))
logger.info("current files dir is : {0}".format(
self.trex_files_path))
logger.debug(
"Starting TRex server. Registering methods to process.")
logger.info(self.get_trex_version(base64=False))
self.server = SimpleJSONRPCServer(
(self.trex_host, self.trex_daemon_port))
except socket.error as e:
if e.errno == errno.EADDRINUSE:
logger.error(
"TRex server requested address already in use. Aborting server launching."
)
print(
"TRex server requested address already in use. Aborting server launching."
)
raise socket.error(
errno.EADDRINUSE,
"TRex daemon requested address already in use. "
"Server launch aborted. Please make sure no other process is "
"using the desired server properties.")
elif isinstance(e, socket.gaierror) and e.errno == -3:
# handling Temporary failure in name resolution exception
raise socket.gaierror(
-3, "Temporary failure in name resolution.\n"
"Make sure provided hostname has DNS resolving.")
else:
raise
# set further functionality and peripherals to server instance
self.server.register_function(self.add)
self.server.register_function(self.get_devices_info)
self.server.register_function(self.cancel_reservation)
self.server.register_function(self.connectivity_check)
self.server.register_function(self.connectivity_check,
'check_connectivity') # alias
self.server.register_function(self.force_trex_kill)
self.server.register_function(self.get_file)
self.server.register_function(self.get_files_list)
self.server.register_function(self.get_files_path)
self.server.register_function(self.get_latest_dump)
self.server.register_function(self.get_running_info)
self.server.register_function(self.get_running_status)
self.server.register_function(self.get_trex_cmds)
self.server.register_function(self.get_trex_config)
self.server.register_function(self.get_trex_config_metadata)
self.server.register_function(self.get_trex_daemon_log)
self.server.register_function(self.get_trex_log)
self.server.register_function(self.get_trex_version)
self.server.register_function(self.is_reserved)
self.server.register_function(self.is_running)
self.server.register_function(self.kill_all_trexes)
self.server.register_function(self.push_file)
self.server.register_function(self.reserve_trex)
self.server.register_function(self.start_trex)
self.server.register_function(self.stop_trex)
self.server.register_function(self.wait_until_kickoff_finish)
signal.signal(signal.SIGTSTP, self.stop_handler)
signal.signal(signal.SIGTERM, self.stop_handler)
try:
self.zmq_monitor.start()
self.server.serve_forever()
except KeyboardInterrupt:
logger.info("Daemon shutdown request detected.")
finally:
self.zmq_monitor.join() # close ZMQ monitor thread resources
self.server.shutdown()
def server_thread(conn):
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
server = SimpleJSONRPCServer((my_host, my_port))
server.register_function(process_request, 'request')
server.register_function(do_stop, 'stop')
server.serve_forever()
'result-text':
''.join(re.escape(similar[i][-1]).split('\\')).replace(
'\n', '<br>').replace('\t', ' '),
'result-image':
"asd",
'result-doc-link':
'google.com',
'result-doc-name':
similar[i][1],
'result-modified-date':
'01-2-2019',
'result-id':
"123"
}))
#print(gg)
gg = pgk + gg
return gg
"""
def resolveQuery(query):
gg = list()
for i in range(0, 1):
gg.append(dict({'result-text':"This Works", 'result-image':"asd", 'result-doc-link':'google.com', 'result-doc-name':123, 'result-modified-date':'01-2-2019', 'result-id':"123"}))
return gg
"""
server = SimpleJSONRPCServer(('localhost', 1006))
server.register_function(resolveQuery)
print("Start server")
server.serve_forever()
SERVER_HOST = 'localhost'
SERVER_PORT = 4040
def add(num1, num2):
"""Test method"""
print("Add is called with %d and %d" % (num1, num2))
return num1 + num2
def get_one_news():
"""Get one news"""
print("getOneNews is called")
return operations.getOneNews()
def get_news_summaries_for_user(user_id, page_num):
print("get_news_summaries_for_user is called with %s and %s" % (user_id, page_num))
return operations.getNewsSummariesForUser(user_id, page_num)
def log_news_click_for_user(user_id, news_id):
print("log_news_click_for_user is called with %s and %s" % (user_id, news_id))
operations.logNewsClickForUser(user_id, news_id)
RPC_SERVER = SimpleJSONRPCServer((SERVER_HOST, SERVER_PORT))
RPC_SERVER.register_function(add, 'add')
RPC_SERVER.register_function(get_one_news, 'getOneNews')
RPC_SERVER.register_function(get_news_summaries_for_user, 'getNewsSummariesForUser')
RPC_SERVER.register_function(log_news_click_for_user, 'logNewsClickForUser')
print("Starting RPC server on %s:%d" % (SERVER_HOST, SERVER_PORT))
RPC_SERVER.serve_forever()
"""
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
parser = optparse.OptionParser(usage="%prog [OPTIONS]")
parser.add_option('-p', '--port', default='8080',
help='Port to serve on (default 8080)')
parser.add_option('-H', '--host', default='127.0.0.1',
help='Host to serve on (default localhost; 0.0.0.0 to make public)')
parser.add_option('-q', '--quiet', action='store_false', default=True, dest='verbose',
help="Quiet mode, don't print status msgs to stdout")
parser.add_option('-S', '--corenlp', default=DIRECTORY,
help='Stanford CoreNLP tool directory (default %s)' % DIRECTORY)
parser.add_option('-P', '--properties', default='default.properties',
help='Stanford CoreNLP properties fieles (default: default.properties)')
options, args = parser.parse_args()
VERBOSE = options.verbose
# server = jsonrpc.Server(jsonrpc.JsonRpc20(),
# jsonrpc.TransportTcpIp(addr=(options.host, int(options.port))))
try:
server = SimpleJSONRPCServer((options.host, int(options.port)))
nlp = StanfordCoreNLP(options.corenlp, properties=options.properties, serving=True)
server.register_function(nlp.parse)
server.register_function(nlp.raw_parse)
print 'Serving on http://%s:%s' % (options.host, options.port)
# server.serve()
server.serve_forever()
except KeyboardInterrupt:
print >>sys.stderr, "Bye."
exit()
def daemon(self, config):
network = self.network
devices = self.devices
workers = {}
def _classify(params):
ret = { }
output_dim = {}
hash = hashlib.new('ripemd160')
hash.update(json.dumps(params))
hash = hash.hexdigest()
for k in params:
try:
params[k] = numpy.asarray(params[k], dtype='float32')
if k != 'data':
output_dim[k] = network.n_out[k] # = [network.n_in,2] if k == 'data' else network.n_out[k]
except Exception:
if k != 'data' and not k in network.n_out:
ret['error'] = 'unknown target: %s' % k
else:
ret['error'] = 'unable to convert %s to an array from value %s' % (k,str(params[k]))
break
if not 'error' in ret:
data = StaticDataset(data=[params], output_dim=output_dim)
data.init_seq_order()
try:
data = StaticDataset(data=[params], output_dim=output_dim)
data.init_seq_order()
except Exception:
ret['error'] = "invalid data: %s" % params
else:
batches = data.generate_batches(recurrent_net=network.recurrent,
batch_size=sys.maxsize, max_seqs=1)
if not hash in workers:
workers[hash] = ClassificationTaskThread(network, devices, data, batches)
workers[hash].json_params = params
print("worker started:", hash, file=log.v3)
ret['result'] = { 'hash' : hash }
return ret
def _backprob(params):
ret = {}
def _result(hash):
if not workers[hash].isAlive():
return { 'result' : { k : workers[hash].result[k].tolist() for k in workers[hash].result } }
else:
return { 'error' : "working ..."}
class RequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_POST(self):
if len(self.path) == 0:
self.send_response(404)
return
self.path = self.path[1:]
ret = {}
if self.path in ['classify']:
ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))
if ctype == 'application/json':
length = int(self.headers.getheader('content-length'))
params = cgi.parse_qs(self.rfile.read(length),keep_blank_values=1)
try:
content = params.keys()[0].decode('utf-8') # this is weird
params = json.loads(content)
except Exception:
ret['error'] = 'unable to decode object'
else:
ret.update(_classify(params))
else:
ret['error'] = 'invalid header: %s' % ctype
else:
ret['error'] = 'invalid command: %s' % self.path
self.send_response(200)
self.send_header('Content-Type', 'application/json')
self.wfile.write("\n")
self.wfile.write(json.dumps(ret))
self.end_headers()
def do_GET(self):
if len(self.path.replace('/', '')) == 0:
self.send_response(200)
else:
if len(self.path) == 0:
self.send_response(404)
return
ret = { 'error' : "" }
self.path = self.path[1:].split('/')
if self.path[0] in ['result']:
if self.path[1] in workers:
if not workers[self.path[1]].isAlive():
ret['result'] = { k : workers[self.path[1]].result[k] for k in workers[self.path[1]].result }
else:
ret['error'] = "working ..."
else:
ret['error'] = "unknown hash: " % self.path[1]
else:
ret['error'] = "invalid command: %s" % self.path[0]
self.send_response(200)
self.send_header('Content-Type', 'application/json')
self.wfile.write("\n")
self.wfile.write(json.dumps(ret))
self.end_headers()
def log_message(self, format, *args): pass
class ThreadingServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
pass
port = config.int('daemon.port', 3333)
httpd = ThreadingServer(("", port), RequestHandler)
print("httpd listening on port", port, file=log.v3)
try:
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer # https://pypi.python.org/pypi/jsonrpclib/0.1.6
except Exception:
httpd.serve_forever()
else:
from thread import start_new_thread
start_new_thread(httpd.serve_forever, ())
server = SimpleJSONRPCServer(('0.0.0.0', port+1))
server.register_function(_classify, 'classify')
server.register_function(_result, 'result')
server.register_function(_backprob, 'backprob')
print("json-rpc listening on port", port+1, file=log.v3)
server.serve_forever()
sys.exit(1)
# create watching_only wallet
storage = electrum.WalletStorage(c)
if not storage.file_exists:
print "creating wallet file"
wallet = electrum.wallet.Wallet.from_xpub(xpub, storage)
else:
wallet = electrum.wallet.Wallet(storage)
wallet.synchronize = lambda: None # prevent address creation by the wallet
wallet.start_threads(network)
network.register_callback('updated', on_wallet_update)
threading.Thread(target=db_thread, args=()).start()
out_queue = Queue.Queue()
# server thread
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
server = SimpleJSONRPCServer((my_host, my_port))
server.register_function(process_request, 'request')
server.register_function(do_dump, 'dump')
server.register_function(getrequest, 'getrequest')
server.register_function(do_stop, 'stop')
server.socket.settimeout(1)
while not stopping:
try:
server.handle_request()
except socket.timeout:
continue
def main():
server = SimpleJSONRPCServer(('localhost', 7002))
server.register_function(length)
print("Starting server")
server.serve_forever()
def vlan_name(self, x):
vlan_id = self.state[-1]['vlan']['vlan_id']
name = str(x[0])
return vlan_id, name
def bgp_addr_fam_v4_unicast(self, x):
return {'af_name':'ipv4', 'saf_name':'unicast', 'vrf_name':'default'}
def bgp_neigh(self, x):
if len(x) == 3:
return (str(x[0]), {'remote as':int(x[2])})
return (str(x[0]), {})
def run_cmd(x):
print "\n\n___________________"
print "New command: %s" % x
tranz = LenovoJSONRPCServer()
resp = []
for cmd in x:
resp.append(tranz.exec_cmd(cmd))
return resp
server = SimpleJSONRPCServer(('0.0.0.0', 8080))
server.register_function(pow)
server.register_function(run_cmd, 'runCmds')
server.serve_forever()
def size():
return whole_network.size()
def neighbors(node):
return whole_network.neighbors(node)
whole_network = network()
# synthetic dataset
whole_network.add_nodes(range(1, 36001))
coauthor_file = open(
"dataset/binary_networks/network_N36000_k8_maxk12_mu0.3.dat", 'rb')
for line in coauthor_file:
elements = line.split('\t')
if int(elements[0]) < int(elements[1]):
whole_network.add_edge((int(elements[0]), int(elements[1])))
coauthor_file.close()
print "synthetic data loaded!"
server = SimpleJSONRPCServer(("127.0.0.1", 9000))
server.register_function(nodes)
server.register_function(size)
server.register_function(neighbors)
try:
print "Start working"
server.serve_forever()
except KeyboardInterrupt:
pass
def server():
serverRPC = SimpleJSONRPCServer(('localhost', 7002))
serverRPC.register_function(print_name)
print("Starting server")
serverRPC.serve_forever()
