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()