예제 #1
0
def LoadAndServe(host, port):
    server = SimpleJSONRPCServer((host, port))

    for func in API:
        server.register_function(func.values()[0], func.keys()[0])

    server.serve_forever()
예제 #2
0
파일: jsonrpc.py 프로젝트: asfin/electrum
    def __init__(self, *args, rpc_user, rpc_password, **kargs):

        self.rpc_user = rpc_user
        self.rpc_password = rpc_password

        class VerifyingRequestHandler(SimpleJSONRPCRequestHandler):
            def parse_request(myself):
                # first, call the original implementation which returns
                # True if all OK so far
                if SimpleJSONRPCRequestHandler.parse_request(myself):
                    # Do not authenticate OPTIONS-requests
                    if myself.command.strip() == 'OPTIONS':
                        return True
                    try:
                        self.authenticate(myself.headers)
                        return True
                    except (RPCAuthCredentialsInvalid, RPCAuthCredentialsMissing,
                            RPCAuthUnsupportedType) as e:
                        myself.send_error(401, str(e))
                    except BaseException as e:
                        import traceback, sys
                        traceback.print_exc(file=sys.stderr)
                        myself.send_error(500, str(e))
                return False

        SimpleJSONRPCServer.__init__(
            self, requestHandler=VerifyingRequestHandler, *args, **kargs)
예제 #3
0
def start_sim_index_server(port,
                           backends=(),
                           remote_urls=(),
                           root=True,
                           logRequests=True):

    server = SimpleRPCServer(('localhost', port),
                             logRequests=logRequests,
                             requestHandler=RequestHandler)
    
    backend_list = list(backends)
    if remote_urls:
        backend_list.extend(
            [RemoteSimIndex(url) for url in remote_urls])

    if backend_list:
        if len(backend_list) == 1:
            index = ConcurrentSimIndex(backend_list[0])
        else:
            index = ConcurrentSimIndex(
                        SimIndexCollection(
                            shards=backend_list, root=root))
    else:
        index = ConcurrentSimIndex(MemorySimIndex())
        index.set_query_scorer('tfidf')

    server.register_instance(SimIndexService(index))

    try:
        print('Use Control-C to exit')
        server.serve_forever()
    except KeyboardInterrupt:
        print('Exiting')
예제 #4
0
파일: jsonrpc.py 프로젝트: GemHQ/electrum
class ElectrumGui:

    def __init__(self, config, network):
        self.network = network
        self.config = config
        storage = WalletStorage(self.config.get_wallet_path())
        if not storage.file_exists:
            raise BaseException("Wallet not found")
        self.wallet = Wallet(storage)
        self.cmd_runner = Commands(self.config, self.wallet, self.network)
        host = config.get('rpchost', 'localhost')
        port = config.get('rpcport', 7777)
        self.server = SimpleJSONRPCServer((host, port), requestHandler=RequestHandler)
        self.server.socket.settimeout(1)
        for cmdname in known_commands:
            self.server.register_function(getattr(self.cmd_runner, cmdname), cmdname)

    def main(self, url):
        self.wallet.start_threads(self.network)
        while True:
            try:
                self.server.handle_request()
            except socket.timeout:
                continue
            except:
                break
        self.wallet.stop_threads()
예제 #5
0
    def __init__(self, addr, requestHandler=SimpleJSONRPCRequestHandler,
                 logRequests=True, encoding=None, bind_and_activate=True,
                 address_family=socket.AF_INET, auth_map=None):

        self.auth_map = auth_map
        SimpleJSONRPCServer.__init__(self, addr, requestHandler, logRequests,
                                     encoding, bind_and_activate, address_family)
예제 #6
0
    def _dispatch(self, method, params):
        """
        Dispatch RVI 'message'.
        Check if method is 'message', if so dispatch on
        name 'service_name' instead.
        """
        # print "dispatch:", params
        if method == 'message':
            # print "Will dispatch message to: " + params['service_name']
            dict_param = {}
            # Extract the 'parameters' element from the top level JSON-RPC
            # 'param'. 
            # Convert 'parameters' from [{'vin': 1234}, {hello: 'world'}] to
            # a regular dictionary: {'vin': 1234, hello: 'world'}

            #print "Service:", params['service_name']
            #print "Parameters:", params['parameters']
            msg_params = params['parameters']
            for i in range(0, len(msg_params)):
                for j in range(0, len(msg_params[i].keys())):
                    #print "params", msg_params[i].keys()[j], "=", msg_params[i].values()[j]
                    dict_param[msg_params[i].keys()[j]] = msg_params[i].values()[j]

            # print "Parameter dictionary: ", dict_param
            # print 
            # Ship the processed dispatch info upward.
            return SimpleJSONRPCServer._dispatch(self, params['service_name'], dict_param)           
        return SimpleJSONRPCServer._dispatch(self,message, params)
예제 #7
0
파일: command.py 프로젝트: podhmo/diagrpc
def _main(args):
    server = SimpleJSONRPCServer((args.host, args.port))
    functions = [f for f in args.functions if f in FUNCTION_TABLE]

    _message(functions, args.port)

    for f in functions:
        server.register_function(FUNCTION_TABLE[f])
    server.serve_forever()
예제 #8
0
def server_thread(conn):
    from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
    server = SimpleJSONRPCServer(( my_host, my_port))
    server.register_function(process_request, 'request')
    server.register_function(get_mpk, 'mpk')
    server.register_function(do_stop, 'stop')
    server.serve_forever()
예제 #9
0
 def __init__(self, name, port, cache_size = 100):
   self.name = name
   self.cache = []
   self.cache_size = cache_size
   self.counter = 0
   from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer  # https://pypi.python.org/pypi/jsonrpclib/0.1.6
   server = SimpleJSONRPCServer(('0.0.0.0', port))
   server.register_function(self.count, 'count')
   server.register_function(self.data, 'data')
   print >> log.v3, "json-rpc streaming on port", port
   start_new_thread(server.serve_forever,())
예제 #10
0
def server_thread():

    from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer

    host = "127.0.0.1"
    port = int(serverPort)
    #http://user:[email protected]:12345
    server = SimpleJSONRPCServer((host, port), requestHandler=SleuthSimpleJSONRPCRequestHandler, logRequests=True)
    server.register_function(handleRequest, 'sendPost')

    server.serve_forever()
예제 #11
0
    def __init__(self, rvi_node_url, address='localhost', port=(20001,59999)):
        if isinstance(port, tuple) == True:
            (start_port, stop_port) = port
            self.rvi_port = random.randint(start_port, stop_port)
        else:
            self.rvi_port = port

        self.rvi_address = address
        SimpleJSONRPCServer.__init__(self,addr=((self.rvi_address, self.rvi_port)), logRequests=False)
        self.rvi_client = Server(rvi_node_url)
        self.serve_thread = False
        self.registered_services = dict()
예제 #12
0
 def server_thread():
     from SocketServer import ThreadingMixIn
     from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
     server = SimpleJSONRPCServer(( host, port), requestHandler=authHandler)
     server.register_function(get_new_address, 'getnewaddress')
     server.register_function(get_num, 'getnum')
     server.register_function(get_mpk, 'getkey')
     server.register_function(do_stop, 'stop')
     server.serve_forever()
예제 #13
0
def start_server():
    adb = ADB(ADB_PATH)
    funcs = extract_all_the_functions(adb, 'adb_')
    server = SimpleJSONRPCServer((RPC_HOST, RPC_PORT))
    print type(funcs)
    for name, func in funcs.iteritems():
        server.register_function(func)
    server.register_function(lambda x: x, 'ping')
    server.register_function(upload_apk)
    #server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.serve_forever()
예제 #14
0
파일: ghost.py 프로젝트: changyc/Overlord
 def StartRPCServer(self):
   logging.info('RPC Server: started')
   rpc_server = SimpleJSONRPCServer((_DEFAULT_BIND_ADDRESS, _GHOST_RPC_PORT),
                                    logRequests=False)
   rpc_server.register_function(self.Reconnect, 'Reconnect')
   rpc_server.register_function(self.GetStatus, 'GetStatus')
   rpc_server.register_function(self.RegisterTTY, 'RegisterTTY')
   rpc_server.register_function(self.RegisterSession, 'RegisterSession')
   rpc_server.register_function(self.AddToDownloadQueue, 'AddToDownloadQueue')
   t = threading.Thread(target=rpc_server.serve_forever)
   t.daemon = True
   t.start()
예제 #15
0
    def __init__(self):
        # Setup logging
        self._setupLogging()

        # Parse commandline
        self.parser = argparse.ArgumentParser(
            description="IPset JSON-RPC daemon",
            epilog="Config file is reloaded on SIGUSR1",
            formatter_class=argparse.ArgumentDefaultsHelpFormatter)
        self.parser.add_argument("--bind", default="127.0.0.1",
                                 help="the ip address to bind to")
        self.parser.add_argument("--port", type=int, default="9090",
                                 help="the port to listen on")
        self.parser.add_argument("--config", default="ipset.conf",
                                 help="config file to read ipset mapping from")
        self.args = self.parser.parse_args()

        # Init config
        self.config = configparser.ConfigParser()
        self._read_config()

        # Setup config reloading
        def reload(signal, frame):
            self._read_config()
        signal.signal(signal.SIGUSR1, reload)

        # Init server
        self.server = SimpleJSONRPCServer((self.args.bind, self.args.port))

        # Register handlers
        self._registerHandlers()
예제 #16
0
    def __init__(self, domain="0.0.0.0", port=5000):
        self._server = SimpleJSONRPCServer((domain, port))
        functions = {"run": self.run}

        for name in functions.keys():
            self._server.register_function(functions[name], name)
        self._pop = None
예제 #17
0
    def start(self):
        """This method fires up the daemon server based on initialized parameters of the class"""
        # initialize the server instance with given resources
        register_socket('trex_daemon_server')
        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.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_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_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()
예제 #18
0
파일: hwi.py 프로젝트: nickw444/Sprinkle
    def main(argv):
        from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
        gpio = GPIOInterface()
        gpio.configure_ports(port_numbers)

        hostname = '127.0.0.1'
        port = 8001
        if '-h' in sys.argv:
            hostname = sys.argv[sys.argv.index('-h') + 1]

        if '-p' in sys.argv:
            port = int(sys.argv[sys.argv.index('-p') + 1])

        s = SimpleJSONRPCServer((hostname, port))
        s.register_function(gpio.set_port)
        s.register_function(gpio.get_port)
        s.serve_forever()
예제 #19
0
 def __init__(self, data=None):
     self.server = SimpleJSONRPCServer(("localhost", 0), encoding="utf8", requestHandler=JSONRPCRequestHandler)
     self.rpc_port = self.server.socket.getsockname()[1]
     self.data = data
     self.server.register_function(self.get_plottable, "get_plottable")
     self.server.register_function(self.kill_server, "shutdown")
     webbrowser.open_new_tab("http://localhost:%d/sliceplot.html" % (self.rpc_port,))
     self.server.serve_forever()
def start_master_daemon_func():
    funcs_by_name = {}
    # master_daemon functions
    funcs_by_name['add'] = add
    funcs_by_name['check_connectivity'] = check_connectivity
    funcs_by_name['get_trex_path'] = get_trex_path
    funcs_by_name['update_trex'] = update_trex
    # trex_daemon_server
    funcs_by_name['is_trex_daemon_running'] = trex_daemon_server.is_running
    funcs_by_name['restart_trex_daemon'] = trex_daemon_server.restart
    funcs_by_name['start_trex_daemon'] = trex_daemon_server.start
    funcs_by_name['stop_trex_daemon'] = trex_daemon_server.stop
    # stl rpc proxy
    funcs_by_name['is_stl_rpc_proxy_running'] = stl_rpc_proxy.is_running
    funcs_by_name['restart_stl_rpc_proxy'] = stl_rpc_proxy.restart
    funcs_by_name['start_stl_rpc_proxy'] = stl_rpc_proxy.start
    funcs_by_name['stop_stl_rpc_proxy'] = stl_rpc_proxy.stop
    try:
        set_logger()
        register_socket(master_daemon.tag)
        server = SimpleJSONRPCServer(('0.0.0.0', master_daemon.port))
        logging.info('Started master daemon (port %s)' % master_daemon.port)
        for name, func in funcs_by_name.items():
            server.register_function(partial(log_usage, name, func), name)
        server.register_function(server.funcs.keys, 'get_methods') # should be last
        signal.signal(signal.SIGTSTP, stop_handler) # ctrl+z
        signal.signal(signal.SIGTERM, stop_handler) # kill
        server.serve_forever()
    except KeyboardInterrupt:
        logging.info('Ctrl+C')
    except Exception as e:
        logging.error('Closing due to error: %s' % e)
예제 #21
0
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()
예제 #22
0
파일: corenlp.py 프로젝트: edvisees/EDL2015
def main():
    """
    The code below starts an JSONRPC server
    """
    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()
예제 #23
0
    def __init__(self, hostname='localhost', port=8080):
        global methods

        self._methods = methods
        self.server = SimpleJSONRPCServer((hostname, port), logRequests=False)
        self.server.register_introspection_functions()
        for method in self._methods:
            self.server.register_function(eval('self.{}'.format(method)))
        self.processes = {}
예제 #24
0
class JSONRPCServer(SingletonClass):
    
    def __initialize__(self, context_root='/', server_port=8181):
        
        SimpleJSONRPCRequestHandler.log_request = log_request
        SimpleJSONRPCRequestHandler.rpc_paths = (context_root)
        self.server = SimpleJSONRPCServer(('', server_port))
        
    def registerService(self, serviceName, function):
        self.server.register_function(function, name=serviceName)
        
    def start(self):
        self.server_proc = Thread(target=self.server.serve_forever)
        self.server_proc.daemon = True
        self.server_proc.start()
    
    def stop(self):
        pass
예제 #25
0
def main():
    parser = optparse.OptionParser(usage="%prog [OPTIONS]")
    parser.add_option('-p', '--port', type="int", default=8080,
                      help="Port to bind to [8080]")
    parser.add_option('--path', default=DIRECTORY,
                      help="Path to OpenNLP install [%s]" % DIRECTORY)
    options, args = parser.parse_args()

    addr = ('localhost', options.port)
    uri = 'http://%s:%s' % addr

    server = SimpleJSONRPCServer(addr)

    print("Starting OpenNLP")
    nlp = OpenNLP(options.path)
    server.register_function(nlp.parse)

    print("Serving on %s" % uri)
    server.serve_forever()
예제 #26
0
파일: rvilib.py 프로젝트: mfeuer/rvi_core
    def _dispatch(self, method, params):
        if method == 'message':
            # print "Will dispatch message to: " + params['service_name']
            # dict_param = {}
            # Extract the 'parameters' element from the top level JSON-RPC
            # 'param'. 
            # Convert 'parameters' from [{'vin': 1234}, {hello: 'world'}] to
            # a regular dictionary: {'vin': 1234, hello: 'world'}

            # print "Parameters:", params['parameters']

            # print "Parameter disctionary: ", dict_param
            # print 
            # Ship the processed dispatch info upward.
            return SimpleJSONRPCServer._dispatch(self, params['service_name'], params['parameters'])

        # Fallthrough to all other methods.
        # Will handle service_re3
        return SimpleJSONRPCServer._dispatch(self,method, params)           
예제 #27
0
class BackEndPool(Daemon):
    def __init__(self):
        self.backends = {}
        
    def run(self):
        self.server = SimpleJSONRPCServer(('localhost', 8473))
        
        self.server.register_function(self.spawn_backends, "spawn")
        self.server.register_function(self.kill_backends, "kill")
        self.server.serve_forever()
    
    def spawn_backends(self, backend):
        space = backend['space'] 
        model = backend['model']
        if space not in self.backends:
            self.backends[space] = {}
        if model not in self.backends[space]:
            self.backends[space][model] = []
        self.backends[space][model].append(BackEndProcess(backend))
        for be in self.backends[backend['space']][backend['model']]:
            be.start()
        
    def kill_backends(self, backend):
        for be in self.backends[backend['space']][backend['model']]:
            be.join()    
예제 #28
0
파일: gdfann_node.py 프로젝트: jeiks/gdfann
class GDFANN_Node:
    def __init__(self, domain='0.0.0.0', port=5000):
        self._server = SimpleJSONRPCServer( (domain, port) )
        functions = {
                     'run' : self.run
                    }

        for name in functions.keys():
            self._server.register_function(functions[name], name)
        self._pop = None

    def run(self, population):
        if type(population) <> list:
            return 'Population must be a list'
        
        if self._pop is not None: del(self._pop)
        
        self._pop = Populacao(None, verboso=True)
        
        for i in population:
            print i
            self._pop.addIndividuo(Cromossomo(9,i))
        
        print 'Evaluating population...'
        self._pop.avaliarPopulacao(avaliacaoRNA)
        print 'Sending answers...'
        answersMSE = []
        for i in self._pop.getIndividuos():
            answersMSE.append(i.getAvaliacao())
        print answersMSE
        return answersMSE

    def serve(self):
        try:
            print 'Server running. Press CTRL+C to stop...'
            self._server.serve_forever()
        except KeyboardInterrupt:
            print 'Exiting'
예제 #29
0
def main():
    global _PIDS
 
    # Create a new JSON-RPC server on localhost:8080
    s = SimpleJSONRPCServer(('localhost', 8080))
 
    # Register the functions to be called by the PHP client
    s.register_function(parse_html, 'parse_html')

    # Creates 5 child server processes
    for i in range(5):
        # Fork current process
        pid = os.fork()
 
        # Child fork:
        if 0 == pid:
            # Prevent interrupt messages
            for signum in ( signal.SIGINT, signal.SIGTERM, ):
                signal.signal(signum, _gogentle)
 
            # Start server
            s.serve_forever()
            os._exit(0)
 
        # Parent:
        else:
            _PIDS.append(pid)
 
    # Handle interrupt signals quietly
    for signum in ( signal.SIGINT, signal.SIGTERM, ):
        signal.signal(signum, _kronos)
 
    # Wait for child processes
    while len(_PIDS):
        pid, rc = os.waitpid(-1, 0)
        _PIDS.remove(pid)
 
    return 0
예제 #30
0
def server_set_up(addr, address_family=socket.AF_INET):
    # Not sure this is a good idea to spin up a new server thread
    # for each test... but it seems to work fine.
    def log_request(self, *args, **kwargs):
        """ Making the server output 'quiet' """
        pass
    SimpleJSONRPCRequestHandler.log_request = log_request
    server = SimpleJSONRPCServer(addr, address_family=address_family)
    service = ExampleAggregateService()
    # Expose an instance of the service
    server.register_instance(service, allow_dotted_names=True)
    # Expose some aliases for service methods
    server.register_function(service.summation, 'sum')
    server.register_function(service.summation, 'notify_sum')
    server.register_function(service.summation, 'namespace.sum')
    server_proc = Thread(target=server.serve_forever)
    server_proc.daemon = True
    server_proc.start()
    return server_proc
예제 #31
0
class Daemon(DaemonThread):
    def __init__(self, config, network):
        DaemonThread.__init__(self)
        self.config = config
        self.network = network
        self.wallets = {}
        self.load_wallet()
        self.cmd_runner = Commands(self.config, self.wallets, self.network)

        host = config.get('rpchost', '0.0.0.0')
        port = config.get('rpcport', 8000)
        self.server = SimpleJSONRPCServer((host, port),
                                          requestHandler=RequestHandler,
                                          logRequests=False)
        with open(lockfile(config), 'w') as f:
            f.write(repr(self.server.socket.getsockname()))
        self.server.timeout = 0.1
        for cmdname in known_commands:
            # rpc直接调用命令 --hetao
            self.server.register_function(getattr(self.cmd_runner, cmdname),
                                          cmdname)
        self.server.register_function(self.ping, 'ping')
        self.server.register_function(self.run_daemon, 'daemon')

    def ping(self):
        return True

    def run_daemon(self, config):
        sub = config.get('subcommand')
        assert sub in ['start', 'stop', 'status']
        if sub == 'start':
            response = "Daemon already running"
        elif sub == 'status':
            p = self.network.get_parameters()
            response = {
                'path':
                self.network.config.path,
                'server':
                p[0],
                'blockchain_height':
                self.network.get_local_height(),
                'server_height':
                self.network.get_server_height(),
                'nodes':
                self.network.get_interfaces(),
                'connected':
                self.network.is_connected(),
                'auto_connect':
                p[3],
                'wallets':
                dict([(k, w.is_up_to_date())
                      for k, w in self.wallets.items()]),
            }
        elif sub == 'stop':
            self.stop()
            response = "Daemon stopped"
        return response

    def load_wallet(self):
        mongo = pymongo.MongoClient('192.168.14.240')
        db = mongo.uwallet_user
        for col_name in db.list_collection_names():
            col = db.get_collection(col_name)

            for user_name in col.find({}, {'_id': 1}):

                user = '******'.join([col_name, user_name['_id']])
                storage = WalletStorage(user)

                wallet = Wallet(storage)
                # automatically generate wallet for ulord
                if not storage.file_exists:
                    seed = wallet.make_seed()
                    wallet.add_seed(seed, None)
                    wallet.create_master_keys(None)
                    wallet.create_main_account()
                    wallet.synchronize()

                wallet.start_threads(self.network)
                if wallet:
                    self.wallets[user] = wallet

    def run(self):
        i = 0
        while self.is_running():
            # self.server.handle_request()
            try:
                thread.start_new_thread(self.server.handle_request, ())
                time.sleep(0.01)
                i = i + 1
            except Exception, ex:
                i = 0
                print ex
                continue
        os.unlink(lockfile(self.config))
예제 #32
0
        time.sleep(MODEL_UPDATE_LAG_IN_SECONDS)
        restoreVars()
        loadModel()


# Setup watchdog
observer = Observer()
observer.schedule(ReloadModelHandler(), path=MODEL_DIR, recursive=False)
observer.start()


def classify(text):
    text_series = pd.Series([text])
    predict_x = np.array(list(vocab_processor.transform(text_series)))
    print(predict_x)

    y_predicted = [
        p['class'] for p in classifier.predict(predict_x, as_iterable=True)
    ]
    print(y_predicted[0])
    topic = news_classes.class_map[str(y_predicted[0])]
    return topic


# Threading RPC server
RPC_SERVER = SimpleJSONRPCServer((SERVER_HOST, SERVER_PORT))
RPC_SERVER.register_function(classify, 'classify')

print("Starting RPC Server on %s:%d" % (SERVER_HOST, SERVER_PORT))

RPC_SERVER.serve_forever()
예제 #33
0
파일: trex_server.py 프로젝트: lb1wh/trex
class CTRexServer(object):
    """This class defines the server side of the RESTfull interaction with TRex"""
    DEFAULT_TREX_PATH = '/auto/proj-pcube-b/apps/PL-b/tools/bp_sim2/v1.55/'  #'/auto/proj-pcube-b/apps/PL-b/tools/nightly/trex_latest'
    TREX_START_CMD = './t-rex-64'
    DEFAULT_FILE_PATH = '/tmp/trex_files/'

    def __init__(self,
                 trex_path,
                 trex_files_path,
                 trex_host='0.0.0.0',
                 trex_daemon_port=8090,
                 trex_zmq_port=4500):
        """ 
        Parameters
        ----------
        trex_host : str
            a string of the t-rex ip address or hostname.
            default value: machine hostname as fetched from socket.gethostname()
        trex_daemon_port : int
            the port number on which the trex-daemon server can be reached
            default value: 8090
        trex_zmq_port : int
            the port number on which trex's zmq module will interact with daemon server
            default value: 4500

        Instantiate a TRex client object, and connecting it to listening daemon-server
        """
        self.TREX_PATH = os.path.abspath(os.path.dirname(trex_path + '/'))
        self.trex_files_path = os.path.abspath(
            os.path.dirname(trex_files_path + '/'))
        self.__check_trex_path_validity()
        self.__check_files_path_validity()
        self.trex = CTRex()
        self.trex_version = None
        self.trex_host = trex_host
        self.trex_daemon_port = trex_daemon_port
        self.trex_zmq_port = trex_zmq_port
        self.trex_server_path = "http://{hostname}:{port}".format(
            hostname=trex_host, port=trex_daemon_port)
        self.start_lock = threading.Lock()
        self.__reservation = None
        self.zmq_monitor = ZmqMonitorSession(
            self.trex, self.trex_zmq_port
        )  # intiate single ZMQ monitor thread for server usage

    def add(self, x, y):
        print("server function add ", x, y)
        logger.info(
            "Processing add function. Parameters are: {0}, {1} ".format(x, y))
        return x + y
        # return Fault(-10, "")

    def push_file(self, filename, bin_data):
        logger.info("Processing push_file() command.")
        try:
            filepath = os.path.abspath(
                os.path.join(self.trex_files_path, filename))
            with open(filepath, 'wb') as f:
                f.write(binascii.a2b_base64(bin_data))
            logger.info(
                "push_file() command finished. `{name}` was saved at {fpath}".
                format(name=filename, fpath=self.trex_files_path))
            return True
        except IOError as inst:
            logger.error("push_file method failed. " + str(inst))
            return False

    def connectivity_check(self):
        logger.info("Processing connectivity_check function.")
        return True

    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
        try:
            self.server.register_function(self.add)
            self.server.register_function(self.get_trex_log)
            self.server.register_function(self.get_trex_daemon_log)
            self.server.register_function(self.get_trex_version)
            self.server.register_function(self.connectivity_check)
            self.server.register_function(self.start_trex)
            self.server.register_function(self.stop_trex)
            self.server.register_function(self.wait_until_kickoff_finish)
            self.server.register_function(self.get_running_status)
            self.server.register_function(self.is_running)
            self.server.register_function(self.get_running_info)
            self.server.register_function(self.is_reserved)
            self.server.register_function(self.get_files_path)
            self.server.register_function(self.push_file)
            self.server.register_function(self.reserve_trex)
            self.server.register_function(self.cancel_reservation)
            self.server.register_function(self.force_trex_kill)
            signal.signal(signal.SIGTSTP, self.stop_handler)
            signal.signal(signal.SIGTERM, self.stop_handler)
            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()
            pass

    # get files from Trex server and return their content (mainly for logs)
    @staticmethod
    def _pull_file(filepath):
        try:
            with open(filepath, 'rb') as f:
                file_content = f.read()
                return binascii.b2a_base64(file_content)
        except Exception as e:
            err_str = "Can't get requested file: {0}, possibly due to TRex that did not run".format(
                filepath)
            logger.error('{0}, error: {1}'.format(err_str, e))
            return Fault(-33, err_str)

    # get Trex log /tmp/trex.txt
    def get_trex_log(self):
        logger.info("Processing get_trex_log() command.")
        return self._pull_file('/tmp/trex.txt')

    # get daemon log /var/log/trex/trex_daemon_server.log
    def get_trex_daemon_log(self):
        logger.info("Processing get_trex_daemon_log() command.")
        return self._pull_file('/var/log/trex/trex_daemon_server.log')

    # get Trex version from ./t-rex-64 --help (last lines starting with "Version : ...")
    def get_trex_version(self, base64=True):
        try:
            logger.info("Processing get_trex_version() command.")
            if not self.trex_version:
                help_print = subprocess.Popen(['./t-rex-64', '--help'],
                                              cwd=self.TREX_PATH,
                                              stdout=subprocess.PIPE,
                                              stderr=subprocess.PIPE)
                (stdout, stderr) = help_print.communicate()
                search_result = re.search('\n\s*(Version\s*:.+)', stdout,
                                          re.DOTALL)
                if not search_result:
                    raise Exception(
                        'Could not determine version from ./t-rex-64 --help')
                self.trex_version = binascii.b2a_base64(search_result.group(1))
            if base64:
                return self.trex_version
            else:
                return binascii.a2b_base64(self.trex_version)
        except Exception as e:
            err_str = "Can't get trex version, error: {0}".format(e)
            logger.error(err_str)
            return Fault(-33, err_str)

    def stop_handler(self, signum, frame):
        logger.info("Daemon STOP request detected.")
        if self.is_running():
            # in case TRex process is currently running, stop it before terminating server process
            self.stop_trex(self.trex.get_seq())
        sys.exit(0)

    def is_running(self):
        run_status = self.trex.get_status()
        logger.info(
            "Processing is_running() command. Running status is: {stat}".
            format(stat=run_status))
        if run_status == TRexStatus.Running:
            return True
        else:
            return False

    def is_reserved(self):
        logger.info("Processing is_reserved() command.")
        return bool(self.__reservation)

    def get_running_status(self):
        run_status = self.trex.get_status()
        logger.info(
            "Processing get_running_status() command. Running status is: {stat}"
            .format(stat=run_status))
        return {
            'state': run_status.value,
            'verbose': self.trex.get_verbose_status()
        }

    def get_files_path(self):
        logger.info("Processing get_files_path() command.")
        return self.trex_files_path

    def reserve_trex(self, user):
        if user == "":
            logger.info(
                "TRex reservation cannot apply to empty string user. Request denied."
            )
            return Fault(
                -33,
                "TRex reservation cannot apply to empty string user. Request denied."
            )

        with self.start_lock:
            logger.info("Processing reserve_trex() command.")
            if self.is_reserved():
                if user == self.__reservation['user']:
                    # return True is the same user is asking and already has the resrvation
                    logger.info(
                        "the same user is asking and already has the resrvation. Re-reserving TRex."
                    )
                    return True

                logger.info(
                    "TRex is already reserved to another user ({res_user}), cannot reserve to another user."
                    .format(res_user=self.__reservation['user']))
                return Fault(
                    -33,
                    "TRex is already reserved to another user ({res_user}). Please make sure TRex is free before reserving it."
                    .format(res_user=self.__reservation['user']
                            ))  # raise at client TRexInUseError
            elif self.trex.get_status() != TRexStatus.Idle:
                logger.info(
                    "TRex is currently running, cannot reserve TRex unless in Idle state."
                )
                return Fault(
                    -13,
                    'TRex is currently running, cannot reserve TRex unless in Idle state. Please try again when TRex run finished.'
                )  # raise at client TRexInUseError
            else:
                logger.info(
                    "TRex is now reserved for user ({res_user}).".format(
                        res_user=user))
                self.__reservation = {'user': user, 'since': time.ctime()}
                logger.debug("Reservation details: " + str(self.__reservation))
                return True

    def cancel_reservation(self, user):
        with self.start_lock:
            logger.info("Processing cancel_reservation() command.")
            if self.is_reserved():
                if self.__reservation['user'] == user:
                    logger.info(
                        "TRex reservation to {res_user} has been canceled successfully."
                        .format(res_user=self.__reservation['user']))
                    self.__reservation = None
                    return True
                else:
                    logger.warning(
                        "TRex is reserved to different user than the provided one. Reservation wasn't canceled."
                    )
                    return Fault(
                        -33,
                        "Cancel reservation request is available to the user that holds the reservation. Request denied"
                    )  # raise at client TRexRequestDenied

            else:
                logger.info(
                    "TRex is not reserved to anyone. No need to cancel anything"
                )
                assert (self.__reservation is None)
                return False

    def start_trex(self,
                   trex_cmd_options,
                   user,
                   block_to_success=True,
                   timeout=40):
        with self.start_lock:
            logger.info("Processing start_trex() command.")
            if self.is_reserved():
                # check if this is not the user to which TRex is reserved
                if self.__reservation['user'] != user:
                    logger.info(
                        "TRex is reserved to another user ({res_user}). Only that user is allowed to initiate new runs."
                        .format(res_user=self.__reservation['user']))
                    return Fault(
                        -33,
                        "TRex is reserved to another user ({res_user}). Only that user is allowed to initiate new runs."
                        .format(res_user=self.__reservation['user']
                                ))  # raise at client TRexRequestDenied
            elif self.trex.get_status() != TRexStatus.Idle:
                logger.info(
                    "TRex is already taken, cannot create another run until done."
                )
                return Fault(-13, '')  # raise at client TRexInUseError

            try:
                server_cmd_data = self.generate_run_cmd(**trex_cmd_options)
                self.zmq_monitor.first_dump = True
                self.trex.start_trex(self.TREX_PATH, server_cmd_data)
                logger.info("TRex session has been successfully initiated.")
                if block_to_success:
                    # delay server response until TRex is at 'Running' state.
                    start_time = time.time()
                    trex_state = None
                    while (time.time() - start_time) < timeout:
                        trex_state = self.trex.get_status()
                        if trex_state != TRexStatus.Starting:
                            break
                        else:
                            time.sleep(0.5)

                    # check for TRex run started normally
                    if trex_state == TRexStatus.Starting:  # reached timeout
                        logger.warning(
                            "TimeoutError: TRex initiation outcome could not be obtained, since TRex stays at Starting state beyond defined timeout."
                        )
                        return Fault(
                            -12,
                            'TimeoutError: TRex initiation outcome could not be obtained, since TRex stays at Starting state beyond defined timeout.'
                        )  # raise at client TRexWarning
                    elif trex_state == TRexStatus.Idle:
                        return Fault(-11, self.trex.get_verbose_status()
                                     )  # raise at client TRexError

                # reach here only if TRex is at 'Running' state
                self.trex.gen_seq()
                return self.trex.get_seq(
                )  # return unique seq number to client

            except TypeError as e:
                logger.error(
                    "TRex command generation failed, probably because either -f (traffic generation .yaml file) and -c (num of cores) was not specified correctly.\nReceived params: {params}"
                    .format(params=trex_cmd_options))
                raise TypeError(
                    'TRex -f (traffic generation .yaml file) and -c (num of cores) must be specified.'
                )

    def stop_trex(self, seq):
        logger.info("Processing stop_trex() command.")
        if self.trex.get_seq() == seq:
            logger.debug("Abort request legit since seq# match")
            return self.trex.stop_trex()
        else:
            if self.trex.get_status() != TRexStatus.Idle:
                logger.warning(
                    "Abort request is only allowed to process initiated the run. Request denied."
                )

                return Fault(
                    -33,
                    'Abort request is only allowed to process initiated the run. Request denied.'
                )  # raise at client TRexRequestDenied
            else:
                return False

    def force_trex_kill(self):
        logger.info(
            "Processing force_trex_kill() command. --> Killing TRex session indiscriminately."
        )
        return self.trex.stop_trex()

    def wait_until_kickoff_finish(self, timeout=40):
        # block until TRex exits Starting state
        logger.info("Processing wait_until_kickoff_finish() command.")
        trex_state = None
        start_time = time.time()
        while (time.time() - start_time) < timeout:
            trex_state = self.trex.get_status()
            if trex_state != TRexStatus.Starting:
                return
        return Fault(
            -12,
            'TimeoutError: TRex initiation outcome could not be obtained, since TRex stays at Starting state beyond defined timeout.'
        )  # raise at client TRexWarning

    def get_running_info(self):
        logger.info("Processing get_running_info() command.")
        return self.trex.get_running_info()

    def generate_run_cmd(self,
                         f,
                         d,
                         iom=0,
                         export_path="/tmp/trex.txt",
                         **kwargs):
        """ generate_run_cmd(self, trex_cmd_options, export_path) -> str

        Generates a custom running command for the kick-off of the TRex traffic generator.
        Returns a tuple of command (string) and export path (string) to be issued on the trex server

        Parameters
        ----------
        kwargs: dictionary
            Dictionary of parameters for trex. For example: (c=1, nc=True, l_pkt_mode=3).
            Notice that when sending command line parameters that has -, you need to replace it with _.
            for example, to have on command line "--l-pkt-mode 3", you need to send l_pkt_mode=3
        export_path : str
            Full system path to which the results of the trex-run will be logged.

        """
        if 'results_file_path' in kwargs:
            export_path = kwargs['results_file_path']
            del kwargs['results_file_path']

        # adding additional options to the command
        trex_cmd_options = ''
        for key, value in kwargs.items():
            tmp_key = key.replace('_', '-')
            dash = ' -' if (len(key) == 1) else ' --'
            if (value == True) and (
                    str(value) != '1'
            ):  # checking also int(value) to excape from situation that 1 translates by python to 'True'
                trex_cmd_options += (dash + tmp_key)
            else:
                trex_cmd_options += (dash +
                                     '{k} {val}'.format(k=tmp_key, val=value))

        cmd = "{run_command} -f {gen_file} -d {duration} --iom {io} {cmd_options} --no-key > {export}".format(  # -- iom 0 disables the periodic log to the screen (not needed)
            run_command=self.TREX_START_CMD,
            gen_file=f,
            duration=d,
            cmd_options=trex_cmd_options,
            io=iom,
            export=export_path)

        logger.info("TREX FULL COMMAND: {command}".format(command=cmd))

        return (cmd, export_path, int(d))

    def __check_trex_path_validity(self):
        # check for executable existance
        if not os.path.exists(self.TREX_PATH + '/t-rex-64'):
            print(
                "The provided TRex path do not contain an executable TRex file.\nPlease check the path and retry."
            )
            logger.error(
                "The provided TRex path do not contain an executable TRex file"
            )
            exit(-1)
        # check for executable permissions
        st = os.stat(self.TREX_PATH + '/t-rex-64')
        if not bool(st.st_mode & (stat.S_IXUSR)):
            print(
                "The provided TRex path do not contain an TRex file with execution privileges.\nPlease check the files permissions and retry."
            )
            logger.error(
                "The provided TRex path do not contain an TRex file with execution privileges"
            )
            exit(-1)
        else:
            return

    def __check_files_path_validity(self):
        # first, check for path existance. otherwise, try creating it with appropriate credentials
        if not os.path.exists(self.trex_files_path):
            try:
                os.makedirs(self.trex_files_path, 0o660)
                return
            except os.error as inst:
                print(
                    "The provided files path does not exist and cannot be created with needed access credentials using root user.\nPlease check the path's permissions and retry."
                )
                logger.error(
                    "The provided files path does not exist and cannot be created with needed access credentials using root user."
                )
                exit(-1)
        elif os.access(self.trex_files_path, os.W_OK):
            return
        else:
            print(
                "The provided files path has insufficient access credentials for root user.\nPlease check the path's permissions and retry."
            )
            logger.error(
                "The provided files path has insufficient access credentials for root user"
            )
            exit(-1)
예제 #34
0
파일: engine.py 프로젝트: vieting/returnn
  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()
예제 #35
0
def main():
	server = SimpleJSONRPCServer(('localhost', 1006))
	server.register_function(predict)
	print("Start server")
	server.serve_forever()
예제 #36
0
 def __init__(self, *args, **kwargs):
     SimpleJSONRPCServer.__init__(self, *args, **kwargs)
예제 #37
0
import sys

from bson.json_util import dumps
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer

# import utils packages
sys.path.append(os.path.join(os.path.dirname(__file__), 'utils'))
import mongodb_client # pylint: disable=import-error, wrong-import-position

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("get_one_news is called")
    news = mongodb_client.get_db()['news'].find_one()
    return json.loads(dumps(news))

RPC_SERVER = SimpleJSONRPCServer((SERVER_HOST, SERVER_PORT))
RPC_SERVER.register_function(add, 'add')
RPC_SERVER.register_function(get_one_news, 'getOneNews')

print("Starting RPC Server on %s:%d " % (SERVER_HOST, SERVER_PORT))

RPC_SERVER.serve_forever()
예제 #38
0
class OverlordClientDaemon(object):
    """Overlord Client Daemon."""
    def __init__(self):
        self._state = DaemonState()
        self._server = None

    def Start(self):
        self.StartRPCServer()

    def StartRPCServer(self):
        self._server = SimpleJSONRPCServer(_OVERLORD_CLIENT_DAEMON_RPC_ADDR,
                                           logRequests=False)
        exports = [
            (self.State, 'State'),
            (self.Ping, 'Ping'),
            (self.GetPid, 'GetPid'),
            (self.Connect, 'Connect'),
            (self.Clients, 'Clients'),
            (self.SelectClient, 'SelectClient'),
            (self.AddForward, 'AddForward'),
            (self.RemoveForward, 'RemoveForward'),
            (self.RemoveAllForward, 'RemoveAllForward'),
        ]
        for func, name in exports:
            self._server.register_function(func, name)

        pid = os.fork()
        if pid == 0:
            self._server.serve_forever()

    @staticmethod
    def GetRPCServer():
        """Returns the Overlord client daemon RPC server."""
        server = jsonrpclib.Server('http://%s:%d' %
                                   _OVERLORD_CLIENT_DAEMON_RPC_ADDR)
        try:
            server.Ping()
        except Exception:
            return None
        return server

    def State(self):
        return self._state

    def Ping(self):
        return True

    def GetPid(self):
        return os.getpid()

    def _GetJSON(self, path):
        url = '%s:%d%s' % (self._state.host, self._state.port, path)
        return json.loads(UrlOpen(self._state, url).read())

    def _TLSEnabled(self):
        """Determine if TLS is enabled on given server address."""
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            # Allow any certificate since we only want to check if server talks TLS.
            context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
            context.verify_mode = ssl.CERT_NONE

            sock = context.wrap_socket(sock, server_hostname=self._state.host)
            sock.settimeout(_CONNECT_TIMEOUT)
            sock.connect((self._state.host, self._state.port))
            return True
        except ssl.SSLError as e:
            return False
        except socket.error:  # Connect refused or timeout
            raise
        except Exception:
            return False  # For whatever reason above failed, assume False

    def _CheckTLSCertificate(self):
        """Check TLS certificate.

    Returns:
      A tupple (check_result, if_certificate_is_loaded)
    """
        def _DoConnect(context):
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            try:
                sock.settimeout(_CONNECT_TIMEOUT)
                sock = context.wrap_socket(sock,
                                           server_hostname=self._state.host)
                sock.connect((self._state.host, self._state.port))
            except ssl.SSLError:
                return False
            finally:
                sock.close()

            # Save SSLContext for future use.
            self._state.ssl_context = context
            return True

        # First try connect with built-in certificates
        tls_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
        if _DoConnect(tls_context):
            return True

        # Try with already saved certificate, if any.
        tls_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
        tls_context.verify_mode = ssl.CERT_REQUIRED
        tls_context.check_hostname = True

        tls_cert_path = GetTLSCertPath(self._state.host)
        if os.path.exists(tls_cert_path):
            tls_context.load_verify_locations(tls_cert_path)
            self._state.ssl_self_signed = True

        return _DoConnect(tls_context)

    def Connect(self,
                host,
                port=_OVERLORD_HTTP_PORT,
                ssh_pid=None,
                username=None,
                password=None,
                orig_host=None):
        self._state.username = username
        self._state.password = password
        self._state.host = host
        self._state.port = port
        self._state.ssl = False
        self._state.ssl_self_signed = False
        self._state.orig_host = orig_host
        self._state.ssh_pid = ssh_pid
        self._state.selected_mid = None

        tls_enabled = self._TLSEnabled()
        if tls_enabled:
            result = self._CheckTLSCertificate()
            if not result:
                if self._state.ssl_self_signed:
                    return ('SSLCertificateChanged',
                            ssl.get_server_certificate(
                                (self._state.host, self._state.port)))
                else:
                    return ('SSLVerifyFailed',
                            ssl.get_server_certificate(
                                (self._state.host, self._state.port)))

        try:
            self._state.ssl = tls_enabled
            UrlOpen(self._state, '%s:%d' % (host, port))
        except urllib2.HTTPError as e:
            return ('HTTPError', e.getcode(), str(e), e.read().strip())
        except Exception as e:
            return str(e)
        else:
            return True

    def Clients(self):
        if time.time() - self._state.last_list <= _LIST_CACHE_TIMEOUT:
            return self._state.listing

        mids = [client['mid'] for client in self._GetJSON('/api/agents/list')]
        self._state.listing = sorted(list(set(mids)))
        self._state.last_list = time.time()
        return self._state.listing

    def SelectClient(self, mid):
        self._state.selected_mid = mid

    def AddForward(self, mid, remote, local, pid):
        self._state.forwards[local] = (mid, remote, pid)

    def RemoveForward(self, local_port):
        try:
            unused_mid, unused_remote, pid = self._state.forwards[local_port]
            KillGraceful(pid)
            del self._state.forwards[local_port]
        except (KeyError, OSError):
            pass

    def RemoveAllForward(self):
        for unused_mid, unused_remote, pid in self._state.forwards.values():
            try:
                KillGraceful(pid)
            except OSError:
                pass
        self._state.forwards = {}
예제 #39
0
    def startservers(self):
        server = SimpleJSONRPCServer((IP, self.serverport))
        server.register_function(self.deviceConnected)
        server.register_function(self.deviceDisconnected)
        server.register_function(self.portAdded)
        server.register_function(self.portRemoved)
        server.register_function(self.linkup)
        server.register_function(self.linkdown)

        try:
            self.fvthread = threading.Thread(target=server.serve_forever)
            print "Start callback server"
            self.fvthread.start()
            self.httpd.serve_forever()
        except KeyboardInterrupt:
            server.shutdown()
            self.unregisterFromFV()
예제 #40
0
        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
class CTRexServer(object):
    """This class defines the server side of the RESTfull interaction with TRex"""
    TREX_START_CMD = './t-rex-64'
    DEFAULT_FILE_PATH = '/tmp/trex_files/'

    def __init__(self,
                 trex_path,
                 trex_files_path,
                 trex_host='0.0.0.0',
                 trex_daemon_port=8090,
                 trex_zmq_port=4500,
                 trex_nice=-19):
        """ 
        Parameters
        ----------
        trex_host : str
            a string of the TRex ip address or hostname.
            default value: machine hostname as fetched from socket.gethostname()
        trex_daemon_port : int
            the port number on which the trex-daemon server can be reached
            default value: 8090
        trex_zmq_port : int
            the port number on which trex's zmq module will interact with daemon server
            default value: 4500
        nice: int
            priority of the TRex process

        Instantiate a TRex client object, and connecting it to listening daemon-server
        """
        self.TREX_PATH = os.path.abspath(os.path.dirname(trex_path + '/'))
        self.trex_files_path = os.path.abspath(
            os.path.dirname(trex_files_path + '/'))
        self.__check_trex_path_validity()
        self.__check_files_path_validity()
        self.trex = CTRex()
        self.trex_version = None
        self.trex_host = trex_host
        self.trex_daemon_port = trex_daemon_port
        self.trex_zmq_port = trex_zmq_port
        self.trex_server_path = "http://{hostname}:{port}".format(
            hostname=trex_host, port=trex_daemon_port)
        self.start_lock = threading.Lock()
        self.__reservation = None
        self.zmq_monitor = ZmqMonitorSession(
            self.trex, self.trex_zmq_port
        )  # intiate single ZMQ monitor thread for server usage
        self.trex_nice = int(trex_nice)
        if self.trex_nice < -20 or self.trex_nice > 19:
            err = "Parameter 'nice' should be integer in range [-20, 19]"
            print(err)
            logger.error(err)
            raise Exception(err)

    def add(self, x, y):
        logger.info(
            "Processing add function. Parameters are: {0}, {1} ".format(x, y))
        return x + y
        # return Fault(-10, "")

    def push_file(self, filename, bin_data):
        logger.info("Processing push_file() command.")
        try:
            filepath = os.path.join(self.trex_files_path,
                                    os.path.basename(filename))
            with open(filepath, 'wb') as f:
                f.write(binascii.a2b_base64(bin_data))
            logger.info("push_file() command finished. File is saved as %s" %
                        filepath)
            return True
        except IOError as inst:
            logger.error("push_file method failed. " + str(inst))
            return False

    def connectivity_check(self):
        logger.info("Processing connectivity_check function.")
        return True

    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.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_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()
            #self.server.server_close()

    # get files from Trex server and return their content (mainly for logs)
    @staticmethod
    def _pull_file(filepath):
        try:
            with open(filepath, 'rb') as f:
                file_content = f.read()
                return binascii.b2a_base64(file_content).decode(
                    errors='replace')
        except Exception as e:
            err_str = "Can't get requested file %s: %s" % (filepath, e)
            logger.error(err_str)
            return Fault(-33, err_str)

    # returns True if given path is under TRex package or under /tmp/trex_files
    def _check_path_under_TRex_or_temp(self, path):
        if not os.path.relpath(path, self.trex_files_path).startswith(
                os.pardir):
            return True
        if not os.path.relpath(path, self.TREX_PATH).startswith(os.pardir):
            return True
        return False

    # gets the file content encoded base64 either from /tmp/trex_files or TRex server dir
    def get_file(self, filepath):
        try:
            logger.info("Processing get_file() command.")
            if not self._check_path_under_TRex_or_temp(filepath):
                raise Exception(
                    'Given path should be under current TRex package or /tmp/trex_files'
                )
            return self._pull_file(filepath)
        except Exception as e:
            err_str = "Can't get requested file %s: %s" % (filepath, e)
            logger.error(err_str)
            return Fault(-33, err_str)

    # get tuple (dirs, files) with directories and files lists from given path (limited under TRex package or /tmp/trex_files)
    def get_files_list(self, path):
        try:
            logger.info("Processing get_files_list() command, given path: %s" %
                        path)
            if not self._check_path_under_TRex_or_temp(path):
                raise Exception(
                    'Given path should be under current TRex package or /tmp/trex_files'
                )
            return os.walk(path).next()[1:3]
        except Exception as e:
            err_str = "Error processing get_files_list(): %s" % e
            logger.error(err_str)
            return Fault(-33, err_str)

    # get Trex log /tmp/trex.txt
    def get_trex_log(self):
        logger.info("Processing get_trex_log() command.")
        return self._pull_file('/tmp/trex.txt')

    # get /etc/trex_cfg.yaml
    def get_trex_config(self):
        logger.info("Processing get_trex_config() command.")
        return self._pull_file('/etc/trex_cfg.yaml')

    # get daemon log /var/log/trex/trex_daemon_server.log
    def get_trex_daemon_log(self):
        logger.info("Processing get_trex_daemon_log() command.")
        return self._pull_file('/var/log/trex/trex_daemon_server.log')

    # get Trex version from ./t-rex-64 --help (last lines starting with "Version : ...")
    def get_trex_version(self, base64=True):
        try:
            logger.info("Processing get_trex_version() command.")
            if not self.trex_version:
                ret_code, stdout, stderr = run_command('./t-rex-64 --help',
                                                       cwd=self.TREX_PATH)
                search_result = re.search('\n\s*(Version\s*:.+)', stdout,
                                          re.DOTALL)
                if not search_result:
                    raise Exception(
                        'Could not determine version from ./t-rex-64 --help')
                self.trex_version = binascii.b2a_base64(
                    search_result.group(1).encode(errors='replace'))
            if base64:
                return self.trex_version.decode(errors='replace')
            else:
                return binascii.a2b_base64(
                    self.trex_version).decode(errors='replace')
        except Exception as e:
            err_str = "Can't get trex version, error: %s" % e
            logger.error(err_str)
            return Fault(-33, err_str)

    def stop_handler(self, *args, **kwargs):
        logger.info("Daemon STOP request detected.")
        if self.is_running():
            # in case TRex process is currently running, stop it before terminating server process
            self.stop_trex(self.trex.get_seq())
        sys.exit(0)

    def assert_zmq_ok(self):
        if self.trex.zmq_error:
            self.trex.zmq_error, err = None, self.trex.zmq_error
            raise Exception('ZMQ thread got error: %s' % err)
        if not self.zmq_monitor.is_alive():
            if self.trex.get_status() != TRexStatus.Idle:
                self.force_trex_kill()
            raise Exception('ZMQ thread is dead.')

    def is_running(self):
        run_status = self.trex.get_status()
        logger.info(
            "Processing is_running() command. Running status is: {stat}".
            format(stat=run_status))
        if run_status == TRexStatus.Running:
            return True
        else:
            return False

    def is_reserved(self):
        logger.info("Processing is_reserved() command.")
        return bool(self.__reservation)

    def get_running_status(self):
        run_status = self.trex.get_status()
        logger.info(
            "Processing get_running_status() command. Running status is: {stat}"
            .format(stat=run_status))
        return {
            'state': run_status.value,
            'verbose': self.trex.get_verbose_status()
        }

    def get_files_path(self):
        logger.info("Processing get_files_path() command.")
        return self.trex_files_path

    def reserve_trex(self, user):
        if user == "":
            logger.info(
                "TRex reservation cannot apply to empty string user. Request denied."
            )
            return Fault(
                -33,
                "TRex reservation cannot apply to empty string user. Request denied."
            )

        with self.start_lock:
            logger.info("Processing reserve_trex() command.")
            if self.is_reserved():
                if user == self.__reservation['user']:
                    # return True is the same user is asking and already has the resrvation
                    logger.info(
                        "the same user is asking and already has the resrvation. Re-reserving TRex."
                    )
                    return True

                logger.info(
                    "TRex is already reserved to another user ({res_user}), cannot reserve to another user."
                    .format(res_user=self.__reservation['user']))
                return Fault(
                    -33,
                    "TRex is already reserved to another user ({res_user}). Please make sure TRex is free before reserving it."
                    .format(res_user=self.__reservation['user']
                            ))  # raise at client TRexInUseError
            elif self.trex.get_status() != TRexStatus.Idle:
                logger.info(
                    "TRex is currently running, cannot reserve TRex unless in Idle state."
                )
                return Fault(
                    -13,
                    'TRex is currently running, cannot reserve TRex unless in Idle state. Please try again when TRex run finished.'
                )  # raise at client TRexInUseError
            else:
                logger.info(
                    "TRex is now reserved for user ({res_user}).".format(
                        res_user=user))
                self.__reservation = {'user': user, 'since': time.ctime()}
                logger.debug("Reservation details: " + str(self.__reservation))
                return True

    def cancel_reservation(self, user):
        with self.start_lock:
            logger.info("Processing cancel_reservation() command.")
            if self.is_reserved():
                if self.__reservation['user'] == user:
                    logger.info(
                        "TRex reservation to {res_user} has been canceled successfully."
                        .format(res_user=self.__reservation['user']))
                    self.__reservation = None
                    return True
                else:
                    logger.warning(
                        "TRex is reserved to different user than the provided one. Reservation wasn't canceled."
                    )
                    return Fault(
                        -33,
                        "Cancel reservation request is available to the user that holds the reservation. Request denied"
                    )  # raise at client TRexRequestDenied

            else:
                logger.info(
                    "TRex is not reserved to anyone. No need to cancel anything"
                )
                assert (self.__reservation is None)
                return False

    def start_trex(self,
                   trex_cmd_options,
                   user,
                   block_to_success=True,
                   timeout=40,
                   stateless=False,
                   debug_image=False,
                   trex_args=''):
        self.trex.zmq_error = None
        self.assert_zmq_ok()
        with self.start_lock:
            logger.info("Processing start_trex() command.")
            if self.is_reserved():
                # check if this is not the user to which TRex is reserved
                if self.__reservation['user'] != user:
                    logger.info(
                        "TRex is reserved to another user ({res_user}). Only that user is allowed to initiate new runs."
                        .format(res_user=self.__reservation['user']))
                    return Fault(
                        -33,
                        "TRex is reserved to another user ({res_user}). Only that user is allowed to initiate new runs."
                        .format(res_user=self.__reservation['user']
                                ))  # raise at client TRexRequestDenied
            elif self.trex.get_status() != TRexStatus.Idle:
                err = 'TRex is already taken, cannot create another run until done.'
                logger.info(err)
                return Fault(-13, err)  # raise at client TRexInUseError

            try:
                server_cmd_data = self.generate_run_cmd(
                    stateless=stateless,
                    debug_image=debug_image,
                    trex_args=trex_args,
                    **trex_cmd_options)
                self.zmq_monitor.first_dump = True
                self.trex.start_trex(self.TREX_PATH, server_cmd_data)
                logger.info("TRex session has been successfully initiated.")
                if block_to_success:
                    # delay server response until TRex is at 'Running' state.
                    start_time = time.time()
                    trex_state = None
                    while (time.time() - start_time) < timeout:
                        trex_state = self.trex.get_status()
                        if trex_state != TRexStatus.Starting:
                            break
                        else:
                            time.sleep(0.5)
                            self.assert_zmq_ok()

                    # check for TRex run started normally
                    if trex_state == TRexStatus.Starting:  # reached timeout
                        logger.warning(
                            "TimeoutError: TRex initiation outcome could not be obtained, since TRex stays at Starting state beyond defined timeout."
                        )
                        return Fault(
                            -12,
                            'TimeoutError: TRex initiation outcome could not be obtained, since TRex stays at Starting state beyond defined timeout.'
                        )  # raise at client TRexWarning
                    elif trex_state == TRexStatus.Idle:
                        return Fault(-11, self.trex.get_verbose_status()
                                     )  # raise at client TRexError

                # reach here only if TRex is at 'Running' state
                self.trex.gen_seq()
                return self.trex.get_seq(
                )  # return unique seq number to client

            except TypeError as e:
                logger.error(
                    "TRex command generation failed, probably because either -f (traffic generation .yaml file) and -c (num of cores) was not specified correctly.\nReceived params: {params}"
                    .format(params=trex_cmd_options))
                raise TypeError(
                    'TRex -f (traffic generation .yaml file) and -c (num of cores) must be specified. %s'
                    % e)

    def stop_trex(self, seq):
        logger.info("Processing stop_trex() command.")
        if self.trex.get_seq() == seq:
            logger.debug("Abort request legit since seq# match")
            return self.trex.stop_trex()
        else:
            if self.trex.get_status() != TRexStatus.Idle:
                logger.warning(
                    "Abort request is only allowed to process initiated the run. Request denied."
                )

                return Fault(
                    -33,
                    'Abort request is only allowed to process initiated the run. Request denied.'
                )  # raise at client TRexRequestDenied
            else:
                return False

    def force_trex_kill(self):
        logger.info(
            "Processing force_trex_kill() command. --> Killing TRex session indiscriminately."
        )
        return self.trex.stop_trex()

    # returns list of tuples (pid, command line) of running TRex(es)
    def get_trex_cmds(self):
        logger.info('Processing get_trex_cmds() command.')
        ret_code, stdout, stderr = run_command(
            'ps -u root --format pid,comm,cmd')
        if ret_code:
            raise Exception(
                'Failed to determine running processes, stderr: %s' % stderr)
        trex_cmds_list = []
        for line in stdout.splitlines():
            pid, proc_name, full_cmd = line.strip().split(' ', 2)
            pid = pid.strip()
            full_cmd = full_cmd.strip()
            if proc_name.find('_t-rex-64') >= 0:
                trex_cmds_list.append((pid, full_cmd))
        return trex_cmds_list

    # Silently tries to kill TRexes with given signal.
    # Responsibility of client to verify with get_trex_cmds.
    def kill_all_trexes(self, signal_name):
        logger.info('Processing kill_all_trexes() command.')
        trex_cmds_list = self.get_trex_cmds()
        for pid, cmd in trex_cmds_list:
            logger.info('Killing with signal %s process %s %s' %
                        (signal_name, pid, cmd))
            try:
                os.kill(int(pid), signal_name)
            except OSError as e:
                if e.errno == errno.ESRCH:
                    logger.info('No such process, ignoring.')
                raise

    def wait_until_kickoff_finish(self, timeout=40):
        # block until TRex exits Starting state
        logger.info("Processing wait_until_kickoff_finish() command.")
        start_time = time.time()
        while (time.time() - start_time) < timeout:
            self.assert_zmq_ok()
            trex_state = self.trex.get_status()
            if trex_state != TRexStatus.Starting:
                return
            time.sleep(0.1)
        return Fault(
            -12,
            'TimeoutError: TRex initiation outcome could not be obtained, since TRex stays at Starting state beyond defined timeout.'
        )  # raise at client TRexWarning

    def get_running_info(self):
        self.assert_zmq_ok()
        logger.info("Processing get_running_info() command.")
        return self.trex.get_running_info()

    def get_latest_dump(self):
        logger.info("Processing get_latest_dump() command.")
        return self.trex.get_latest_dump()

    def generate_run_cmd(self,
                         iom=0,
                         export_path="/tmp/trex.txt",
                         stateless=False,
                         debug_image=False,
                         trex_args='',
                         **kwargs):
        """ generate_run_cmd(self, iom, export_path, kwargs) -> str

        Generates a custom running command for the kick-off of the TRex traffic generator.
        Returns a tuple of command (string) and export path (string) to be issued on the trex server

        Parameters
        ----------
        iom: int
            0 = don't print stats screen to log, 1 = print stats (can generate huge logs)
        stateless: boolean
            True = run as stateless, False = require -f and -d arguments
        kwargs: dictionary
            Dictionary of parameters for trex. For example: (c=1, nc=True, l_pkt_mode=3).
            Notice that when sending command line parameters that has -, you need to replace it with _.
            for example, to have on command line "--l-pkt-mode 3", you need to send l_pkt_mode=3
        export_path : str
            Full system path to which the results of the trex-run will be logged.

        """
        if 'results_file_path' in kwargs:
            export_path = kwargs['results_file_path']
            del kwargs['results_file_path']
        if stateless:
            kwargs['i'] = True

        # adding additional options to the command
        trex_cmd_options = ''
        for key, value in kwargs.items():
            tmp_key = key.replace('_', '-').lstrip('-')
            dash = ' -' if (len(key) == 1) else ' --'
            if value is True:
                trex_cmd_options += (dash + tmp_key)
            elif value is False:
                continue
            else:
                trex_cmd_options += (dash +
                                     '{k} {val}'.format(k=tmp_key, val=value))
        if trex_args:
            trex_cmd_options += ' %s' % trex_args

        self._check_zmq_port(trex_cmd_options)

        if not stateless:
            if 'f' not in kwargs:
                raise Exception(
                    'Argument -f should be specified in stateful command')
            if 'd' not in kwargs:
                raise Exception(
                    'Argument -d should be specified in stateful command')

        cmd = "{nice}{run_command}{debug_image} --iom {io} {cmd_options} --no-key".format(  # -- iom 0 disables the periodic log to the screen (not needed)
            nice='' if self.trex_nice == 0 else 'nice -n %s ' % self.trex_nice,
            run_command=self.TREX_START_CMD,
            debug_image='-debug' if debug_image else '',
            cmd_options=trex_cmd_options,
            io=iom)

        logger.info("TREX FULL COMMAND: {command}".format(command=cmd))

        return (cmd, export_path, kwargs.get('d', 0))

    def _check_zmq_port(self, trex_cmd_options):
        zmq_cfg_port = 4500  # default
        parser = ArgumentParser()
        parser.add_argument('--cfg', default='/etc/trex_cfg.yaml')
        args, _ = parser.parse_known_args(shlex.split(trex_cmd_options))
        if not os.path.exists(args.cfg):
            raise Exception('Platform config file "%s" does not exist!' %
                            args.cfg)
        with open(args.cfg) as f:
            trex_cfg = yaml.safe_load(f.read())
        if type(trex_cfg) is not list:
            raise Exception(
                'Platform config file "%s" content should be array.' %
                args.cfg)
        if not len(trex_cfg):
            raise Exception(
                'Platform config file "%s" content should be array with one element.'
                % args.cfg)
        trex_cfg = trex_cfg[0]
        if 'enable_zmq_pub' in trex_cfg and trex_cfg['enable_zmq_pub'] == False:
            raise Exception(
                'TRex daemon expects ZMQ publisher to be enabled. Please change "enable_zmq_pub" to true.'
            )
        if 'zmq_pub_port' in trex_cfg:
            zmq_cfg_port = trex_cfg['zmq_pub_port']
        if zmq_cfg_port != self.trex_zmq_port:
            raise Exception(
                'ZMQ port does not match: platform config file is configured to: %s, daemon server to: %s'
                % (zmq_cfg_port, self.trex_zmq_port))

    def __check_trex_path_validity(self):
        # check for executable existance
        if not os.path.exists(self.TREX_PATH + '/t-rex-64'):
            print(
                "The provided TRex path do not contain an executable TRex file.\nPlease check the path and retry."
            )
            logger.error(
                "The provided TRex path do not contain an executable TRex file"
            )
            exit(-1)
        # check for executable permissions
        st = os.stat(self.TREX_PATH + '/t-rex-64')
        if not bool(st.st_mode & (stat.S_IXUSR)):
            print(
                "The provided TRex path do not contain an TRex file with execution privileges.\nPlease check the files permissions and retry."
            )
            logger.error(
                "The provided TRex path do not contain an TRex file with execution privileges"
            )
            exit(-1)
        else:
            return

    def __check_files_path_validity(self):
        # first, check for path existance. otherwise, try creating it with appropriate credentials
        if not os.path.exists(self.trex_files_path):
            try:
                os.makedirs(self.trex_files_path, 0o660)
                return
            except os.error as inst:
                print(
                    "The provided files path does not exist and cannot be created with needed access credentials using root user.\nPlease check the path's permissions and retry."
                )
                logger.error(
                    "The provided files path does not exist and cannot be created with needed access credentials using root user."
                )
                exit(-1)
        elif os.access(self.trex_files_path, os.W_OK):
            return
        else:
            print(
                "The provided files path has insufficient access credentials for root user.\nPlease check the path's permissions and retry."
            )
            logger.error(
                "The provided files path has insufficient access credentials for root user"
            )
            exit(-1)
    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.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_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()
예제 #43
0
    def __init__(self, config, fd):

        DaemonThread.__init__(self)
        self.config = config
        if config.get('offline'):
            self.network = None
        else:
            self.network = Network(config)
            self.network.start()
        self.gui = None
        self.wallets = {}
        # Setup JSONRPC server
        path = config.get_wallet_path()
        default_wallet = self.load_wallet(path)
        cmd_runner = Commands(self.config, default_wallet, self.network)
        host = config.get('rpchost', 'localhost')
        port = config.get('rpcport', 0)
        server = SimpleJSONRPCServer((host, port),
                                     logRequests=False,
                                     requestHandler=RequestHandler)
        os.write(fd, repr((server.socket.getsockname(), time.time())))
        os.close(fd)
        server.timeout = 0.1
        for cmdname in known_commands:
            server.register_function(getattr(cmd_runner, cmdname), cmdname)
        server.register_function(self.run_cmdline, 'run_cmdline')
        server.register_function(self.ping, 'ping')
        server.register_function(self.run_daemon, 'daemon')
        server.register_function(self.run_gui, 'gui')
        self.server = server
예제 #44
0
def main():
    server = SimpleJSONRPCServer(('localhost', 12000))
    server.register_function(execute)
    print("Start server")
    server.serve_forever()
예제 #45
0
def run_server(port = 8095):
    native_methods = [
                      'acquire',
                      'connect',
                      'disconnect',
                      'get_stats',
                      'get_warnings',
                      'push_remote',
                      'reset',
                      'wait_on_traffic',
                     ]
    hltapi_methods = [
                      'connect',
                      'cleanup_session',
                      'interface_config',
                      'traffic_config',
                      'traffic_control',
                      'traffic_stats',
                     ]

    try:
        server = SimpleJSONRPCServer(('0.0.0.0', port))
        server.register_function(add)
        server.register_function(check_connectivity)
        server.register_function(native_proxy_init)
        server.register_function(native_proxy_del)
        server.register_function(hltapi_proxy_init)
        server.register_function(hltapi_proxy_del)
        server.register_function(native_method)
        server.register_function(hltapi_method)

        for method in native_methods:
            server.register_function(partial(native_method, method), method)
        for method in hltapi_methods:
            if method in native_methods: # collision in names
                method_hlt_name = 'hlt_%s' % method
            else:
                method_hlt_name = method
            server.register_function(partial(hltapi_method, method), method_hlt_name)
        server.register_function(server.funcs.keys, 'get_methods') # should be last
        print('Started Stateless RPC proxy at port %s' % port)
        server.serve_forever()
    except KeyboardInterrupt:
        print('Done')
예제 #46
0
def ping():
    return True


setSpeed(40)
for x in xrange(_Servo0UL, _Servo0LL, -1):
    setCam0Position(x)
    sleep(.01)
for x in xrange(_Servo0LL, 50):
    setCam0Position(x)
    sleep(.01)

if __name__ == "__main__":

    server = SimpleJSONRPCServer((([
        (s.connect(('8.8.8.8', 80)), s.getsockname()[0], s.close())
        for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]
    ][0][1]), 10101))

    server.register_function(setSpeed)
    server.register_function(stop)
    server.register_function(goForward)
    server.register_function(goBackward)
    server.register_function(pivotLeft)
    server.register_function(pivotRight)
    server.register_function(ping)
    server.register_function(setCam0Position)

    try:
        print "Server listening..."
        server.serve_forever()
    except KeyboardInterrupt:
예제 #47
0
                      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:
        if not options.ports:
            server = SimpleJSONRPCServer((options.host, int(options.port)))

            nlp = StanfordCoreNLP(options.corenlp,
                                  properties=options.properties)
            server.register_function(nlp.parse)

            print 'Serving on http://%s:%s' % (options.host, options.port)

            server.serve_forever()
        else:
            server = SimpleJSONRPCServer((options.host, int(options.port)))
            lb = CoreNLPLoadBalancer(options)
            server.register_function(lb.send)
            server.register_function(lb.getAll)
            server.register_function(lb.getCompleted)
            server.register_function(lb.getForKey)
예제 #48
0
    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()
예제 #49
0
logging.basicConfig(format=LOGGER_FORMAT)
LOGGER = logging.getLogger('backend_server')
LOGGER.setLevel(logging.DEBUG)


def get_preference_for_user(user_id):
    """ Get user's preference in an ordered class list. """
    LOGGER.debug("get_preference_for_user is called with %s", str(user_id))
    db = mongodb_client.get_db()
    model = db[PREFERENCE_MODEL_TABLE_NAME].find_one({'userId': user_id})
    if model is None:
        return []
    sorted_tuples = sorted(list(model['preference'].items()),
                           key=operator.itemgetter(1),
                           reverse=True)
    sorted_list = [x[0] for x in sorted_tuples]
    sorted_value_list = [x[1] for x in sorted_tuples]

    if math.isclose(float(sorted_value_list[0]), float(sorted_value_list[-1])):
        return []

    return sorted_list


# Threading RPC server.
RPC_SERVER = SimpleJSONRPCServer((SERVER_HOST, SERVER_PORT))
RPC_SERVER.register_function(get_preference_for_user, 'getPreferenceForUser')

LOGGER.info("Starting RPC server on %s:%d", SERVER_HOST, SERVER_PORT)

RPC_SERVER.serve_forever()
예제 #50
0

def get_one_news():
    print("getOneNews is called...")
    news = operations.getOneNews()
    return json.loads(dumps(news))


def get_news_summaries_for_user(user_id, page_num):
    """ get news summaries for a user """
    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):
    """ send click news log from a user """
    print("log_news_click_for_user is called with %s and %s" %
          (user_id, news_id))
    operations.logNewsClickForUser(user_id, news_id)


server = SimpleJSONRPCServer((SERVER_HOST, SERVER_PORT))
server.register_function(add, 'add')
server.register_function(get_one_news, 'getOneNews')
server.register_function(get_news_summaries_for_user,
                         'getNewsSummariesForUser')
server.register_function(log_news_click_for_user, 'logNewsClickForUser')

print("Starting RPC server on %s:%d" % (SERVER_HOST, SERVER_PORT))
server.serve_forever()
def main():
    server = SimpleJSONRPCServer(('localhost', 7002))
    server.register_function(lengths)
    print("Starting server")
    server.serve_forever()
예제 #52
0
    def init_server(self, config, fd, is_gui):
        host = config.get('rpchost', '127.0.0.1')
        port = config.get('rpcport', 0)
        try:
            server = SimpleJSONRPCServer((host, port), logRequests=False)
        except Exception as e:
            self.print_error('Warning: cannot initialize RPC server on host',
                             host, e)
            self.server = None
            os.close(fd)
            return
        os.write(
            fd, bytes(repr((server.socket.getsockname(), time.time())),
                      'utf8'))
        os.close(fd)
        self.server = server
        server.timeout = 0.1
        server.register_function(self.ping, 'ping')
        if is_gui:
            server.register_function(self.run_gui, 'gui')
        else:
            server.register_function(self.run_daemon, 'daemon')
            self.cmd_runner = Commands(self.config, None, self.network)
            for cmdname in known_commands:
                server.register_function(getattr(self.cmd_runner, cmdname),
                                         cmdname)
            server.register_function(self.run_cmdline, 'run_cmdline')

        self.server = server