class DragonCorrectionDialog(): def __init__(self, heard): self.completed = False self.setup_XMLRPC_server() dlg = wx.TextEntryDialog(None, "Correct with...", caption="Correction Dialog", defaultValue=heard) dlg.ShowModal() self.correction = dlg.GetValue() self.completed = True # start server, tk main loop def start_server(): while not self.server_quit: self.server.handle_request() Timer(1, start_server).start() # backup plan in case for whatever reason Dragon doesn't shut it down: Timer(60, self.xmlrpc_kill).start() def setup_XMLRPC_server(self): self.server_quit = 0 self.server = SimpleXMLRPCServer(("127.0.0.1", LISTENING_PORT), allow_none=True) self.server.register_function(self.xmlrpc_get_message, "get_message") self.server.register_function(self.xmlrpc_kill, "kill") def xmlrpc_kill(self): self.server_quit = 1 os.kill(os.getpid(), signal.SIGTERM) def xmlrpc_get_message(self): print "get message called" if self.completed: Timer(1, self.xmlrpc_kill).start() return self.correction else: return None
def __init__(self, registerInstance, server_address, keyFile=DEFAULTKEYFILE, certFile=DEFAULTCERTFILE, caFile = DEFAULTCAFILE, logRequests=True): """Secure Documenting XML-RPC server. It it very similar to DocXMLRPCServer but it uses HTTPS for transporting XML data. """ SimpleXMLRPCServer.__init__(self, server_address, SecureXMLRPCRequestHandler, logRequests) self.logRequests = logRequests self.register_introspection_functions() # init stuff, handle different versions: try: SimpleXMLRPCDispatcher.__init__(self) except TypeError: # An exception is raised in Python 2.5 as the prototype of the __init__ # method has changed and now has 3 arguments (self, allow_none, encoding) SimpleXMLRPCDispatcher.__init__(self, False, None) SocketServer.BaseServer.__init__(self, server_address, SecureXMLRPCRequestHandler) self.register_instance(registerInstance) # for some reason, have to register instance down here! # SSL socket stuff ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(keyFile) ctx.use_certificate_file(certFile) # verify ctx.load_verify_locations(caFile) ctx.set_verify(SSL.VERIFY_PEER|SSL.VERIFY_FAIL_IF_NO_PEER_CERT, self._verify) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() # requests count and condition, to allow for keyboard quit via CTL-C self.requests = 0 self.rCondition = Condition()
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "hs:p:", ["help"]) serv = "localhost" port = 8088 for opt, val in opts: if opt in ("-h", "--help"): usage() sys.exit(0) elif opt == "-s": serv = val elif opt == "-p": port = int(val) server = SimpleXMLRPCServer((serv, port), RequestHandler, True, True) server.register_introspection_functions() server.serve_forever() except getopt.GetoptError as err: print str(err) usage() sys.exit(1) except ValueError: usage() sys.exit(1) except KeyboardInterrupt: sys.exit(0)
def system_listMethods(self): methods = self.funcs.keys() if self.instance is not None: if hasattr(self.instance, '_listMethods'): methods = SimpleXMLRPCServer.remove_duplicates( methods + list_public_methods(self.instance) ) elif not hasattr(self.instance, '_dispatch'): methods = SimpleXMLRPCServer.remove_duplicates( methods + list_public_methods(self.instance))
def __init__(self, password, hostname, port, server_list): self.password = password self.myUrl = "http://" + hostname + ":" + port self.server_list = server_list servers = self.update_server_list() if servers: for server in self.aug_network(servers[0]): self.aug_network(server) server = SimpleXMLRPCServer((hostname, int(port))) if not server.register_function(self.handle_request, "handle_request"): utils.srv(server)
class Receptive_XML_RPC(Thread): def __init__(self, my_host, my_port, GUI_functions): Thread.__init__(self) self.host = my_host # server XMLRPC i = 0 while 1: try: self.server = SimpleXMLRPCServer((self.host, my_port + i)) break except: i += 1 self.port = my_port + i # functions callable by the GUI self.server.register_instance(GUI_functions) # getPort -------------------- def getPort(self): return self.port # getClass -------------------- def getClass(self, host, port): return Emissive_XML_RPC(host, port) # kill -------------------- def kill(self): # Send a message to awake it. try: url = str(self.host) + ":"+str(self.port) newServer = xmlrpclib.Server(url) newServer.isAlive() except : pass # run -------------------- def run(self): """ Receive messages from the GUI and process them""" while globalvars.ALIVE: self.server.handle_request() print "End of Xml connection..."
class ServerThread( threading.Thread ) : def __init__( self, case ) : self.case = case threading.Thread.__init__( self ) print "starting local Ophidian server..." self.ProblemServer = ophidian.ProblemServer() self.ProblemServer.RunDir = 'RunDir' # check the run directory for cached problems self.ProblemServer.InitProblemList() # load the first problem, if it exists, exit otherwise if self.ProblemServer.ProblemList.__contains__(case) : self.ProblemServer.ProblemList = [case] print "Loading CUBE data for problem " + case self.ProblemServer.LoadProblem( case ) print "Starting server..." self.server = SimpleXMLRPCServer(('127.0.0.1', 8000 )) self.server.register_function(self.ProblemServer.GetProblem) self.server.register_function(self.ProblemServer.GetBlock) self.server.register_function(self.ProblemServer.CheckInBlock) else : print "No problems found. Ophidian server shutting down." def run( self ) : print "Now serving problem " + self.ProblemServer.Problem.problemname self.server.serve_forever()
def _dispatch(self, method, params, **kwargs): """Dispatch a rpc call to the appropriate method with parameters. This method is copied from SimpleXMLRPCServer but adds kwargs so that REST methods can receive keyword arguments rather than just list of parameters, which is all XMLRPC supports. Args: method: string, method name params: tuple, list of arguments kwargs: optional, dict of keyword arguments Returns: output from the called method Raises: Exception: if unsupported method is called """ func = None try: func = self.funcs[method] except KeyError: if self.instance is not None: if hasattr(self.instance, '_dispatch'): return self.instance._dispatch(method, params, kwargs) else: try: func = SimpleXMLRPCServer.resolve_dotted_attribute( self.instance, method, self.allow_dotted_names) except AttributeError: pass if func is not None: return func(*params, **kwargs) else: raise Exception('method "%s" is not supported' % method)
def setup_XMLRPC_server(self): self.server_quit = 0 comm = Communicator() self.server = SimpleXMLRPCServer(("127.0.0.1", comm.com_registry["status"]), allow_none=True) self.server.register_function(self.xmlrpc_kill, "kill") self.server.register_function(self.xmlrpc_hint, "hint") self.server.register_function(self.xmlrpc_text, "text")
def _dispatch(self, method, params): func = None try: func = self.funcs[method] except KeyError: if self.instance is not None: if hasattr(self.instance, '_dispatch'): return self.instance._dispatch(method, params) else: try: func = SimpleXMLRPCServer.resolve_dotted_attribute( self.instance, method, True ) except AttributeError: pass if func is not None: try: if type(params) is types.ListType: response = func(*params) else: response = func(**params) return response except TypeError: return Fault(-32602, 'Invalid parameters: ') except: err_lines = traceback.format_exc().splitlines() trace_string = '%s | %s' % (err_lines[-3], err_lines[-1]) fault = jsonrpclib.Fault(-32603, 'Server error: %s' % trace_string) return fault else: return Fault(-32601, 'Method %s not supported.' % method)
def list_public_methods(obj): """Returns a list of attribute strings, found in the specified object, which represent callable attributes""" methods = SimpleXMLRPCServer.list_public_methods(obj) methods = [dotify(m) for m in methods if is_public(getattr(obj, m, None))] return methods
def _dispatch(self, method, params): func = None try: func = self.funcs[method] except KeyError: if self.instance is not None: if hasattr(self.instance, "_dispatch"): return self.instance._dispatch(method, params) else: try: func = SimpleXMLRPCServer.resolve_dotted_attribute(self.instance, method, True) except AttributeError: pass if func is not None: try: if type(params) is types.ListType: # MODIFIED to pass service method name as well response = func(method, *params) else: # MODIFIED to pass service method name as well response = func(method, **params) return response except TypeError: return Fault(-32602, "Invalid parameters.") except: err_lines = traceback.format_exc().splitlines() trace_string = "%s | %s" % (err_lines[-3], err_lines[-1]) fault = jsonrpclib.Fault(-32603, "Server error: %s" % trace_string) return fault else: return Fault(-32601, "Method %s not supported." % method)
def _dispatch(self, method, params): """Dispatches the XML-RPC method. XML-RPC calls are forwarded to a registered function that matches the called XML-RPC method name. If no such function exists then the call is forwarded to the registered instance, if available. If the registered instance has a _dispatch method then that method will be called with the name of the XML-RPC method and its parameters as a tuple e.g. instance._dispatch('add',(2,3)) If the registered instance does not have a _dispatch method then the instance will be searched to find a matching method and, if found, will be called. Methods beginning with an '_' are considered private and will not be called. """ func = None try: # check to see if a matching function has been registered func = self.funcs[method] except KeyError: if self.instance is not None: # check for a _dispatch method if hasattr(self.instance, '_dispatch'): return self.instance._dispatch(method, params) else: # call instance method directly try: func = SimpleXMLRPCServer.resolve_dotted_attribute( self.instance, method, self.allow_dotted_names ) except AttributeError: pass if func is not None: try: # since we are using a keyword xmlrpc proxy this is sending # the info comes in form of args and kwargs # so params has 2 items, the first being a list or tuple # and the second a dictionary if len(params) == 2 and isinstance(params[1],dict) and\ ( isinstance(params[0],list) or isinstance(params[0],tuple) ) : return func(*params[0], **params[1]) else: # this is the default way in case a normal xmlrpclib.ServerProxy is used return func(*params) except Exception: # extended functionality to let the client have the full traceback msg = traceback.format_exc() raise xmlrpclib.Fault(1, msg) else: raise Exception('method "%s" is not supported' % method)
def __init__(self) : Thread.__init__(self) self.n = 0 self.uniqueRequests = [] self.numDoneSent = 0 self.server = SimpleXMLRPCServer(("0.0.0.0", port)) self.server.register_function(self.nextInput, "nextInput") self.lock = Lock()
def setup_XMLRPC_server(self): self.server_quit = 0 comm = Communicator() self.server = SimpleXMLRPCServer(("127.0.0.1", comm.com_registry["hmc"]), allow_none=True) self.server.register_function(self.xmlrpc_do_action, "do_action") self.server.register_function(self.xmlrpc_complete, "complete") self.server.register_function(self.xmlrpc_get_message, "get_message") self.server.register_function(self.xmlrpc_kill, "kill")
def test_dotted_attribute(self): # Raises an AttributeError because private methods are not allowed. self.assertRaises(AttributeError, SimpleXMLRPCServer.resolve_dotted_attribute, str, "__add") self.assertTrue(SimpleXMLRPCServer.resolve_dotted_attribute(str, "title")) # Get the test to run faster by sending a request with test_simple1. # This avoids waiting for the socket timeout. self.test_simple1()
def setup_XMLRPC_server(self): self.server_quit = 0 comm = Communicator() self.server = SimpleXMLRPCServer(("127.0.0.1", comm.com_registry["sticky_list"]), allow_none=True) self.server.register_function(self.xmlrpc_kill, "kill") self.server.register_function(self.xmlrpc_add_symbol, "add_symbol") self.server.register_function(self.xmlrpc_remove_symbol, "remove_symbol") self.server.register_function(self.xmlrpc_clear, "clear")
def _dispatch(self, method, params): try: self.local.method = method return SimpleXMLRPCServer._dispatch(self, method, params) except: logging.exception('Exception in method %s', method) self.local.exception = utils.FormatExceptionOnly() raise
def main(): print ("init") server = SimpleXMLRPCServer(('0.0.0.0', int(SLAVE_DAEMON_PORT))) server.register_introspection_functions() server.register_instance(Node()) print ("starting server") server.serve_forever()
def main(self): msj="" host, port = "192.168.9.30", 9990 host, port = "localhost", 4321 sock=socket.socket() sock.connect((host,port)) self.menu(sock) self.clienteRemoto = SimpleXMLRPCServer((localhost, 4321),allow_none=True); #aqui abre los puertos para escuchar self.clienteRemoto.register_function(self.horaClienteLocal, "horaCliente")
class Network(object): def __init__(self, config,log): self.log = log xmlport = config.getValue("xmlport") xmlhost = config.getValue("xmlhost") udpport = config.getValue("udpport") udphost = config.getValue("udphost") self.xml = SimpleXMLRPCServer((xmlhost, xmlport)) self.udp = netServer(udphost,udpport,log) log.StartupMessage("* Attempting to start XML-RPC Server") self.udp.serve_forever() self.xmlThread = Thread( target = self.startXMLRPCServer ) self.xmlThread.setDaemon( True ) self.xmlThread.start() log.StartupMessage( " XML-RPC Server is up at port %d" % xmlport) def register_function(self,func,funcname): self.xml.register_function(func,funcname) self.udp.register_function(func,funcname) self.log.Notice("Registered funtion %s for network access" % funcname) def stopServices(self): self.udp.stopServer() self.udp.join() self.log.StartupMessage("* Attempting to stop XML-RPC Server") self.xml.server_close() #self.xmlThread.join() def startXMLRPCServer(self): self.xml.serve_forever()
def system_listMethods(self): """system.listMethods() => ['add', 'subtract', 'multiple'] Returns a list of the methods supported by the server.""" methods = self.funcs.keys() if self.instance is not None: # Instance can implement _listMethods to return a list of # methods if hasattr(self.instance, '_listMethods'): methods = SimpleXMLRPCServer.remove_duplicates( methods + self.instance._listMethods() ) # if the instance has a _dispatch method then we # don't have enough information to provide a list # of methods elif not hasattr(self.instance, '_dispatch'): methods = SimpleXMLRPCServer.remove_duplicates( methods + list_public_methods(self.instance) ) methods.sort() return methods
def _dispatch(self, method, params): """ Default method resolver and caller :param method: Name of the method to call :param params: List of arguments to give to the method :return: The result of the method """ func = None try: # Try with registered methods func = self.funcs[method] except KeyError: if self.instance is not None: # Try with the registered instance if hasattr(self.instance, '_dispatch'): # Instance has a custom dispatcher return self.instance._dispatch(method, params) else: # Resolve the method name in the instance try: func = xmlrpcserver.resolve_dotted_attribute(\ self.instance, method, True) except AttributeError: # Unknown method pass if func is not None: try: # Call the method if type(params) is utils.ListType: return func(*params) else: return func(**params) except TypeError as ex: # Maybe the parameters are wrong return Fault(-32602, 'Invalid parameters: {0}'.format(ex)) except: # Method exception err_lines = traceback.format_exc().splitlines() trace_string = '{0} | {1}'.format(err_lines[-3], err_lines[-1]) return Fault(-32603, 'Server error: {0}'.format(trace_string)) else: # Unknown method return Fault(-32601, 'Method {0} not supported.'.format(method))
class servidor: """main class""" configuraciones = {'puerto':6051, 'version_cliente':0.1,'version_server':0.1} def __init__(self): #self.leer_configuraciones() #oldstderr=sys.stderr sys.stderr=file('infoserver.log', 'w') self.server = SimpleXMLRPCServer(("", self.configuraciones['puerto'])) cpu_datos = allocate_lock() cpu_datos.acquire() cpu_da = [0,0] cpu_datos.release() self.server.register_instance(sesiones(cpu_datos,cpu_da)) a = cpu_datos,cpu_da start_new_thread(cpu_funcion, a) def run(self): self.server.serve_forever()
class RPCServer(Thread) : def __init__(self) : Thread.__init__(self) self.n = 0 self.uniqueRequests = [] self.numDoneSent = 0 self.server = SimpleXMLRPCServer(("0.0.0.0", port)) self.server.register_function(self.nextInput, "nextInput") self.lock = Lock() def nextInput(self, ip) : self.lock.acquire() if self.uniqueRequests.count(ip) == 0 : self.uniqueRequests.append(ip) if self.n >= len(input_files) : self.numDoneSent += 1 if self.numDoneSent >= len(self.uniqueRequests) : shutdown(1) self.lock.release() return -1 rtn = self.n self.n += 1 self.lock.release() return rtn def run(self) : self.server.serve_forever()
def __init__(self): #self.leer_configuraciones() #oldstderr=sys.stderr sys.stderr=file('infoserver.log', 'w') self.server = SimpleXMLRPCServer(("", self.configuraciones['puerto'])) cpu_datos = allocate_lock() cpu_datos.acquire() cpu_da = [0,0] cpu_datos.release() self.server.register_instance(sesiones(cpu_datos,cpu_da)) a = cpu_datos,cpu_da start_new_thread(cpu_funcion, a)
def my_dispatch(self, methodName, params, auth, client_addr): """Dispatches the XML-RPC method. XML-RPC calls are forwarded to a registered function that matches the called XML-RPC method name. If no such function exists then the call is forwarded to the registered instance, if available. If the registered instance has a _dispatch method then that method will be called with the name of the XML-RPC method, its parameters as a tuple e.g. instance._dispatch('add',(2,3)) If the registered instance does not have a _dispatch method then the instance will be searched to find a matching method and, if found, will be called. Methods beginning with an '_' (except _dispatch) are considered private and will not be called. """ kwdargs = {} func = None # check for a _dispatch method if (self.instance is not None) and hasattr(self.instance, '_dispatch'): return self.instance._dispatch(methodName, params, kwdargs, auth, client_addr) try: # check to see if a matching function has been registered func = self.funcs[methodName] except KeyError: if self.instance is not None: # call instance method directly try: func = SimpleXMLRPCServer.resolve_dotted_attribute( self.instance, methodName, self.allow_dotted_names ) except AttributeError: pass if func is not None: return func(*params, **kwdargs) else: raise Error('method "%s" is not supported' % methodName)
def __init__(self, protocol, address, port, decks, total, packsize): SyncEntity.__init__(self, decks, total, packsize) self.address = address self.port = port self.protocol = protocol if protocol == 'xml-rpc': from SimpleXMLRPCServer import SimpleXMLRPCServer server = SimpleXMLRPCServer((address, port), allow_none=True) elif protocol == 'json-rpc': #from SimpleJsonRPCServer import SimpleJSONRPCServer as Server server = SimpleJSONRPCServer((address, port)) else: raise RuntimeException("Unknown RPC protocol: %s" % protocol) server.register_function(self.applyPayload) server.register_function(self.append) server.register_function(self.__contains__) self.server = server
def __init__(self, config,log): self.log = log xmlport = config.getValue("xmlport") xmlhost = config.getValue("xmlhost") udpport = config.getValue("udpport") udphost = config.getValue("udphost") self.xml = SimpleXMLRPCServer((xmlhost, xmlport)) self.udp = netServer(udphost,udpport,log) log.StartupMessage("* Attempting to start XML-RPC Server") self.udp.serve_forever() self.xmlThread = Thread( target = self.startXMLRPCServer ) self.xmlThread.setDaemon( True ) self.xmlThread.start() log.StartupMessage( " XML-RPC Server is up at port %d" % xmlport)
def _dispatch(self, method, params): if self.server.instance is None: logging.error("Client without a server instance!") raise AskgodException("Internal server error.") # call instance method directly func = None try: func = SimpleXMLRPCServer.resolve_dotted_attribute( self.server.instance, method, self.server.allow_dotted_names) except Exception as e: logging.info("Failed to resolv '%s': %s" % (method, e)) raise AskgodException("Unable to resolve method name.") if not func: logging.info("Function '%s' doesn't exist." % func) raise AskgodException("Invalid method name.") # Per connection data (address, DB connection, request) client = {} client['client_address'] = self.client_address[0] client['db_store'] = Store(self.server.database) client['request'] = self.request forwarded_address = self.headers.get("X-Forwarded-For", "") if forwarded_address: client['client_address'] = forwarded_address # Actually call the function try: retval = func(client, *params) except not AskgodException: logging.error(traceback.format_exc()) raise AskgodException("Internal server error.") # Attempt to close the DB connection (if still there) try: client['db_store'].commit() client['db_store'].close() except: pass return retval
# python 2 import SimpleXMLRPCServer except ImportError: # python3 import xmlrpc.server as SimpleXMLRPCServer class TestRhnpush(TestServer.TestServer): def __init__(self): TestServer.TestServer.__init__(self) self._init_app() def _init_app(self): self.app = server.app.packages.Packages() def getApp(self): return self.app if __name__ == "__main__": server = TestRhnpush() app = server.getApp() print((app.test_login(server.getUsername(), server.getPassword()))) print((app.listChannel(['wregglej-test'], "wregglej", "bm8gv5z2"))) print((app.listChannelSource(['wregglej-test'], "wregglej", "bm8gv5z2"))) server = SimpleXMLRPCServer.SimpleXMLRPCServer(addr=('', 16000)) for func in app.functions: print(func) server.register_function(getattr(app, func), name="app.%s" % (func)) server.serve_forever()
def __init__(self, channel=26, channel_max=11, channel_min=11): gr.top_block.__init__(self, "Top Block") ################################################## # Parameters ################################################## self.channel = channel self.channel_max = channel_max self.channel_min = channel_min ################################################## # Variables ################################################## self.samp_rate = samp_rate = 4000000 ################################################## # Blocks ################################################## self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer( ('localhost', 8080), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread( target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(('', "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq( 1000000 * (2400 + 5 * (channel - 10)), 0) self.uhd_usrp_source_0.set_gain(40, 0) self.uhd_usrp_source_0.set_antenna('RX2', 0) self.uhd_usrp_source_0.set_auto_dc_offset(False, 0) self.uhd_usrp_source_0.set_auto_iq_balance(False, 0) self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff( 0.00016, 1) self.rftap_rftap_encap_0 = rftap.rftap_encap(2, 195, '') self.ieee802_15_4_packet_sink_0 = ieee802_15_4.packet_sink(10) self.epy_block_0 = epy_block_0.blk() self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff( 2, 0.000225, 0.5, 0.03, 0.0002) self.blocks_sub_xx_0 = blocks.sub_ff(1) self.blocks_socket_pdu_0_0_0 = blocks.socket_pdu( "UDP_CLIENT", '127.0.0.1', '52002', 10000, False) self.blocks_message_debug_0 = blocks.message_debug() self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(1) ################################################## # Connections ################################################## self.msg_connect((self.epy_block_0, 'out'), (self.rftap_rftap_encap_0, 'in')) self.msg_connect((self.ieee802_15_4_packet_sink_0, 'out'), (self.blocks_message_debug_0, 'print_pdu')) self.msg_connect((self.ieee802_15_4_packet_sink_0, 'out'), (self.epy_block_0, 'in')) self.msg_connect((self.rftap_rftap_encap_0, 'out'), (self.blocks_socket_pdu_0_0_0, 'pdus')) self.connect((self.analog_quadrature_demod_cf_0, 0), (self.blocks_sub_xx_0, 0)) self.connect((self.analog_quadrature_demod_cf_0, 0), (self.single_pole_iir_filter_xx_0, 0)) self.connect((self.blocks_sub_xx_0, 0), (self.digital_clock_recovery_mm_xx_0, 0)) self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.ieee802_15_4_packet_sink_0, 0)) self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_sub_xx_0, 1)) self.connect((self.uhd_usrp_source_0, 0), (self.analog_quadrature_demod_cf_0, 0))
def __init__(self): gr.top_block.__init__(self, "OFDM Single") Qt.QWidget.__init__(self) self.setWindowTitle("OFDM Single") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "vr1_rx") if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"): self.restoreGeometry(self.settings.value("geometry").toByteArray()) else: self.restoreGeometry( self.settings.value("geometry", type=QtCore.QByteArray)) ################################################## # Variables ################################################## self.vr1_pc = vr1_pc = ((-27, -14, -7, 7, 14, 27), ) self.vr1_pattern2 = vr1_pattern2 = [1, -1, 1, -1] self.vr1_pattern1 = vr1_pattern1 = [0., 1.41421356, 0., -1.41421356] self.fft_len = fft_len = 64 self.zcpu = zcpu = psutil self._xmlrpcport_config = ConfigParser.ConfigParser() self._xmlrpcport_config.read('./default') try: xmlrpcport = self._xmlrpcport_config.getint("rx", "xmlrpcport") except: xmlrpcport = 0 self.xmlrpcport = xmlrpcport self.vr1_sw2 = vr1_sw2 = [ 0., 0., 0., 0., 0., 0., ] + vr1_pattern2 * ((fft_len - 12) / len(vr1_pattern2)) + [ 0., 0., 0., 0., 0., 0., ] self.vr1_sw1 = vr1_sw1 = [ 0., 0., 0., 0., 0., 0., ] + vr1_pattern1 * ((fft_len - 12) / len(vr1_pattern1)) + [ 0., 0., 0., 0., 0., 0., ] self.vr1_ps = vr1_ps = ((-1, 1, 1, -1, -1, -1), ) self.vr1_oc = vr1_oc = (sorted( tuple( set([x for x in range(-26, 27)]) - set(vr1_pc[0]) - set([ 0, ]))), ) self._usrpip_config = ConfigParser.ConfigParser() self._usrpip_config.read('./default') try: usrpip = self._usrpip_config.get("usrp", "ip") except: usrpip = "127.0.0.1" self.usrpip = usrpip self._txoutport_config = ConfigParser.ConfigParser() self._txoutport_config.read('./default') try: txoutport = self._txoutport_config.get("usrp", "txoutport") except: txoutport = "2666" self.txoutport = txoutport self.tx_goodput = tx_goodput = 0 self._timeout_config = ConfigParser.ConfigParser() self._timeout_config.read('./default') try: timeout = self._timeout_config.getint("global", "zmqtimeout") except: timeout = 100 self.timeout = timeout self._samprate_config = ConfigParser.ConfigParser() self._samprate_config.read('./default') try: samprate = self._samprate_config.getfloat("usrp_hydra", "samprate1") except: samprate = 4e6 self.samprate = samprate self.rx_goodput = rx_goodput = 0 self._maxnoutput_config = ConfigParser.ConfigParser() self._maxnoutput_config.read('./default') try: maxnoutput = self._maxnoutput_config.getint("global", "maxnoutput") except: maxnoutput = 100 self.maxnoutput = maxnoutput self._freq_config = ConfigParser.ConfigParser() self._freq_config.read('./default') try: freq = self._freq_config.getfloat("usrp_hydra", "txfreq1") except: freq = 4.4e9 self.freq = freq self.cpu_percent = cpu_percent = 0 self.amplitude = amplitude = 0.01 ################################################## # Blocks ################################################## self.probe1_1_0 = blocks.probe_rate(gr.sizeof_char * 1, 500.0, 0.15) self.probe1_1 = blocks.probe_rate(gr.sizeof_char * 1, 500.0, 0.15) self._amplitude_range = Range(0, 1, 0.01, 0.01, 200) self._amplitude_win = RangeWidget(self._amplitude_range, self.set_amplitude, 'amplitude', "counter_slider", float) self.top_layout.addWidget(self._amplitude_win) self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer( ('127.0.0.1', xmlrpcport), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread( target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(samprate) self.uhd_usrp_source_0.set_center_freq(freq, 0) self.uhd_usrp_source_0.set_normalized_gain(0, 0) self.uhd_usrp_source_0.set_antenna('RX2', 0) self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0.set_samp_rate(samprate) self.uhd_usrp_sink_0.set_center_freq(freq + 4e6, 0) self.uhd_usrp_sink_0.set_normalized_gain(1.0, 0) self.uhd_usrp_sink_0.set_antenna('TX/RX', 0) def _tx_goodput_probe(): while True: val = self.probe1_1_0.rate() try: self.set_tx_goodput(val) except AttributeError: pass time.sleep(1.0 / (10)) _tx_goodput_thread = threading.Thread(target=_tx_goodput_probe) _tx_goodput_thread.daemon = True _tx_goodput_thread.start() def _rx_goodput_probe(): while True: val = self.probe1_1.rate() try: self.set_rx_goodput(val) except AttributeError: pass time.sleep(1.0 / (10)) _rx_goodput_thread = threading.Thread(target=_rx_goodput_probe) _rx_goodput_thread.daemon = True _rx_goodput_thread.start() self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c( 1024, #size firdes.WIN_RECTANGULAR, #wintype 0, #fc 100, #bw "", #name 1 #number of inputs ) self.qtgui_waterfall_sink_x_0.set_update_time(0.10) self.qtgui_waterfall_sink_x_0.enable_grid(False) self.qtgui_waterfall_sink_x_0.enable_axis_labels(True) if not True: self.qtgui_waterfall_sink_x_0.disable_legend() if "complex" == "float" or "complex" == "msg_float": self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True) labels = ['', '', '', '', '', '', '', '', '', ''] colors = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(1): if len(labels[i]) == 0: self.qtgui_waterfall_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i]) self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i]) self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i]) self.qtgui_waterfall_sink_x_0.set_intensity_range(-140, 10) self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance( self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_waterfall_sink_x_0_win) self.digital_ofdm_tx_0 = digital.ofdm_tx(fft_len=fft_len, cp_len=16, packet_length_tag_key="vr1tx", occupied_carriers=vr1_oc, pilot_carriers=vr1_pc, pilot_symbols=vr1_ps, sync_word1=vr1_sw1, sync_word2=vr1_sw2, bps_header=1, bps_payload=1, rolloff=0, debug_log=False, scramble_bits=False) self.digital_ofdm_rx_0 = digital.ofdm_rx( fft_len=fft_len, cp_len=16, frame_length_tag_key='frame_' + "vr1rx", packet_length_tag_key="vr1rx", occupied_carriers=vr1_oc, pilot_carriers=vr1_pc, pilot_symbols=vr1_ps, sync_word1=vr1_sw1, sync_word2=vr1_sw2, bps_header=1, bps_payload=1, debug_log=False, scramble_bits=False) self.digital_burst_shaper_xx_0 = digital.burst_shaper_cc( (([])), 2000, 1000, False, "vr1tx") def _cpu_percent_probe(): while True: val = self.zcpu.cpu_percent() try: self.set_cpu_percent(val) except AttributeError: pass time.sleep(1.0 / (1)) _cpu_percent_thread = threading.Thread(target=_cpu_percent_probe) _cpu_percent_thread.daemon = True _cpu_percent_thread.start() self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, "vr1rx") (self.blocks_tagged_stream_to_pdu_0).set_processor_affinity([1]) self.blocks_tag_debug_0_0 = blocks.tag_debug(gr.sizeof_char * 1, "Tx'd Packet", "") self.blocks_tag_debug_0_0.set_display(True) self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_char * 1, "Rx'd Packet", "") self.blocks_tag_debug_0.set_display(True) self.blocks_random_pdu_0_0 = blocks.random_pdu(100, 100, chr(0xFF), 2) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream( blocks.byte_t, "vr1tx") self.blocks_pdu_set_0_0 = blocks.pdu_set(pmt.intern("vr1rx"), pmt.intern("generate")) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc( (amplitude, )) ################################################## # Connections ################################################## self.msg_connect((self.blocks_pdu_set_0_0, 'pdus'), (self.blocks_random_pdu_0_0, 'generate')) self.msg_connect((self.blocks_random_pdu_0_0, 'pdus'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.blocks_pdu_set_0_0, 'pdus')) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.digital_burst_shaper_xx_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_tag_debug_0_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_ofdm_tx_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.probe1_1_0, 0)) self.connect((self.digital_burst_shaper_xx_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.digital_ofdm_rx_0, 0), (self.blocks_tag_debug_0, 0)) self.connect((self.digital_ofdm_rx_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.digital_ofdm_rx_0, 0), (self.probe1_1, 0)) self.connect((self.digital_ofdm_tx_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.digital_ofdm_rx_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.qtgui_waterfall_sink_x_0, 0))
def __init__(self): gr.top_block.__init__(self, "VR1 TX all-in-one") ################################################## # Variables ################################################## self.pilot_carriers = pilot_carriers = ((-27, -14, -7, 7, 14, 27),) self.pattern2 = pattern2 = [1, -1, 1, -1] self.pattern1 = pattern1 = [0., 1.41421356, 0., -1.41421356] self.fft_len = fft_len = 64 self.zcpu = zcpu = psutil self._xmlrpcport_config = ConfigParser.ConfigParser() self._xmlrpcport_config.read('./default') try: xmlrpcport = self._xmlrpcport_config.getint("vr1_tx", "xmlrpcport") except: xmlrpcport = 8081 self.xmlrpcport = xmlrpcport self._usrpip_config = ConfigParser.ConfigParser() self._usrpip_config.read('./default') try: usrpip = self._usrpip_config.get("usrp_hydra", "ip") except: usrpip = "127.0.0.1" self.usrpip = usrpip self._txport_config = ConfigParser.ConfigParser() self._txport_config.read('./default') try: txport = self._txport_config.get("vr1_tx", "port") except: txport = "2666" self.txport = txport self.tx_goodput = tx_goodput = 0 self.sync_word2 = sync_word2 = [0., 0., 0., 0., 0., 0.,] + pattern2 * ((fft_len-12)/len(pattern2)) +[0., 0., 0., 0., 0., 0.,] self.sync_word1 = sync_word1 = [0., 0., 0., 0., 0., 0.,] + pattern1 * ((fft_len-12)/len(pattern1)) +[0., 0., 0., 0., 0., 0.,] self._samprate_config = ConfigParser.ConfigParser() self._samprate_config.read('./default') try: samprate = self._samprate_config.getfloat("usrp_hydra", "samprate1") except: samprate = 0 self.samprate = samprate self._rxport_config = ConfigParser.ConfigParser() self._rxport_config.read('./default') try: rxport = self._rxport_config.get("usrp_hydra", "rxport1") except: rxport = "2666" self.rxport = rxport self.pilot_symbols = pilot_symbols = ((-1,1, 1, -1, -1, -1),) self.packet_len = packet_len = 100 self.occupied_carriers = occupied_carriers = (sorted(tuple(set([x for x in range(-26,27)]) - set(pilot_carriers[0]) - set([0,]))),) self._ip_config = ConfigParser.ConfigParser() self._ip_config.read('./default') try: ip = self._ip_config.get("vr1_tx", "ip") except: ip = "127.0.0.1" self.ip = ip self.cpu_percent = cpu_percent = 0 ################################################## # Blocks ################################################## self.ztxrate = blocks.probe_rate(gr.sizeof_char*1, 2000, 0.15) self.zeromq_push_sink_0 = zeromq.push_sink(gr.sizeof_gr_complex, 1, "tcp://" + ip + ":" + txport, 100, True, -1) self.xmlrpc_server_0_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(('127.0.0.1', xmlrpcport), allow_none=True) self.xmlrpc_server_0_0.register_instance(self) self.xmlrpc_server_0_0_thread = threading.Thread(target=self.xmlrpc_server_0_0.serve_forever) self.xmlrpc_server_0_0_thread.daemon = True self.xmlrpc_server_0_0_thread.start() def _tx_goodput_probe(): while True: val = self.ztxrate.rate() try: self.set_tx_goodput(val) except AttributeError: pass time.sleep(1.0 / (10)) _tx_goodput_thread = threading.Thread(target=_tx_goodput_probe) _tx_goodput_thread.daemon = True _tx_goodput_thread.start() self.digital_ofdm_tx_0 = digital.ofdm_tx( fft_len=fft_len, cp_len=16, packet_length_tag_key="packet_len", occupied_carriers=occupied_carriers, pilot_carriers=pilot_carriers, pilot_symbols=pilot_symbols, sync_word1=sync_word1, sync_word2=sync_word2, bps_header=1, bps_payload=1, rolloff=0, debug_log=False, scramble_bits=False ) def _cpu_percent_probe(): while True: val = self.zcpu.cpu_percent() try: self.set_cpu_percent(val) except AttributeError: pass time.sleep(1.0 / (1)) _cpu_percent_thread = threading.Thread(target=_cpu_percent_probe) _cpu_percent_thread.daemon = True _cpu_percent_thread.start() self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samprate,True) self.blocks_tag_debug_0_0 = blocks.tag_debug(gr.sizeof_char*1, "Tx'd Packet", ""); self.blocks_tag_debug_0_0.set_display(True) self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, packet_len, "packet_len") self.analog_random_source_x_0 = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000)), True) ################################################## # Connections ################################################## self.connect((self.analog_random_source_x_0, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tag_debug_0_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.digital_ofdm_tx_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.ztxrate, 0)) self.connect((self.blocks_throttle_0, 0), (self.zeromq_push_sink_0, 0)) self.connect((self.digital_ofdm_tx_0, 0), (self.blocks_throttle_0, 0))
import SimpleXMLRPCServer running = True def finis(): global running running = False return 1 server = SimpleXMLRPCServer.SimpleXMLRPCServer(('127.0.0.1', 8000)) server.register_function(finis) while running: server.handle_request()
#!/bin/bash export UTGID exec -a ${UTGID} /usr/bin/python <</EOF import os, sys, socket, xmlrpclib,SimpleXMLRPCServer class XMLRPCTestSrv: def ping(self,who,count,size): ti = xmlrpclib.DateTime(); return (1,2,3.,4.,'hello_0',ti,True,(11,22,33.,44.,'hello_1',False,),[111,222,333.,444.,'hello_2',ti], {'d1':1111,'d2':2222,'d3':3333.,'d4':4444.,'ds':'hello_3'}) def log_req(self, code='-', size='-'): pass if __name__ == "__main__": port=8088 if len('${1}')>0: port=int('${1}') print 'Port:',port server = SimpleXMLRPCServer.SimpleXMLRPCServer((socket.gethostname(),port),logRequests=False) server.log_request = log_req server.register_instance(XMLRPCTestSrv()) print '..... XMLRPCTest server instance is now running.....' server.serve_forever() /EOF
""" get release version num """ return platform.release() def get_linux_distribution(self): ''' get info about linux distribution ''' return platform.linux_distribution() def get_architecture(self): """ return 64bit or 32bit """ return platform.architecture()[0] def get_node(self): """ return node name hostname """ return platform.node() if __name__ == '__main__': server = SimpleXMLRPCServer.SimpleXMLRPCServer((IP, PORT)) obj = Proc() server.register_instance(obj) print('rpc service start..') server.serve_forever()
#!/usr/bin/env python import xmlrpclib, SimpleXMLRPCServer, threading ############# # Handle the callbacks here: callback_handler = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", 20001)) def print_event(event_type, args, state): print "type: %s\nargs: %s\n state: %s\n\n" % (event_type, args, state) return True callback_handler.register_function(print_event) server_thread = threading.Thread(target=callback_handler.serve_forever) server_thread.start() ############ node = xmlrpclib.ServerProxy("http://127.0.0.1:20000/xm.rem") #setup our callback function: node.localproxy("xmlrpc.AddXRHandler", "pytest", "http://localhost:20001/RPC2") print node.localproxy("ConnectionTable.addConnectionHandler", \ "pytest.print_event", "my_state") raw_input("Press Enter to quit") #stop listening now
def main(): replica = Replica() server = SimpleXMLRPCServer.SimpleXMLRPCServer(("", 8000), allow_none=True) server.register_instance(replica) print("Replica ready.") server.serve_forever()
import SimpleXMLRPCServer def hello(): return "Hello World Python WS" server = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 8081)) server.register_function(hello) print "Webservice up and running in python... " server.serve_forever()
#!/usr/bin/env python import SimpleXMLRPCServer import xmlrpclib import sys, time, os, os.path import datetime from remoteapp import remote_client_db, convertdata sep = os.sep NAME = os.environ['COMPUTERNAME'] DOMAIN = os.environ['USERDNSDOMAIN'] server_name = lower('.'.join(NAME, DOMAIN)) paths = '%s%shddlab%sPerformance_Results%s' % (sep,sep,sep,sep) server = SimpleXMLRPCServer.SimpleXMLRPCServer((server_name,1332), logRequests=True, allow_none=True) server.register_introspection_functions() server.register_multicall_functions() #file_names = ["XQV03JDA.csv", "XQV03L1A.csv", "XQV03LJA.csv", "XQV03LKA.csv", "XQV03PRA.csv", "XQV03R6A.csv"] file_names = ["1 1.csv", "2 1.csv", "3 1.csv", "4 1.csv", "5 1.csv", "6 1.csv"] class gateway_connect: def __init__(self): self.script_filenames = [] self.performance_Result_file = '' def run_performance_testing(self, group, metrics): """the group list of iometer scripts are passed in to run the analysis between similar products""" self.script_filenames = group #paths = '%s%shddlab%sPerformance_Results%s' % (sep,sep,sep,sep) analysis.run(file_names, paths, metrics)
def __init__(self): gr.top_block.__init__(self, "Static RF or Single Path Rayleigh Faded RF") Qt.QWidget.__init__(self) self.setWindowTitle("Static RF or Single Path Rayleigh Faded RF") self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) ################################################## # Variables ################################################## self.usrpRate = usrpRate = 250e3 self.fd = fd = 50 self.fdTs = fdTs = fd*(1.0/usrpRate) self.fadeMode = fadeMode = False self.centreFreq = centreFreq = 1e6 self.baseband_multiplier = baseband_multiplier = 0.25 self.atten = atten = 0 ################################################## # Blocks ################################################## _fadeMode_check_box = Qt.QCheckBox("Fading Enabled") self._fadeMode_choices = {True: True, False: False} self._fadeMode_choices_inv = dict((v,k) for k,v in self._fadeMode_choices.iteritems()) self._fadeMode_callback = lambda i: _fadeMode_check_box.setChecked(self._fadeMode_choices_inv[i]) self._fadeMode_callback(self.fadeMode) _fadeMode_check_box.stateChanged.connect(lambda i: self.set_fadeMode(self._fadeMode_choices[bool(i)])) self.top_layout.addWidget(_fadeMode_check_box) self._atten_layout = Qt.QVBoxLayout() self._atten_tool_bar = Qt.QToolBar(self) self._atten_layout.addWidget(self._atten_tool_bar) self._atten_tool_bar.addWidget(Qt.QLabel("RF Attenuator Setting, dB"+": ")) self._atten_counter = Qwt.QwtCounter() self._atten_counter.setRange(0, 63, 0.5) self._atten_counter.setNumButtons(2) self._atten_counter.setValue(self.atten) self._atten_tool_bar.addWidget(self._atten_counter) self._atten_counter.valueChanged.connect(self.set_atten) self._atten_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot) self._atten_slider.setRange(0, 63, 0.5) self._atten_slider.setValue(self.atten) self._atten_slider.setMinimumWidth(200) self._atten_slider.valueChanged.connect(self.set_atten) self._atten_layout.addWidget(self._atten_slider) self.top_layout.addLayout(self._atten_layout) self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("0.0.0.0", 1234), allow_none=True) self.xmlrpc_server_0.register_instance(self) threading.Thread(target=self.xmlrpc_server_0.serve_forever).start() self.uhd_usrp_sink_0_0_0 = uhd.usrp_sink( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0_0_0.set_subdev_spec("B:AB", 0) self.uhd_usrp_sink_0_0_0.set_samp_rate(usrpRate) self.uhd_usrp_sink_0_0_0.set_center_freq(centreFreq, 0) self.uhd_usrp_sink_0_0_0.set_gain(0, 0) self.rccBlocks_channelModel_cc_0 = rccBlocks.channelModel_cc(randint(-10000,0), fdTs, 1.0, False, fadeMode) self.rccBlocks_VNXLabBrick_0 = rccBlocks.VNXLabBrick(atten) self._fd_tool_bar = Qt.QToolBar(self) self._fd_tool_bar.addWidget(Qt.QLabel("Doppler Rate, Hz"+": ")) self._fd_line_edit = Qt.QLineEdit(str(self.fd)) self._fd_tool_bar.addWidget(self._fd_line_edit) self._fd_line_edit.returnPressed.connect( lambda: self.set_fd(eng_notation.str_to_num(self._fd_line_edit.text().toAscii()))) self.top_layout.addWidget(self._fd_tool_bar) self.const_source_x_0_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 1.0) self.const_source_x_0 = gr.sig_source_c(0, gr.GR_CONST_WAVE, 0, 0, 1.0+1j) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1, usrpRate) self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vcc((baseband_multiplier, )) ################################################## # Connections ################################################## self.connect((self.const_source_x_0, 0), (self.rccBlocks_channelModel_cc_0, 0)) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.uhd_usrp_sink_0_0_0, 0)) self.connect((self.const_source_x_0_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.rccBlocks_VNXLabBrick_0, 0)) self.connect((self.rccBlocks_channelModel_cc_0, 0), (self.blocks_multiply_const_vxx_1, 0))
def rpc_server(): rpcserver = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 8004), logRequests=False) rpcserver.register_function(announce, 'announce') logger.debug('启动xml rpc server') rpcserver.serve_forever()
def http_multi_server(evt, numrequests, requestHandler=None): class TestInstanceClass: def div(self, x, y): return x // y def _methodHelp(self, name): if name == 'div': return 'This is the div function' def my_function(): '''This is my function''' return True class MyXMLRPCServer(SimpleXMLRPCServer.MultiPathXMLRPCServer): def get_request(self): # Ensure the socket is always non-blocking. On Linux, socket # attributes are not inherited like they are on *BSD and Windows. s, port = self.socket.accept() s.setblocking(True) return s, port if not requestHandler: requestHandler = SimpleXMLRPCServer.SimpleXMLRPCRequestHandler class MyRequestHandler(requestHandler): rpc_paths = [] serv = MyXMLRPCServer(("localhost", 0), MyRequestHandler, logRequests=False, bind_and_activate=False) serv.socket.settimeout(3) serv.server_bind() try: global ADDR, PORT, URL ADDR, PORT = serv.socket.getsockname() #connect to IP address directly. This avoids socket.create_connection() #trying to connect to "localhost" using all address families, which #causes slowdown e.g. on vista which supports AF_INET6. The server listens #on AF_INET only. URL = "http://%s:%d" % (ADDR, PORT) serv.server_activate() paths = ["/foo", "/foo/bar"] for path in paths: d = serv.add_dispatcher( path, SimpleXMLRPCServer.SimpleXMLRPCDispatcher()) d.register_introspection_functions() d.register_multicall_functions() serv.get_dispatcher(paths[0]).register_function(pow) serv.get_dispatcher(paths[1]).register_function( lambda x, y: x + y, 'add') evt.set() # handle up to 'numrequests' requests while numrequests > 0: serv.handle_request() numrequests -= 1 except socket.timeout: pass finally: serv.socket.close() PORT = None evt.set()
else: return 'Invalid Method [%s]' % method # functions available as web services class XMLRPC_register: def hello_world(self, t1, t2, validuser): if validuser: return t1 + '-' + t2 else: return "please register ur machine" if __name__ == '__main__': try: se = SimpleXMLRPCServer(("localhost", 8088), MySimpleXMLRPCRequestHandler, True, True) se.register_introspection_functions() se.serve_forever() except KeyboardInterrupt: print "Bye" #--------------------- new file starts here----------- ### client.py import os import base64 import xmlrpclib import urllib2 import cookielib class CookieAuthXMLRPCTransport(xmlrpclib.Transport):
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Signal Hunter Faked") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 2000000 self.xlate_decimation = xlate_decimation = 40 self.offset2 = offset2 = 0 self.offset = offset = samp_rate / 4 self.hunter_freq_0 = hunter_freq_0 = 0 self.gain = gain = 10 self.frequency = frequency = 930000000 self.filter_width = filter_width = 5120 self.fft_taps = fft_taps = filter.firdes.low_pass_2( 1, samp_rate, 2000, 1000, 0.1) ################################################## # Blocks ################################################## _offset2_sizer = wx.BoxSizer(wx.VERTICAL) self._offset2_text_box = forms.text_box( parent=self.GetWin(), sizer=_offset2_sizer, value=self.offset2, callback=self.set_offset2, label='offset2', converter=forms.int_converter(), proportion=0, ) self._offset2_slider = forms.slider( parent=self.GetWin(), sizer=_offset2_sizer, value=self.offset2, callback=self.set_offset2, minimum=-samp_rate / 2, maximum=samp_rate / 2, num_steps=1000, style=wx.SL_HORIZONTAL, cast=int, proportion=1, ) self.Add(_offset2_sizer) _offset_sizer = wx.BoxSizer(wx.VERTICAL) self._offset_text_box = forms.text_box( parent=self.GetWin(), sizer=_offset_sizer, value=self.offset, callback=self.set_offset, label='offset', converter=forms.int_converter(), proportion=0, ) self._offset_slider = forms.slider( parent=self.GetWin(), sizer=_offset_sizer, value=self.offset, callback=self.set_offset, minimum=-samp_rate / 2, maximum=samp_rate / 2, num_steps=1000, style=wx.SL_HORIZONTAL, cast=int, proportion=1, ) self.Add(_offset_sizer) _hunter_freq_0_sizer = wx.BoxSizer(wx.VERTICAL) self._hunter_freq_0_text_box = forms.text_box( parent=self.GetWin(), sizer=_hunter_freq_0_sizer, value=self.hunter_freq_0, callback=self.set_hunter_freq_0, label='hunter_freq_0', converter=forms.int_converter(), proportion=0, ) self._hunter_freq_0_slider = forms.slider( parent=self.GetWin(), sizer=_hunter_freq_0_sizer, value=self.hunter_freq_0, callback=self.set_hunter_freq_0, minimum=-100000, maximum=100000, num_steps=1000, style=wx.SL_HORIZONTAL, cast=int, proportion=1, ) self.Add(_hunter_freq_0_sizer) _frequency_sizer = wx.BoxSizer(wx.VERTICAL) self._frequency_text_box = forms.text_box( parent=self.GetWin(), sizer=_frequency_sizer, value=self.frequency, callback=self.set_frequency, label='Frequency', converter=forms.int_converter(), proportion=0, ) self._frequency_slider = forms.slider( parent=self.GetWin(), sizer=_frequency_sizer, value=self.frequency, callback=self.set_frequency, minimum=80000000, maximum=1100000000, num_steps=1000, style=wx.SL_HORIZONTAL, cast=int, proportion=1, ) self.Add(_frequency_sizer) self.zeromq_push_sink_1 = zeromq.push_sink(gr.sizeof_gr_complex, samp_rate, 'tcp://127.0.0.1:9001', 100, False, -1) self.zeromq_push_sink_0_0 = zeromq.push_sink(gr.sizeof_float, 1024, 'tcp://127.0.0.1:9000', 100, False, -1) self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer( ('localhost', 8080), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread( target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.wxgui_fftsink2_0_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate / xlate_decimation, fft_size=1024, fft_rate=15, average=False, avg_alpha=None, title='filtered_fft', peak_hold=False, ) self.Add(self.wxgui_fftsink2_0_0.win) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=frequency, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate, fft_size=1024, fft_rate=15, average=False, avg_alpha=None, title='master_plot', peak_hold=False, ) self.Add(self.wxgui_fftsink2_0.win) _gain_sizer = wx.BoxSizer(wx.VERTICAL) self._gain_text_box = forms.text_box( parent=self.GetWin(), sizer=_gain_sizer, value=self.gain, callback=self.set_gain, label='gain', converter=forms.int_converter(), proportion=0, ) self._gain_slider = forms.slider( parent=self.GetWin(), sizer=_gain_sizer, value=self.gain, callback=self.set_gain, minimum=0, maximum=50, num_steps=50, style=wx.SL_HORIZONTAL, cast=int, proportion=1, ) self.Add(_gain_sizer) self.freq_xlating_fft_filter_ccc_0 = filter.freq_xlating_fft_filter_ccc( xlate_decimation, (fft_taps), frequency + hunter_freq_0, samp_rate) self.freq_xlating_fft_filter_ccc_0.set_nthreads(1) self.freq_xlating_fft_filter_ccc_0.declare_sample_delay(0) _filter_width_sizer = wx.BoxSizer(wx.VERTICAL) self._filter_width_text_box = forms.text_box( parent=self.GetWin(), sizer=_filter_width_sizer, value=self.filter_width, callback=self.set_filter_width, label='filter_width', converter=forms.int_converter(), proportion=0, ) self._filter_width_slider = forms.slider( parent=self.GetWin(), sizer=_filter_width_sizer, value=self.filter_width, callback=self.set_filter_width, minimum=2048, maximum=40960, num_steps=100, style=wx.SL_HORIZONTAL, cast=int, proportion=1, ) self.Add(_filter_width_sizer) self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1) self.blocks_vector_to_stream_0 = blocks.vector_to_stream( gr.sizeof_gr_complex * 1, 1024) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1, samp_rate, True) self.blocks_stream_to_vector_2 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, samp_rate) self.blocks_stream_to_vector_1 = blocks.stream_to_vector( gr.sizeof_float * 1, 1024) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, 1024) self.blocks_complex_to_real_0 = blocks.complex_to_real(1) self.blocks_add_xx_0 = blocks.add_vcc(1) self.analog_sig_source_x_0_0 = analog.sig_source_c( samp_rate, analog.GR_SIN_WAVE, frequency + offset, 0.001, 0) self.analog_sig_source_x_0 = analog.sig_source_c( samp_rate, analog.GR_COS_WAVE, frequency + offset2, 0.001, 0) ################################################## # Connections ################################################## self.connect((self.analog_sig_source_x_0, 0), (self.blocks_add_xx_0, 1)) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_stream_to_vector_2, 0)) self.connect((self.analog_sig_source_x_0_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_add_xx_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_add_xx_0, 0), (self.freq_xlating_fft_filter_ccc_0, 0)) self.connect((self.blocks_add_xx_0, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.blocks_complex_to_real_0, 0), (self.blocks_stream_to_vector_1, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.blocks_stream_to_vector_1, 0), (self.zeromq_push_sink_0_0, 0)) self.connect((self.blocks_stream_to_vector_2, 0), (self.zeromq_push_sink_1, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_add_xx_0, 0)) self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_complex_to_real_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.freq_xlating_fft_filter_ccc_0, 0), (self.wxgui_fftsink2_0_0, 0))
class HaloRPC: def __init__(self): """ """ import string self.python_string = string import HaloRadio import HaloRadio.Song as Song import HaloRadio.Relay as Relay self.config = HaloRadio.conf self.configdb = HaloRadio.configdb self.hrSong = Song self.hrRelay = Relay def getCurrentSong(self): cursong = int(self.configdb.GetConfigItem("current_song")) if cursong == 0: currelay = int(self.configdb.GetConfigItem("current_relay")) r = self.hrRelay.Relay(currelay) return r.GetDisplayName() else: s = self.hrSong.Song(cursong) return s.GetDisplayName() server = SimpleXMLRPCServer.SimpleXMLRPCServer(("*", 7014)) server.register_instance(HaloRPC()) server.serve_forever()
def setUp(self): self.cgi = SimpleXMLRPCServer.CGIXMLRPCRequestHandler()
import SimpleXMLRPCServer, sys import factorizar usage = """ Usar serv_processes.py nroport ej: serv_processes.py 9000 """ if len(sys.argv) != 2: print usage sys.exit(-1) port = int(sys.argv[1]) server = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', port)) server.register_function(factorizar.factoriz_sum) server.serve_forever()
def launch_XMLRPC(hostname='', port=_xmlPort, nToTry=_nPortsToTry): """ launches the xmlrpc server into a separate thread Arguments: hostname: (OPTIONAL) name of the host for the server (defaults to be the name of the localhost) port: (OPTIONAL) the first port to try for the server nToTry: (OPTIONAL) the number of possible ports to try (in case the first can't be opened) """ if not hostname: import os hostname = os.environ.get('PYMOL_RPCHOST', 'localhost') global cgoDict, serv cgoDict = {} for i in range(nToTry): try: serv = SimpleXMLRPCServer.SimpleXMLRPCServer((hostname, port + i), logRequests=0, allow_none=True) except: serv = None else: break if serv: print('xml-rpc server running on host %s, port %d' % (hostname, port + i)) # import PyMOL API from pymol import api serv.register_instance(cmd) # legacy stuff with unique names serv.register_function(rpcPing, 'ping') serv.register_function(rpcResetCGO, 'resetCGO') serv.register_function(rpcRenderCGO, 'renderCGO') serv.register_function(rpcSphere, 'sphere') serv.register_function(rpcSpheres, 'spheres') serv.register_function(rpcCylinder, 'cylinder') serv.register_function(rpcDeleteObject, 'deleteObject') serv.register_function(rpcDeleteAll, 'deleteAll') serv.register_function(rpcLoadPDB, 'loadPDB') serv.register_function(rpcLoadMolBlock, 'loadMolBlock') serv.register_function(rpcLoadSurface, 'loadSurface') serv.register_function(rpcLoadSurfaceData, 'loadSurfaceData') serv.register_function(rpcLoadFile, 'loadFile') serv.register_function(rpcGetNames, 'getNames') serv.register_function(api.count_atoms, 'countAtoms') serv.register_function(rpcIdAtom, 'idAtom') serv.register_function(rpcHelp, 'help') serv.register_function(rpcGetAtomCoords, 'getAtomCoords') # legacy stuff, should be removed because overwrites API names! serv.register_function(rpcLabel, 'label') # pseudoatom serv.register_function(rpcRotate, 'rotate') serv.register_introspection_functions() t = threading.Thread(target=serv.serve_forever) t.setDaemon(1) t.start() else: print('xml-rpc server could not be started')
def start_listen(self): self.s = SimpleXMLRPCServer.SimpleXMLRPCServer( self.serveradd, logRequests=False) #start a RPC Server self.s.register_instance(self) # register RPC bject self.s.serve_forever() # start listening
def __init__(self): gr.top_block.__init__(self, "NBFM Receiver V2- F1ATB - MARCH 2021") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1200000 self.Largeur_filtre = Largeur_filtre = 10000 self.xlate_filter_taps = xlate_filter_taps = firdes.low_pass(1, samp_rate, Largeur_filtre/2, 1500) self.decim_LP = decim_LP = 16 self.Squelch = Squelch = -80 self.Gain_RF = Gain_RF = 30 self.Gain_IF = Gain_IF = 20 self.Gain_BB = Gain_BB = 20 self.FrRX = FrRX = 145000000 self.F_Fine = F_Fine = 0 ################################################## # Blocks ################################################## self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 9003), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread(target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.pluto_source_0 = iio.pluto_source('192.168.2.1', 145000000, int(samp_rate), 1000000, 32768, True, True, True, "manual", 50, '', True) self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass( 1, decim_LP*samp_rate/200, 5200, 1200, firdes.WIN_HAMMING, 6.76)) self.logpwrfft_x_0 = logpwrfft.logpwrfft_c( sample_rate=samp_rate/100, fft_size=2048, ref_scale=0.00001, frame_rate=samp_rate/100/2048, avg_alpha=1.0, average=False, ) self.iio_attr_updater_0_0 = iio.attr_updater('hardwaregain', str(int(Gain_RF*1.75)), 1000) self.iio_attr_updater_0 = iio.attr_updater('frequency', str(int(FrRX)), 1000) self.iio_attr_sink_0_0 = iio.attr_sink("ip:192.168.2.1", "ad9361-phy", "voltage0", 0, False, False) self.iio_attr_sink_0 = iio.attr_sink("ip:192.168.2.1", "ad9361-phy", "altvoltage0", 0, True, False) self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(30, (xlate_filter_taps), F_Fine, samp_rate) self.fractional_resampler_xx_0 = filter.fractional_resampler_cc(0, decim_LP/2) self.blocks_udp_sink_1 = blocks.udp_sink(gr.sizeof_short*2048, '127.0.0.1', 9002, 4096, True) self.blocks_udp_sink_0 = blocks.udp_sink(gr.sizeof_short*1, '127.0.0.1', 9001, 1000, True) self.blocks_pdu_remove_0 = blocks.pdu_remove(pmt.intern("key")) self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_gr_complex, int(1024*decim_LP), 204800, 0) self.blocks_float_to_short_1 = blocks.float_to_short(2048, 100) self.blocks_float_to_short_0 = blocks.float_to_short(1, 16000) self.analog_simple_squelch_cc_0 = analog.simple_squelch_cc(Squelch, 0.001) self.analog_nbfm_rx_0 = analog.nbfm_rx( audio_rate=int(samp_rate/120), quad_rate=int(samp_rate/30), tau=75e-6, max_dev=5e3, ) ################################################## # Connections ################################################## self.msg_connect((self.iio_attr_updater_0, 'out'), (self.iio_attr_sink_0, 'attr')) self.msg_connect((self.iio_attr_updater_0_0, 'out'), (self.iio_attr_sink_0_0, 'attr')) self.connect((self.analog_nbfm_rx_0, 0), (self.blocks_float_to_short_0, 0)) self.connect((self.analog_simple_squelch_cc_0, 0), (self.analog_nbfm_rx_0, 0)) self.connect((self.blocks_float_to_short_0, 0), (self.blocks_udp_sink_0, 0)) self.connect((self.blocks_float_to_short_1, 0), (self.blocks_udp_sink_1, 0)) self.connect((self.blocks_keep_m_in_n_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.fractional_resampler_xx_0, 0), (self.logpwrfft_x_0, 0)) self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.analog_simple_squelch_cc_0, 0)) self.connect((self.logpwrfft_x_0, 0), (self.blocks_float_to_short_1, 0)) self.connect((self.low_pass_filter_0, 0), (self.fractional_resampler_xx_0, 0)) self.connect((self.pluto_source_0, 0), (self.blocks_keep_m_in_n_0, 0)) self.connect((self.pluto_source_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
import SimpleXMLRPCServer def soucet(a, b): return a + b def rozdil(a, b): return a - b server = SimpleXMLRPCServer.SimpleXMLRPCServer(("", 8080)) server.register_function(soucet) server.register_function(rozdil) server.serve_forever()
def Run(self): server = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", self.app.port)) server.register_instance(PostAppServer(self.app)) while self.keepGoing: server.handle_request( ) self.running = False
def main(): # Get configuration yaml config_path = os.path.join(os.path.dirname(__file__), 'config.yaml') with open(config_path, 'r') as ymlfile: config = yaml.load(ymlfile) # Setup logging based on verbosity flag in config.yaml log = logging.getLogger('') log.setLevel(logging.DEBUG) log_format = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s") ch = logging.StreamHandler(sys.stdout) ch.setFormatter(log_format) log.addHandler(ch) if config['verbose']: log_path = os.path.dirname(__file__) + config['logging']['log_path'] fh = handlers.RotatingFileHandler( "%s/%s.log" % (log_path, config['logging']['log_name']), backupCount=7) fh.setFormatter(log_format) log.addHandler(fh) # Create Bank object which creates connection with bank server # a dummy counterpart is also available for use logging.info('Initializing Bank...') if config['devices']['bank']['dummy']: bank = DummyBank() else: bank = Bank(config['devices']['bank']['host'], config['devices']['bank']['port']) logging.info('Bank initialized.') # Create secmod object which creates connection with secmod psoc # a emulated counterpart is also available for use if config['devices']['hsm']['dummy']: logging.info('Initializing DummyHSM ') hsm = DummyHSM(verbose=config['verbose'], provision=True) logging.info('DummyHSM initialized.') else: logging.info('Initializing HSM...') hsm = HSM(verbose=config['verbose']) logging.info('HSM initialized.') # Create card object which connects and reconnects to inserted cards if config['devices']['card']['dummy']: logging.info('Initializing DummyCard...') card = DummyCard(verbose=config['verbose'], provision=True) logging.info('DummyCard initialized.') else: logging.info('Initializing Card...') card = Card(verbose=config['verbose']) logging.info('Card initialized.') # Create ATM object with bank, hsm, and card instances logging.info('Initializing ATM...') atm = ATM(bank, hsm, card) logging.info('ATM initialized.') logging.info('Initializing Provision Tool...') provision_tool = ProvisionTool(bank, hsm, card) logging.info('Provision Tool initialized.') # Start xmlrpc server on host and port specified in config.yaml logging.info('Initializing ATM xmlrpc interface...') server = SimpleXMLRPCServer.SimpleXMLRPCServer( (config['devices']['atm']['host'], config['devices']['atm']['port'])) # Register built-in rpc introspections server.register_introspection_functions() # Register api exposed by atm and hsm server.register_function(atm.hello) server.register_function(atm.withdraw) server.register_function(atm.check_balance) server.register_function(atm.change_pin) server.register_function(provision_tool.provision_card) server.register_function(provision_tool.provision_atm) server.register_function(provision_tool.ready_for_hsm) server.register_function(provision_tool.hsm_connected) server.register_function(provision_tool.card_connected) logging.info('ATM xmlrpc interface initialized.') logging.info('ATM listening on %s:%s' % (config['devices']['atm']['host'], str(config['devices']['atm']['port']))) # Start xmlrpc server t = threading.Thread(target=server.serve_forever) t.daemon = True t.start() # Blocks until a hsm is connected hsm.initialize() # Spins up thread to connect/disconnect cards card.initialize() t.join()
Interface.free_invalid_data_block((block_number)) #REQUEST TO WRITE DATA ON THE THE SERVER def update_data_block(self, p_block_number, p_block_data): block_number = pickle.loads(p_block_number) block_data = pickle.loads(p_block_data) Interface.update_data_block(block_number, block_data) #REQUEST TO UPDATE THE UPDATED INODE IN THE INODE TABLE FROM SERVER def update_inode_table(self, p_inode, p_inode_number): inode = pickle.loads(p_inode) inode_number = pickle.loads(p_inode_number) Interface.update_inode_table(inode, inode_number) #REQUEST FOR THE STATUS OF FILE SYSTEM FROM SERVER def status(self): sta = Interface.status() psta = pickle.dumps(sta) return psta obj = MyObject() port = sys.argv[1] server = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", int(port)), allow_none=True) server.register_instance(obj) print("Listening on port " + port) server.serve_forever()
def __init__(self): gr.top_block.__init__(self, "TJ Cubesat No Gui with IQ streaming") ################################################## # Variables ################################################## self.interp = interp = 4 self.audio_rate = audio_rate = 48000 self.tx_gain = tx_gain = 10 self.rx_downsamp_bw = rx_downsamp_bw = 10000 self.rf_tx_rate = rf_tx_rate = audio_rate*interp self.rf_rx_rate = rf_rx_rate = 192000 self.preamble_len = preamble_len = 300 self.gain = gain = 40 self.freq = freq = 144.39e6 self.cubesat_zmq_port_4 = cubesat_zmq_port_4 = "5504" self.cubesat_zmq_port_3 = cubesat_zmq_port_3 = "5503" self.cubesat_zmq_port_2 = cubesat_zmq_port_2 = "5502" self.cubesat_zmq_port_1 = cubesat_zmq_port_1 = "5501" self.cubesat_port_2 = cubesat_port_2 = "5558" self.cubesat_port_1 = cubesat_port_1 = "5556" self.cubesat_ext_ip_addr = cubesat_ext_ip_addr = "192.168.1.10" self.baud_rate = baud_rate = 1200 self.audio_line_driver = audio_line_driver = .8 self.Decay = Decay = 0.8 self.Attack = Attack = 0.8 ################################################## # Blocks ################################################## self.zeromq_push_sink_0_0_0_0 = zeromq.push_sink(gr.sizeof_float, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_4, 100, False, -1) self.zeromq_push_sink_0_0_0 = zeromq.push_sink(gr.sizeof_float, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_3, 100, False, -1) self.zeromq_push_sink_0_0 = zeromq.push_sink(gr.sizeof_gr_complex, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_2, 100, False, -1) self.zeromq_push_sink_0 = zeromq.push_sink(gr.sizeof_gr_complex, 1, "tcp://"+cubesat_ext_ip_addr+":"+cubesat_zmq_port_1, 100, False, -1) self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(('', 1234), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread(target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(rf_rx_rate) self.uhd_usrp_source_0.set_center_freq(freq, 0) self.uhd_usrp_source_0.set_gain(gain, 0) self.uhd_usrp_source_0.set_antenna('RX2', 0) self.uhd_usrp_source_0.set_bandwidth(rf_rx_rate, 0) self.uhd_usrp_sink_0_1 = uhd.usrp_sink( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0_1.set_samp_rate(rf_tx_rate) self.uhd_usrp_sink_0_1.set_center_freq(freq, 0) self.uhd_usrp_sink_0_1.set_gain(tx_gain, 0) self.uhd_usrp_sink_0_1.set_antenna('TX/RX', 0) self.uhd_usrp_sink_0_1.set_bandwidth(rf_tx_rate, 0) self.rational_resampler_xxx_0_0_0 = filter.rational_resampler_ccc( interpolation=4, decimation=1, taps=None, fractional_bw=None, ) self.low_pass_filter_0 = filter.fir_filter_ccf(4, firdes.low_pass( 1, rf_rx_rate, rx_downsamp_bw/2, 1000, firdes.WIN_HAMMING, 6.76)) self.detectMarkSpace_1_0 = detectMarkSpace( Frequency=2200, attack=Attack, decay=Decay, samp_rate=audio_rate, ) self.detectMarkSpace_0_0 = detectMarkSpace( Frequency=1200, attack=Attack, decay=Decay, samp_rate=audio_rate, ) self.bruninga_str_to_aprs_0_1 = bruninga.str_to_aprs('KN4DTQ', 'KN4DTQ', []) self.bruninga_ax25_fsk_mod_0_0 = bruninga.ax25_fsk_mod(audio_rate, preamble_len, 5, 2200, 1200, baud_rate) self.blocks_udp_sink_0_0 = blocks.udp_sink(gr.sizeof_char*1, '127.0.0.1', int(cubesat_port_1), 1472, True) self.blocks_sub_xx_0_0_0 = blocks.sub_ff(1) self.blocks_socket_pdu_0_0_0_0 = blocks.socket_pdu("UDP_SERVER", '127.0.0.1', cubesat_port_2, 10000, False) self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vff((audio_line_driver, )) self.analog_nbfm_tx_0_0 = analog.nbfm_tx( audio_rate=audio_rate, quad_rate=audio_rate, tau=75e-6, max_dev=5e3, fh=-1.0, ) self.analog_nbfm_rx_0 = analog.nbfm_rx( audio_rate=audio_rate, quad_rate=audio_rate, tau=75e-6, max_dev=5e3, ) self.afsk_ax25decode_1 = afsk.ax25decode(audio_rate, 1) ################################################## # Connections ################################################## self.msg_connect((self.blocks_socket_pdu_0_0_0_0, 'pdus'), (self.bruninga_str_to_aprs_0_1, 'in')) self.msg_connect((self.bruninga_str_to_aprs_0_1, 'out'), (self.bruninga_ax25_fsk_mod_0_0, 'in')) self.connect((self.afsk_ax25decode_1, 0), (self.blocks_udp_sink_0_0, 0)) self.connect((self.analog_nbfm_rx_0, 0), (self.detectMarkSpace_0_0, 0)) self.connect((self.analog_nbfm_rx_0, 0), (self.detectMarkSpace_1_0, 0)) self.connect((self.analog_nbfm_rx_0, 0), (self.zeromq_push_sink_0_0_0, 0)) self.connect((self.analog_nbfm_tx_0_0, 0), (self.rational_resampler_xxx_0_0_0, 0)) self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.analog_nbfm_tx_0_0, 0)) self.connect((self.blocks_sub_xx_0_0_0, 0), (self.afsk_ax25decode_1, 0)) self.connect((self.bruninga_ax25_fsk_mod_0_0, 0), (self.blocks_multiply_const_vxx_0_0, 0)) self.connect((self.bruninga_ax25_fsk_mod_0_0, 0), (self.zeromq_push_sink_0_0_0_0, 0)) self.connect((self.detectMarkSpace_0_0, 0), (self.blocks_sub_xx_0_0_0, 0)) self.connect((self.detectMarkSpace_1_0, 0), (self.blocks_sub_xx_0_0_0, 1)) self.connect((self.low_pass_filter_0, 0), (self.analog_nbfm_rx_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.zeromq_push_sink_0, 0)) self.connect((self.rational_resampler_xxx_0_0_0, 0), (self.uhd_usrp_sink_0_1, 0)) self.connect((self.rational_resampler_xxx_0_0_0, 0), (self.zeromq_push_sink_0_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0, 0))
def __init__(self): gr.top_block.__init__(self, "rfnoc_rx_e3") ################################################## # Variables ################################################## self.vec_length = vec_length = 1 self.device3 = variable_uhd_device3_0 = ettus.device3( uhd.device_addr_t(",".join(('type=e3x0', "")))) self.server_port = server_port = 30000 self.server_address = server_address = "192.168.10.184" self.samp_rate = samp_rate = 1e6 self.rx_gain_A2 = rx_gain_A2 = 60 self.rf_freq = rf_freq = 871e6 self.decim_rate = decim_rate = 500e3 ################################################## # Blocks ################################################## self.zeromq_push_sink_1 = zeromq.push_sink(gr.sizeof_gr_complex, vec_length, 'tcp://*:9998', 100, False, -1) self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer( (str(server_address), int(server_port)), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread( target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.uhd_rfnoc_streamer_radio_0 = ettus.rfnoc_radio( self.device3, uhd.stream_args( # Tx Stream Args cpu_format="fc32", otw_format="sc16", args="", # empty ), uhd.stream_args( # Rx Stream Args cpu_format="fc32", otw_format="sc16", args='', ), 0, -1) self.uhd_rfnoc_streamer_radio_0.set_rate(samp_rate) self.uhd_rfnoc_streamer_radio_0.set_rx_freq(rf_freq, 0) self.uhd_rfnoc_streamer_radio_0.set_rx_gain(rx_gain_A2, 0) self.uhd_rfnoc_streamer_radio_0.set_rx_dc_offset(True, 0) self.uhd_rfnoc_streamer_radio_0.set_rx_bandwidth(samp_rate, 0) if "RX2": self.uhd_rfnoc_streamer_radio_0.set_rx_antenna("RX2", 0) self.uhd_rfnoc_streamer_radio_0.set_clock_source("internal") self.uhd_rfnoc_streamer_ddc_0 = ettus.rfnoc_generic( self.device3, uhd.stream_args( # TX Stream Args cpu_format="fc32", # TODO: This must be made an option otw_format="sc16", channels=range(1), args= "input_rate={},output_rate={},fullscale={},freq={},gr_vlen={},{}" .format( samp_rate, samp_rate, 1.0, 0, vec_length, "" if vec_length == 1 else "spp={}".format(vec_length)), ), uhd.stream_args( # RX Stream Args cpu_format="fc32", # TODO: This must be made an option otw_format="sc16", channels=range(1), args="gr_vlen={},{}".format( vec_length, "" if vec_length == 1 else "spp={}".format(vec_length)), ), "DDC", -1, -1, ) for chan in xrange(1): self.uhd_rfnoc_streamer_ddc_0.set_arg("input_rate", float(samp_rate), chan) self.uhd_rfnoc_streamer_ddc_0.set_arg("output_rate", float(samp_rate), chan) self.uhd_rfnoc_streamer_ddc_0.set_arg("fullscale", 1.0, chan) self.uhd_rfnoc_streamer_ddc_0.set_arg("freq", 0, chan) ################################################## # Connections ################################################## self.connect((self.uhd_rfnoc_streamer_ddc_0, 0), (self.zeromq_push_sink_1, 0)) self.device3.connect(self.uhd_rfnoc_streamer_radio_0.get_block_id(), 0, self.uhd_rfnoc_streamer_ddc_0.get_block_id(), 0)
def rpc_server(): rpcserver = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 8004), logRequests=False) rpcserver.register_function(announce, 'announce') print 'Starting xml rpc server...' rpcserver.serve_forever()
def __init__(self, channel=6): gr.top_block.__init__(self, "Wifi Rx") ################################################## # Parameters ################################################## self.channel = channel ################################################## # Variables ################################################## self.window_size = window_size = 48 self.sync_length = sync_length = 320 self.samp_rate = samp_rate = 20e6 self.lo_offset = lo_offset = 0 self.gain = gain = 30 self.freq = freq = 2407000000.0 + 5000000.0 * channel self.chan_est = chan_est = 0 ################################################## # Blocks ################################################## self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer( ('localhost', 8080), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread( target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.rftap_rftap_encap_0 = rftap.rftap_encap(0, -1, '') self.osmosdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + '') self.osmosdr_source_0.set_sample_rate(samp_rate) self.osmosdr_source_0.set_center_freq(freq, 0) self.osmosdr_source_0.set_freq_corr(0, 0) self.osmosdr_source_0.set_dc_offset_mode(0, 0) self.osmosdr_source_0.set_iq_balance_mode(0, 0) self.osmosdr_source_0.set_gain_mode(False, 0) self.osmosdr_source_0.set_gain(gain, 0) self.osmosdr_source_0.set_if_gain(20, 0) self.osmosdr_source_0.set_bb_gain(20, 0) self.osmosdr_source_0.set_antenna('', 0) self.osmosdr_source_0.set_bandwidth(0, 0) self.ieee802_11_sync_short_0 = ieee802_11.sync_short( 0.56, 2, False, False) self.ieee802_11_sync_long_0 = ieee802_11.sync_long( sync_length, False, False) self.ieee802_11_parse_mac_0 = ieee802_11.parse_mac(True, True) self.ieee802_11_moving_average_xx_1 = ieee802_11.moving_average_ff( window_size + 16) self.ieee802_11_moving_average_xx_0 = ieee802_11.moving_average_cc( window_size) self.ieee802_11_frame_equalizer_0 = ieee802_11.frame_equalizer( chan_est, freq, samp_rate, False, False) self.ieee802_11_decode_mac_0 = ieee802_11.decode_mac(True, False) self.fft_vxx_0 = fft.fft_vcc(64, True, (window.rectangular(64)), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, 64) self.blocks_socket_pdu_0_0_0 = blocks.socket_pdu( "UDP_CLIENT", '127.0.0.1', '52002', 10000, False) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_divide_xx_0 = blocks.divide_ff(1) self.blocks_delay_0_0 = blocks.delay(gr.sizeof_gr_complex * 1, 16) self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex * 1, sync_length) self.blocks_conjugate_cc_0 = blocks.conjugate_cc() self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1) self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1) ################################################## # Connections ################################################## self.msg_connect((self.ieee802_11_decode_mac_0, 'out'), (self.ieee802_11_parse_mac_0, 'in')) self.msg_connect((self.ieee802_11_decode_mac_0, 'out'), (self.rftap_rftap_encap_0, 'in')) self.msg_connect((self.rftap_rftap_encap_0, 'out'), (self.blocks_socket_pdu_0_0_0, 'pdus')) self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_divide_xx_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.ieee802_11_moving_average_xx_1, 0)) self.connect((self.blocks_conjugate_cc_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_delay_0, 0), (self.ieee802_11_sync_long_0, 1)) self.connect((self.blocks_delay_0_0, 0), (self.blocks_conjugate_cc_0, 0)) self.connect((self.blocks_delay_0_0, 0), (self.ieee802_11_sync_short_0, 0)) self.connect((self.blocks_divide_xx_0, 0), (self.ieee802_11_sync_short_0, 2)) self.connect((self.blocks_multiply_xx_0, 0), (self.ieee802_11_moving_average_xx_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.fft_vxx_0, 0), (self.ieee802_11_frame_equalizer_0, 0)) self.connect((self.ieee802_11_frame_equalizer_0, 0), (self.ieee802_11_decode_mac_0, 0)) self.connect((self.ieee802_11_moving_average_xx_0, 0), (self.blocks_complex_to_mag_0, 0)) self.connect((self.ieee802_11_moving_average_xx_0, 0), (self.ieee802_11_sync_short_0, 1)) self.connect((self.ieee802_11_moving_average_xx_1, 0), (self.blocks_divide_xx_0, 1)) self.connect((self.ieee802_11_sync_long_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.ieee802_11_sync_short_0, 0), (self.blocks_delay_0, 0)) self.connect((self.ieee802_11_sync_short_0, 0), (self.ieee802_11_sync_long_0, 0)) self.connect((self.osmosdr_source_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.osmosdr_source_0, 0), (self.blocks_delay_0_0, 0)) self.connect((self.osmosdr_source_0, 0), (self.blocks_multiply_xx_0, 0))