class AsyncServer(threading.Thread):
    def __init__(self,port):
        # Create XMLRPC server
        threading.Thread.__init__(self)
        self.lock=threading.Condition(threading.Lock())
        self.timeout=0.2
        self._quit=False
        self.port=port
        self.interp = PyInterp(self.lock)
        sys.stdout=self.interp._stdout
        sys.stdin=self.interp._stdin
        sys.stderr=self.interp._stderr
    def start_interp(self):
        self.interp.main_loop()
    def run(self):
        self.server = SimpleXMLRPCServer(("localhost", self.port))
        self.server.logRequests=0
        self.server.register_introspection_functions()
        #self.server.socket.settimeout(self.timeout) ##timeouts cause probs
        self.server.register_function(self.end,'end')
        self.server.register_function(self.run_code,'run_code')
        self.server.register_function(self.cont,'cont')
        while not self._quit:
            self.server.handle_request()
    def end(self):
        if self.interp._runningeval:
            raise KeyboardInterrupt
        self.lock.acquire()
        self.interp._running=False
        self._quit=True
        self.lock.notify()
        self.lock.release()
        return "Session Terminated"
    def run_code(self,eval_str,stdin):
        logmsg("compiling code")
        try:
            cobj=code.compile_command(eval_str)
        except:
            logmsg("syntax error")
            return -1,'','',False
        if cobj==None:
            logmsg("statement incomplete")
            return -2,'','',False
        logmsg("running code "+eval_str)
        if self.interp.queue_code(eval_str):
            return self.cont(stdin)
        else:
            return -3,self.interp._stdout.read(),self.interp._stderr.read(),self.interp._stdin.HasInputRequest()
    def cont(self,stdin):
        logmsg('continuing with stdin: '+stdin)
        self.interp._stdin.write(stdin)
        if self.interp._stdin.HasInputRequest():
            self.interp._stdin.InputRequestNotify()
        self.lock.acquire()
        if self.interp._runningeval:
            self.lock.wait(self.timeout)
        self.lock.release()
        result=(int(self.interp._runningeval),self.interp._stdout.read(),self.interp._stderr.read(),self.interp._stdin.HasInputRequest())
        logmsg('returning result ',result)
        return result
Example #2
0
    def __init__(self, port, interpreter):
        address = ("localhost", port)

        SimpleXMLRPCServer.__init__(self, address, logRequests=False, allow_none=True)

        self.register_instance(self._methods(interpreter))
        self.register_introspection_functions()
 def __init__(self, sspec, boss,
              handler=RequestHandler,
              logger=Logger,
              xmlrpc=None,
              auth_handler=None,
              ssl_pem_filename=None,
              ssl_context=None):
   SimpleXMLRPCServer.__init__(self, sspec, handler)
   self.boss = boss
   self.handler = handler
   self.auth_handler = auth_handler
   self.logger = logger()
   if xmlrpc:
     self.xmlrpc = xmlrpc(boss)
     self.register_introspection_functions()
     self.register_instance(self.xmlrpc)
   else:
     self.xmlrpc = None
   if ssl_pem_filename and ssl_context:
     ctx = ssl_context(socks.SSL.TLSv1_METHOD)
     ctx.use_privatekey_file (ssl_pem_filename)
     ctx.use_certificate_chain_file(ssl_pem_filename)
     self.socket = socks.SSL_Connect(ctx, socket.socket(self.address_family,
                                                        self.socket_type),
                                        server_side=True)
     self.server_bind()
     self.server_activate()
     self.enable_ssl = True
   else:
     self.enable_ssl = False
Example #4
0
 def __init__(self, addr, requestHandler=KeepAliveRequestHandler,
              logRequests=True, allow_none=True, encoding=None,
              bind_and_activate=True, key_path='key.pem',
              cert_path='cert.pem', ca_certs=None, cert_reqs=CERT_NONE,
              ssl_version=PROTOCOL_SSLv23):
     """Overriding __init__ method of the SimpleXMLRPCServer to add SSL in
     between basic init and network activation.
     """
     # Initializing SecureXMLRPCServer *without* network
     SimpleXMLRPCServer.__init__(self, addr, requestHandler=requestHandler,
                                 logRequests=logRequests,
                                 allow_none=allow_none, encoding=encoding,
                                 bind_and_activate=False)
     # Validate arguments possibly supplied by user
     if not os.path.isfile(key_path):
         raise ValueError("No such server key: %s" % key_path)
     if not os.path.isfile(cert_path):
         raise ValueError("No such server certificate: %s" % cert_path)
     if not ssl_version in (PROTOCOL_SSLv2, PROTOCOL_SSLv3, PROTOCOL_SSLv23,
                            PROTOCOL_TLSv1):
         raise ValueError("Invalid ssl_version value: %s" % ssl_version)
     if not cert_reqs in (CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED):
         raise ValueError("Invalid cert_reqs value: %s" % cert_reqs)
     self.socket = wrap_socket(self.socket, server_side=True,
                               keyfile=key_path, certfile=cert_path,
                               cert_reqs=cert_reqs, ssl_version=ssl_version,
                               ca_certs=ca_certs)
     if bind_and_activate:
         self.server_bind()
         self.server_activate()
 def _start(self):
     """
     Used internally to start the XML-RPC server.
     """
     s = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
     s.register_instance(self)
     s.serve_forever()
Example #6
0
 def _start(self):
     """
       internal function: to start XML-RPC server
     """
     s = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
     s.register_instance(self)
     s.serve_forever()
Example #7
0
 def __init__(self, addr, requestHandler=IPXMLRPCRequestHandler,
              logRequests=True, allow_none=False, encoding=None,
              bind_and_activate=True):
     self.address_family = socket.getaddrinfo(*addr)[0][0]
     SimpleXMLRPCServer.__init__(self, addr, requestHandler,
                                 logRequests, allow_none, encoding,
                                 bind_and_activate)
Example #8
0
 def run(self):
     """Run XMLRPC server, serving our methods."""
     server = SimpleXMLRPCServer(("0.0.0.0", self.port))
     self.server = server
     server.register_instance(self)
     self.queue.put(self.port)
     server.serve_forever()
Example #9
0
 def finish_request(self, request, client_address):
     try:
         SimpleXMLRPCServer.finish_request(self, request, client_address)
     except socket.error:
         pass
     if mailpile.util.QUITTING:
         self.shutdown()
Example #10
0
    def __init__(self, dbfile, logfile, interface, daemon=True):
        ''' constructor '''
        try:
            SimpleXMLRPCServer.__init__(self, interface,
                                        logRequests=False, allow_none=True)
        except socket.error:
            ip=socket.gethostbyname(interface[0])
            port=interface[1]
            msg="PR Server unable to bind to %s:%s\n" % (ip, port)
            sys.stderr.write(msg)
            raise PRServiceConfigError

        self.dbfile=dbfile
        self.daemon=daemon
        self.logfile=logfile
        self.working_thread=None
        self.host, self.port = self.socket.getsockname()
        self.pidfile=PIDPREFIX % (self.host, self.port)

        self.register_function(self.getPR, "getPR")
        self.register_function(self.quit, "quit")
        self.register_function(self.ping, "ping")
        self.register_function(self.export, "export")
        self.register_function(self.importone, "importone")
        self.register_introspection_functions()

        self.db = prserv.db.PRData(self.dbfile)
        self.table = self.db["PRMAIN"]

        self.requestqueue = Queue.Queue()
        self.handlerthread = threading.Thread(target = self.process_request_thread)
        self.handlerthread.daemon = False
Example #11
0
    def __init__(self, addr, requestHandler=SecureXMLRPCRequestHandler,
                 logRequests=False, allow_none=False, encoding=None,
                 bind_and_activate=True, keyfile=None, certfile=None,
                 ca_certs=None):
        SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
                                    allow_none, encoding, False)
        if certfile and ((not os.path.exists(certfile)) or os.path.getsize(certfile) < 1):
            raise Exception("certfile %s doesn't exist or is empty" % certfile)

        if keyfile and ((not os.path.exists(keyfile)) or
                        os.path.getsize(keyfile) < 1):
            raise Exception("keyfile %s doesn't exist or is empty" % keyfile)
        self.socket = ssl.wrap_socket(self.socket,
                                      keyfile=keyfile,
                                      certfile=certfile,
                                      server_side=True,
                                      cert_reqs=ssl.CERT_REQUIRED,
#                                      ssl_version=ssl.PROTOCOL_TLSv1,
                                      ssl_version=ssl.PROTOCOL_SSLv23, # Ideally we'd accept any TLS but no SSL. Sigh.
                                      ca_certs=ca_certs)
#                                      ciphers='HIGH:MEDIUM:!ADH:!SSLv2:!MD5:!RC4:@STRENGTH') # Hopefully this effectively exclues SSLv2 and 3?
        if bind_and_activate:
            # This next throws a socket.error on error, eg
            # Address already in use or Permission denied. 
            # Catch for clearer error message?
            self.server_bind()
            self.server_activate()
Example #12
0
 def _start(self):
     """
     内部使用,用于启动XML_RPC服务器
     """
     s = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
     s.register_instance(self)
     s.serve_forever()
class RPCServer:
    '''
    classdocs
    '''
           
    def getRSS(self, url):
        informasi=[]
        message =''
        rss = parse(urllib.urlopen(url)).getroot()
        
        for data in rss.findall('gempa'):
            magnitude = data.find('Magnitude').text
            jumlah = data.find('Jumlah').text
            informasi.append([magnitude,jumlah])
           
            message = message + 'Magnitude\t: '+magnitude+'\n'+'Jumlah\t\t: '+jumlah+'\n'
            print'\n================================'
      
        return message;
        
        

    def __init__(self):
        '''
        Constructor
        '''
        self.server = SimpleXMLRPCServer(('localhost',65530))
        print "listening at 65530"
        self.server.register_function(self.getRSS, 'getRSS')
        #self.server.allow_none = True
        self.server.serve_forever()
def serve(ip="localhost", port=8123):
    server = SimpleXMLRPCServer((ip, port), allow_none=True)
    server.register_introspection_functions()

    server.register_instance(PandoraServerProxy())    
    t = eventlet.spawn(server.serve_forever)
    t.wait()
 def initialize_server(self):
     dispatcher = self._create_request_dispatcher()
     host = SFLvaultServer.settings['sflvault.host']
     port = int(SFLvaultServer.settings['sflvault.port'])
     address = (host, port)
     keyfile = SFLvaultServer.settings.get('sflvault.keyfile')
     certfile = SFLvaultServer.settings.get('sflvault.certfile')
     if keyfile and certfile:
         log.info("Starting in SSL mode")
         self.server = SecureXMLRPCServer(
             address,
             requestHandler=SFLvaultRequestHandler,
             keyfile=keyfile,
             certfile=certfile,
             logRequests=False,
             allow_none=True,
         )
     else:
         log.info("Starting in insecure mode")
         self.server = SimpleXMLRPCServer(
             address,
             requestHandler=SFLvaultRequestHandler,
             logRequests=False,
             allow_none=True,
         )
     self.server.register_introspection_functions()
     self.server.register_instance(dispatcher)
Example #16
0
	def run(self):
		"""Run forever on the configured port."""
		s=SimpleXMLRPCServer(("0.0.0.0", self.port))
		handler=Handler(self.queue)
		s.register_instance(handler)
		print "Starting XML RPC Handler."
		s.serve_forever()
Example #17
0
class ReportSVRThread():
    global report_port
    """
    A XML RPC svr for receiving LTBNET search result
    """

    def __init__(self,win):
        self.win=win
##        self.running=True
        self.port = report_port
        self.server = SimpleXMLRPCServer(("localhost", self.port),
                            logRequests=False,
                            requestHandler=XMLRPCRequestHandler)
        self.server.register_introspection_functions()
        self.server.register_function(self.report)
        thread.start_new_thread(self.run,())

##    def stop(self):
##        self.running=False

    def report(self,search_results):
        sr=cPickle.loads(base64.b16decode(search_results))
        evt=SearchReportEvent(result=sr)
        try:
            wx.PostEvent(self.win, evt)
        except Exception, inst:
            print "LTBSearchDiag: catched except:"
            print traceback.format_exc()
            print inst

        return 'ok'
Example #18
0
    def __init__(self, *args, **kwargs):
        """
        Takes the same arguments as SimpleXMLRPCServer, with the addition of
        some keyward arguments documented here.  All of the additional
        arguments are passed directly into `ssl.wrap_socket`.  For details, see
        the documentation on `ssl.wrap_socket`.

        :param certfile:
            File with PEM formatted certificate.

        :param keyfile:
            File with PEM formatted private key.  Not needed if certfile
            contains private key.

        :param cert_reqs:
            Specifies whether a certificate is required from clients.  Must be
            one of `ssl.CERT_OPTIONAL`, `ssl.CERT_REQUIRED`, or
            `ssl.CERT_NONE`.  Default `ssl.CERT_REQUIRED`.

        :param ca_certs:
            File containing accepted "certification authority" certificates.

        :param ssl_version:
            SSL protocol version to use.  Must be one of `ssl.PROTOCOL_*`.
            Default `ssl.PROTOCOL_TLSv1`.
        """

        self.keyfile = kwargs.pop("keyfile", None)
        self.certfile = kwargs.pop("certfile", None)
        self.cert_reqs = kwargs.pop("cert_reqs", ssl.CERT_REQUIRED)
        self.ca_certs = kwargs.pop("ca_certs", None)
        self.ssl_version = kwargs.pop("ssl_version", ssl.PROTOCOL_TLSv1)
        SimpleXMLRPCServer.__init__(self, *args, **kwargs)
Example #19
0
def main():
    global logger, reactor
    options, args = _parseCommandLine()
    settings = localSettings()

    if not options.debug:
        sys.stdout = sys.stderr = LogFile(settings)
        logger.setLevel(logging.INFO)
    else:
        logger.setLevel(logging.DEBUG)
    logger.addHandler(logging.StreamHandler())
    logging.getLogger("nitro.selectreactor").addHandler(logging.StreamHandler())

    reactor = SelectReactor()
    seedNodes = [(options.dhtnode, options.dhtport)]
    service = CSpaceService(seedNodes, settings, reactor)
    server = SimpleXMLRPCServer(("localhost", options.xmlport))
    reactor.addReadCallback(server, server.handle_request)
    server.register_instance(service, allow_dotted_names=True)

    xmlrpcport = server.socket.getsockname()[1]
    logger.info("rpcserver listenport = %i" % xmlrpcport)
    appletport = service.appletServer.listenPort
    logger.info("seed nodes = (%s:%i)" % (options.dhtnode, options.dhtport))
    _writePID(xmlrpcport, appletport)
    service.run()
    _deletePID()
    logger.info("server stopped.")
Example #20
0
class KeyValueServer(object):
    _rpc_methods = ['get', 'set', 'delete', 'exists', 'keys']

    def __init__(self, address):
        self._data = {}
        self._serv = SimpleXMLRPCServer(address, allow_none=True)
        for name in self._rpc_methods:
            self._serv.register_function(getattr(self, name))
    
    def get(self, key):
        return self._data[key]

    def set(self, key, value):
        self._data[key] = value

    def delete(self, key):
        del self._data[key]

    def exists(self, key):
        return key in self._data
        
    def keys(self):
        return list(self._data)

    def serve_forever(self):
        self._serv.serve_forever()
    def __init__(self, addr, requestHandler=SecureXMLRPCRequestHandler,
                 logRequests=False, allow_none=False, encoding=None,
                 bind_and_activate=True, keyfile=None, certfile=None,
                 ca_certs=None):
        SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
                                    allow_none, encoding, False)
        if certfile and ((not os.path.exists(certfile)) or os.path.getsize(certfile) < 1):
            raise Exception("certfile %s doesn't exist or is empty" % certfile)

        if keyfile and ((not os.path.exists(keyfile)) or
                        os.path.getsize(keyfile) < 1):
            raise Exception("keyfile %s doesn't exist or is empty" % keyfile)
        self.socket = ssl.wrap_socket(self.socket,
                                      keyfile=keyfile,
                                      certfile=certfile,
                                      server_side=True,
                                      cert_reqs=ssl.CERT_REQUIRED,
                                      ssl_version=ssl.PROTOCOL_SSLv23,
                                      ca_certs=ca_certs)
        if bind_and_activate:
            # This next throws a socket.error on error, eg
            # Address already in use or Permission denied. 
            # Catch for clearer error message?
            self.server_bind()
            self.server_activate()
 def __init__(self, **kw):
     """
     Creates the xml-rpc server
 
     Keywords:
         - host - hostname to listen on for xml-rpc requests, default 127.0.0.1
         - port - port  to listen on for xml-rpc requests, default 19481
         - fcpHost - hostname where FCP port is
         - fcpPort - port where FCP port is
         - verbosity - verbosity of output messages, 0 (silent) through 6 (noisy),
           default 4. Refer verbosity constants in fcp module
     """
     # create the server
     host = kw.get('host', xmlrpcHost)
     port = kw.get('port', xmlrpcPort)
 
     SimpleXMLRPCServer.__init__(self, (host, port))
 
     # create the fcp node interface
     fcpHost = kw.get('fcpHost', node.defaultFCPHost)
     fcpPort = kw.get('fcpPort', node.defaultFCPPort)
     verbosity = kw.get('verbosity', node.SILENT)
 
     self.node = node.FCPNode(host=fcpHost,
                              port=fcpPort,
                              verbosity=verbosity,
                              )
 
     # create the request handler
     hdlr = FreenetXMLRPCRequestHandler(self.node)
 
     # link in the request handler object
     self.register_instance(hdlr)
     self.register_introspection_functions()
class BDFWXmlRPCServer(object):
    def __init__(self):
        super(BDFWXmlRPCServer, self).__init__()
        self.data = None
        self._sdata = dict()
        self.running = True

        self.server = SimpleXMLRPCServer(("localhost", 18000), allow_none=True)
        self.server.timeout = 0.1
        self.server.register_function(self.update_data, 'update_data')
        self.server.register_function(self.set_data, 'set_data')
        self.server.register_function(self.get_data, 'get_data')
        self.server.register_function(self.stop_monitor, 'stop_monitor')
        pass

    def sighandler(self, v1, v2):
        print 'get TERM signal'
        self.stop_monitor()
        # self.server.server_close()

    def start_monitor(self):
        signal.signal(signal.SIGTERM, self.sighandler)
        # self.server.serve_forever()
        self.serve_forever()
        print 'exit xmlrpc_task'

    def serve_forever(self):
        # while self.running: self.server.handle_request()
        while 1:
            if not self.running: break
            self.server.handle_request()
        self.server.server_close()


    def stop_monitor(self):
        self.running = False
        # print dir(self.server)
        # self.server.shutdown()
        # self.server.server_close()

    def update_data(self):
        if self.data is None:
            self.data = dict()

        else:
            key = int(time.time())
            self.data[str(key)]= str(time.ctime())

        return 1

    def set_data(self, k, v):
        print 'set_data of key[%s]' % k
        self._sdata[k] = v


    def get_data(self, k=None):
        if k is None:
            return self._sdata

        return self._sdata.get(k, None)
Example #24
0
def main_program(YamlConfig):
    def threadedAlert(application, instance, input, delimiter, separator):
        t = Thread(target=doAlert, args=(application, instance, input, delimiter, separator))
        t.start()
        return 0

    connection_type = YamlConfig['app_properties']['connection_type']
    if debug or verbose: print("Listen on: " + str(connection_type))
    daemon_logger.info('Listen on: ' + str(connection_type))

    # Determine what we are to bind to
    if connection_type == "socket":
        socket_addr = YamlConfig['app_properties']['socket_properties']['address']
        socket_port = YamlConfig['app_properties']['socket_properties']['port']
    elif connection_type == "pipe":
        pipe_path = YamlConfig['app_properties']['pipe_path']
    else:
        daemon_logger.info("Unknown connection type to listen on: " + str(connection_type))
        print("Unknown connection type to listen on: " + str(connection_type))
        return False

    if connection_type == "socket":
        server = SimpleXMLRPCServer((socket_addr, socket_port))
    else:
        daemon_logger.info("Connection type " + str(connection_type) + " not implemented yet")
        print("Connection type " + connection_type + " not implemented yet")
        return False

    daemon_logger.info('Listening on ' + str(socket_addr) + ':' + str(socket_port))
    server.register_function(threadedAlert,"threadedAlert")
    server.serve_forever()
Example #25
0
File: remote.py Project: sjl767/woo
def runServers(xmlrpc=False,tcpPy=False):
    """Run python telnet server and info socket. They will be run at localhost on ports 9000 (or higher if used) and 21000 (or higer if used) respectively.
    
    The python telnet server accepts only connection from localhost,
    after authentication by random cookie, which is printed on stdout
    at server startup.

    The info socket provides read-only access to several simulation parameters
    at runtime. Each connection receives pickled dictionary with those values.
    This socket is primarily used by woo-multi batch scheduler.
    """
    if tcpPy:
        import woo.runtime
        srv=GenericTCPServer(handler=woo.remote.PythonConsoleSocketEmulator,title='TCP python prompt',cookie=True,minPort=9000)
        woo.runtime.cookie=srv.server.cookie
    if xmlrpc:
        from SimpleXMLRPCServer import SimpleXMLRPCServer
        port,maxPort=21000,65535 # minimum port number
        while port<maxPort:
            try:
                info=SimpleXMLRPCServer(('',port),logRequests=False,allow_none=True); break
            except socket.error: port+=1
        if port==maxPort: raise RuntimeError("No free port to listen on in range 21000-%d"%maxPort)
        # register methods, as per http://docs.python.org/library/simplexmlrpcserver.html#simplexmlrpcserver-example
        info.register_instance(InfoProvider()) # gets all defined methods by introspection
        #prov=InfoProvider()
        #for m in prov.exposedMethods(): info.register_function(m)
        _runInBackground(info.serve_forever)
        print 'XMLRPC info provider on http://localhost:%d'%port
    sys.stdout.flush()
Example #26
0
    def __init__(self, host=None, port=None, keyfile=None, certfile=None,
                 ca_certs=None, cert_reqs=ssl.CERT_NONE, ssl_version=ssl.PROTOCOL_TLSv1,
                 do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None,
                 log_requests=True, **kwargs):

        SimpleXMLRPCServer.__init__(self, (host, port), requestHandler=RequestHandler)
        self.logger = logging.getLogger(self.__class__.__name__)

        self.keyfile = keyfile
        self.certfile = certfile
        self.ca_certs = ca_certs
        self.cert_reqs = cert_reqs
        self.ssl_version = ssl_version
        self.do_handshake_on_connect = do_handshake_on_connect
        self.suppress_ragged_eofs = suppress_ragged_eofs
        self.ciphers = ciphers

        # Looks awkward to use camelCase here but that's what SimpleXMLRPCRequestHandler
        # expects.
        self.logRequests = log_requests

        # 'verify_fields' is taken from kwargs to allow for adding more keywords
        # in future versions.
        self.verify_fields = kwargs.get("verify_fields")

        self.register_functions()
Example #27
0
def setup_server(listen, port):
    server = SimpleXMLRPCServer((listen, port),
                                requestHandler=RequestHandler)
    
    server.register_function(ping)
    server.register_function(add_key)
    return server    
Example #28
0
    def __init__(self, *args, **kargs):
        class RequestHandler(SimpleXMLRPCRequestHandler):
                def _dispatch(self, method, params):
                    """
                    Overridden to pass request handler to the handling function so that the function can play around
                    with HTTP headers and stuff
                    """
                    params = (self, ) + params
                    func = None
                    try:
                        func = self.server.funcs[method]
                    except KeyError:
                        if self.server.instance is not None:
                            if hasattr(self.server.instance, '_dispatch'):
                                return self.server.instance._dispatch(method, params)
                            else:
                                try:
                                    func = _resolve_dotted_attribute(self.server.instance, method)
                                except AttributeError:
                                    pass

                    if func is not None:
                        return apply(func, params)
                    else:
                        raise Exception('method "%s" is not supported' % method)

        SimpleXMLRPCServer.__init__(self, requestHandler=RequestHandler, *args, **kargs)
Example #29
0
class CentralServer:
    def __init__(self, ip, port, log=None):
        # Node state
        self.log = log

        # Handler for the RPC requests
        self.responder = ServerResponder(log)

        # Accept incoming connections in a background thread
        self.server = SimpleXMLRPCServer((ip,port),logRequests=False,bind_and_activate=False)
        self.server.server_bind()
        self.server.server_activate()
        self.server.register_introspection_functions()
        self.server.register_instance(self.responder)
        t = Thread(target = self._run,name='{0}:{1}'.format(ip,port))
        t.daemon = True
        t.start()

        log.blue('\n\nINIT - server')
        log.blue('----------------')
        self.log.blue( ip,port)
        log.blue('----------------')


    def _run(self):
        """ Accept incoming connection till exit  """
        self.server.serve_forever()
Example #30
0
    def __init__(self, config, host="localhost", port=0, log_requests=False, verbose_queue=False):
        SimpleXMLRPCServer.__init__(self, (host, port), allow_none=True, logRequests=log_requests)
        self._host = host
        self._verbose_queue = verbose_queue
        # https: server.socket = ssl.wrap_socket(srv.socket, ...)

        if isinstance(config, EnKFMain):
            self._config = config
            self._config_file = config.getUserConfigFile()
        else:
            if os.path.exists(config):
                self._config = EnKFMain(config)
                self._config_file = config
            else:
                raise IOError("The ert config file: %s does not exist" % config)

        self._session = Session()

        self.register_function(self.ertVersion)
        self.register_function(self.getTimeMap)
        self.register_function(self.isRunning)
        self.register_function(self.isInitializationCaseAvailable)
        self.register_function(self.startSimulationBatch)
        self.register_function(self.addSimulation)
        self.register_function(self.isRealizationFinished)
        self.register_function(self.didRealizationSucceed)
        self.register_function(self.didRealizationFail)
        self.register_function(self.getGenDataResult)
        self.register_function(self.getCustomKWResult)
        self.register_function(self.isCustomKWKey)
        self.register_function(self.isGenDataKey)
        self.register_function(self.prototypeStorage)
        self.register_function(self.storeGlobalData)
        self.register_function(self.storeSimulationData)
Example #31
0
class outlet(iot.device):
    #The class defining outlet devices
    #Can be turned on or off, or queried for the current state

    def __init__(self):
        iot.device.__init__(self)
        self.name = 'outlet'
        self.category = 'device'

        #Set up logging
        iot.setup_log(self.name, time.localtime())

        #Register with the gateway
        self.register()
        '''
		#Initialize and start daemon thread for serving as the clock synchronization leader
		leader_thread=Thread(target=self.lead, name='Outlet Leader Thread')
		leader_thread.daemon = True
		leader_thread.start()
		'''

        #Start the outlet server
        self.serve()

    def serve(self):
        self.server = SimpleXMLRPCServer((self.ip, self.port),
                                         logRequests=False,
                                         allow_none=True)
        self.server.register_function(self.ping)
        self.server.register_function(self.serve)
        self.server.register_function(self.register)
        self.server.register_function(self.timestamp)
        #self.server.register_function(self.start_election)
        #self.server.register_function(self.lead)
        #self.server.register_function(self.get_time)
        #self.server.register_function(self.set_time)
        self.server.register_function(self.get_attr)
        self.server.register_function(self.set_attr)
        self.server.register_function(self.db_get_state)
        self.server.register_function(self.db_get_history)
        #self.server.register_function(self.set_leader)
        self.server.register_function(self.device_by_name)
        self.server.register_function(self.devices_by_name)
        self.server.register_function(self.update_device_list)

        self.clock += 1
        try:
            print '\nStarting Server'
            print 'Use Control-C to exit'
            logging.info(
                str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
                'Starting Server')
            self.server.serve_forever()
        except KeyboardInterrupt:
            logging.info(
                str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
                'Received keyboard interrupt, stopping server')
            print 'Exiting'
Example #32
0
    return 0

def setCamPos( x, y ):
    print "setCamPos", x, y
    if ( x < 0 ):
        x = 0
    elif ( x > 255 ):
        x = 255
    
    if ( y < 0 ):
        y = 0
    elif ( y > 255 ):
        y = 255
        
    res = io.setIo( 3, x )
    #if not res:
    #    return 1
    res = io.setIo( 4, y )
    #if ( not res ):
    #    return 2
    io.setIo( 0, 1 )
    return 0
    
server = SimpleXMLRPCServer( ( "localhost", 8765 ) )
print "Expecting commands"
server.register_function( setMoto,   "setMoto" )
server.register_function( setLight,  "setLight" )
server.register_function( setCamPos, "setCamPos" )
server.serve_forever()

Example #33
0
#!/usr/bin/env python

from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
import psutil

# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2',)

# Create server
server = SimpleXMLRPCServer(("localhost", 61209),
                            requestHandler=RequestHandler)
server.register_introspection_functions()

# Register the GET function
def getAll():
    return psutil.cpu_percent(interval=1, percpu=True)
server.register_function(get, 'get')

#~ # Register an instance; all the methods of the instance are
#~ # published as XML-RPC methods (in this case, just 'div').
#~ class MyFuncs:
    #~ def div(self, x, y):
        #~ return x // y
#~ server.register_instance(MyFuncs())

# Run the server's main loop
server.serve_forever()
Example #34
0
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
import xmlrpclib
result =0
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2',)

# Create server
server = SimpleXMLRPCServer(("localhost", 9000),
                            requestHandler=RequestHandler)
server.register_introspection_functions()

# Register pow() function; this will use the value of
# pow.__name__ as the name, which is just 'pow'.
server.register_function(pow)
def operacion(l):
    print l
    if l[1]=='+':
        s = xmlrpclib.ServerProxy('http://localhost:9001')
        result=s.suma(l[0],l[2])
    if l[1]=='-':
        s = xmlrpclib.ServerProxy('http://localhost:9002')
        result=s.resta(l[0],l[2])
    if l[1]=='*':
        s = xmlrpclib.ServerProxy('http://localhost:9003')
        result=s.multi(l[0],l[2])
    if l[1]=='/':
        s = xmlrpclib.ServerProxy('http://localhost:9004')
        result=s.div(l[0],l[2])
    if l[1]=='^':
Example #35
0
 def process_request(self, request, client_address):
     self.client_address = client_address
     return SimpleXMLRPCServer.process_request(self, request,
                                               client_address)
# Copyright (c) 2008 Doug Hellmann All rights reserved.
#
"""
"""

__version__ = "$Id$"
#end_pymotw_header

from SimpleXMLRPCServer import (
    SimpleXMLRPCServer,
    list_public_methods,
)
import os
import inspect

server = SimpleXMLRPCServer(('localhost', 9000), logRequests=True)
server.register_introspection_functions()


class DirectoryService:
    def _listMethods(self):
        return list_public_methods(self)

    def _methodHelp(self, method):
        f = getattr(self, method)
        return inspect.getdoc(f)

    def list(self, dir_name):
        """list(dir_name) => [<filenames>]
        
        Returns a list containing the contents of
Example #37
0
#!/usr/bin/python
#*- coding: UTF-8 -*-

from SimpleXMLRPCServer import SimpleXMLRPCServer
import xmlrpclib


def python_logo():
    with open("python_logo.jpg", "rb") as handle:
        return xmlrpclib.Binary(handle.read())


server = SimpleXMLRPCServer(("localhost", 8000))
print "Listening on port 8000..."
server.register_function(python_logo, 'python_logo')

server.serve_forever()
Example #38
0
	def rpcStart(self):
		self.logger.debug('rpcServer start......')
		self.server = SimpleXMLRPCServer((self.serverHost, self.serverPort))
		self.server.register_function(self.opCall)
		self.server.serve_forever()
 def process_request(self, request, client_address):
     if request is None:
         return
     SimpleXMLRPCServer.process_request(self, request, client_address)
    def run(self):
        from SimpleXMLRPCServer import SimpleXMLRPCServer
        from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
        from xmlrpclib import Fault

        config = get_mock_drupal_config()

        # Restrict to a particular path.
        class RequestHandler(SimpleXMLRPCRequestHandler):
            rpc_paths = (config['rpc_path'], )

        # Create server
        server = SimpleXMLRPCServer((config['rpc_host'], config['rpc_port']),
                                    requestHandler=RequestHandler,
                                    logRequests=False)
        server.register_introspection_functions()

        class MyFuncs:
            class user:  # lower case to match Drupal definition
                @classmethod
                def retrieve(cls, user_id):
                    # Real example:
                    # {'status': '1',
                    # 'uid': '28',
                    # 'publishers': {'11407': 'Cabinet Office',
                    #                '12022': 'Arts Council England'},
                    # 'roles': {'2': 'authenticated user'},
                    # 'pass': '******',
                    # 'threshold': '0',
                    # 'timezone': '3600',
                    # 'theme': '',
                    # 'access': '1288976307',
                    # 'init': '*****@*****.**',
                    # 'mail': '*****@*****.**',
                    # 'sort': '0',
                    # 'picture': '',
                    # 'picture_delete': '',
                    # 'form_build_id': 'form-6236f...',
                    # 'signature_format': '0',
                    # 'data': 'a:4:{s:7:"contact";i:1;s:14:"picture_delete";s:0:"";s:14:"picture_upload";s:0:"";s:13:"form_build_id";s:37:"form-6236...";}',
                    # 'name': 'evanking',
                    # 'language': '',
                    # 'created': '1262777740',
                    # 'picture_upload': '',
                    # 'contact': 1,
                    # 'mode': '0',
                    # 'signature': '',
                    # 'timezone_name': 'Europe/London',
                    # 'login': '******'}
                    try:
                        return config['test_users'][user_id]
                    except KeyError:
                        raise Fault(404, 'There is no user with such ID.')

            class organisation:
                @classmethod
                def one(cls, org_id):
                    # return org name by id
                    # Example response:
                    #   "Arts Council England"
                    try:
                        return self.organisations[org_id]['name']
                    except KeyError:
                        raise Fault(404,
                                    'There is no organisation with such ID.')

                @classmethod
                def match(cls, org_name):
                    # return org id by name
                    # Example response:
                    #   "12022"
                    for id, org_dict in self.organisations.items():
                        if org_name == org_dict['name']:
                            return id
                    raise Fault(404, 'Cannot find organisation %r.' % org_name)

                @classmethod
                def department(cls, org_id):
                    # return top level parent org id by org id
                    # Example response:
                    #   {'11419': 'Department for Culture, Media and Sport'}
                    if org_id in self.organisations:
                        parent_org_id = self.organisations[org_id][
                            'parent_department_id']
                        return {
                            parent_org_id:
                            self.organisations[parent_org_id]['name']
                        }
                    else:
                        raise Fault(
                            404,
                            'No department for organisation ID %r' % org_id)

            class session:
                @classmethod
                def retrieve(cls, session_id):
                    # return user_id given a session_id
                    # Example response:
                    #   62
                    try:
                        return config['test_sessions'][session_id]
                    except KeyError:
                        raise Fault(404, 'There is no session with such ID.')

        server.register_instance(MyFuncs(), allow_dotted_names=True)

        # Run the server's main loop
        self.log.debug('Serving on http://%s:%s%s', config['rpc_host'],
                       config['rpc_port'], config['rpc_path'])
        ckan_opts = '''
dgu.xmlrpc_username = 
dgu.xmlrpc_password = 
dgu.xmlrpc_domain = %(rpc_host)s:%(rpc_port)s
''' % config
        self.log.debug('CKAN options: %s', ckan_opts)
        self.log.debug('%i organisations' % len(self.organisations))
        while not self.quit_flag:
            server.handle_request()
Example #41
0
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
import math


# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2', )


# Create server
server = SimpleXMLRPCServer(("localhost", 9993), requestHandler=RequestHandler)
server.register_introspection_functions()


class MyFuncs:
    def pow(self, numero1, numero2):
        return pow(int(numero1), int(numero2))


server.register_instance(MyFuncs())
print "servidorPowCorriendo"
# Correr servidor indefinidamente
server.serve_forever()
Example #42
0
class ssdRpc:
	def __init__(self, port):
		serverHost = os.popen('hostname')
		self.serverHost = serverHost.read().replace('\n', '')
		self.serverPort = port
		self.logger = ssdGetLogger()
	
	def rpcStart(self):
		self.logger.debug('rpcServer start......')
		self.server = SimpleXMLRPCServer((self.serverHost, self.serverPort))
		self.server.register_function(self.opCall)
		self.server.serve_forever()

	def cmdRun(self, cmd, needResult = True):
		self.logger.debug('cmdRun: %r', cmd)
		result = os.popen(cmd)

		if needResult:
			result = result.read().replace('\n', '')
#			self.logger.debug('cmd: %r, result: %r', cmd, result)
			return result

	def hostScan(self):
		return {
			'magic'     : SSDMAGIC,
			'result'    : 0,
			'error'     : NOERR
		}

	def getKernel(self):
		cmd = 'uname -r'
		kernel = self.cmdRun(cmd, True)
		
		return {
			'magic'		: SSDMAGIC,
			'result'	: (self.serverHost, kernel),
			'error'		: NOERR
		}
		
	def changeKernel(self, kernelName):
		fileName = kernelName + '.tgz'
		if os.path.exists(fileName):
			self.logger.debug('%s exists, we remove it', fileName)
			cmd = 'rm -fr ' + fileName
			self.cmdRun(cmd, False)
			cmd = 'rm -fr ' + kernelName
			self.cmdRun(cmd, False)

		path = os.path.join(kernelUrl, fileName)
		cmd = 'wget ' + path + ' 2>/dev/null 1>/dev/null'
		self.cmdRun(cmd, False)

		if not os.path.exists(fileName):
			self.logger.debug('fail to download %s', fileName)
			return {
				'magic'     : SSDMAGIC,
				'result'    : -1,
				'error'		: ERRCHK
			}

		cmd = 'tar zxf ' + fileName + ' && cd ' + kernelName + ' && ./auto_changekernel.pl 1>/dev/null 2>/dev/null'
		self.cmdRun(cmd, False)

		self.logger.debug('We need to modify grub and reboot after change kernel')

		cmd = 'sed -i \'s/default=[^0]/default=0/g\' /boot/grub/grub.conf'
		self.cmdRun(cmd, False)

		#reboot after 1m
		cmd = 'shutdown -r +1 &'
		self.cmdRun(cmd, False)
		return {
			'magic'     : SSDMAGIC,
			'result'    : 0,
			'error'     : NOERR
		}

	def checkSsdMod(self, modName):
		cmd = 'lsmod | grep ' + modName
		return not not self.cmdRun(cmd, True)

	def checkDevice(self):
		#check /dev/ssd
		TIMES = 5
		timesTry = 0
		while timesTry < TIMES:
			cmd_test = 'ls /dev | grep ssd_Baidu43'
			if self.cmdRun(cmd_test, True):
				break

			timesTry += 1
			time.sleep(3)

		if timesTry == TIMES:
			self.logger.debug('scan device timeout')
			return {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRINSMOD
			}

		time.sleep(3)
		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}

	def insmodSsdDriver(self, rootDir):
		drvName = 'ssd_drv.ko'
		modName = drvName.replace('.ko', '')
		if self.checkSsdMod(modName):
			self.logger.debug('we need to rmmod driver')
			cmd = 'rmmod ' + modName
			if self.cmdRun(cmd, True):
				self.logger.debug('fail to rmmod driver')
				return {
					'magic'		: SSDMAGIC,
					'result'	: -1,
					'error'		: ERRRMMOD
				}
		
		drvPath = os.path.join(rootDir, drvName)
		if not os.path.exists(drvPath):
			return self.loadSsdDriver(drvName, rootDir)

		cmd = 'insmod ' + drvPath
		self.cmdRun(cmd, False)
		"""
		cmd = 'modprobe ' + modName
		res = self.cmdRun(cmd, True)

		if 'FATAL' in res:
			res = self.loadSsdDriver(drvName, rootDir)
			if NOERR != res['error']:
				return res
		"""

		if not self.checkSsdMod(modName):
			self.logger.debug('fail to insmod driver')
			return {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRINSMOD
			}

		res = self.checkDevice()
		if NOERR != res['error']:
			return res

		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}

	def loadSsdDriver(self, drvName = 'ssd_drv.ko', rootDir = None):
		ssdName = drvName.replace('.ko', '')
		""" 
		if ssd driver is exists, we rmmod it
		"""
		if self.checkSsdMod(ssdName):
			self.logger.debug('we need to rmmod driver')
			cmd = 'rmmod ' + ssdName
			if self.cmdRun(cmd, True):
				self.logger.debug('fail to rmmod driver')
				return {
					'magic'		: SSDMAGIC,
					'result'	: -1,
					'error'		: ERRRMMOD
				}
				
		"""
		now we can insmod ssd driver(maybe named by driverName)
		"""
		if os.path.exists(drvName):
			self.logger.debug('%s exists, we remove it', drvName)
			cmd = 'rm -fr ' + drvName
			self.cmdRun(cmd, False)

		url = os.path.join(toolsUrl, drvName)
		cmd = 'wget ' + url + ' 2>/dev/null 1>/dev/null'
		self.cmdRun(cmd, False)
		if not os.path.exists(drvName):
			self.logger.debug('driver is not exist')
			return {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRNOFILE
			}
		"""
		cmd = 'insmod ' + drvName
		self.cmdRun(cmd, False)

		if rootDir:
			cmd = 'cp -f --reply=yes ' + drvName + ' ' + rootDir
			self.cmdRun(cmd)
		"""
		cmd = 'uname -r'
		path = self.cmdRun(cmd, True)
		modPath = '/lib/modules/' + path + '/kernel/drivers/block/'

		cmd = 'cp -f --reply=yes ' + drvName + ' ' + modPath
		self.cmdRun(cmd, False)

		cmd = 'depmod -a'
		self.cmdRun(cmd, False)

		cmd = 'modprobe ' + ssdName
		self.cmdRun(cmd, False)
		#check module
		if not self.checkSsdMod(ssdName):
			self.logger.debug('fail to insmod driver')
			return {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRINSMOD
			}

		res = self.checkDevice()
		if NOERR != res['error']:
			return res

		#success
		self.logger.debug('success to insmod driver')
		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}

	def downLoads(self, rootDir):
		fileList = ['flash_tools.tar.gz', 'bridge', 'controller', 'op_tools.tar', 'ssd_drv.ko']
		self.logger.debug('download files: %r', fileList)

		cmd = 'mkdir -p ' + rootDir
		self.cmdRun(cmd, False)

		for file in fileList:
			if os.path.exists(file):
				self.logger.debug('%s exists, we remove it', file)
				cmd = 'rm -fr ' + file
				self.cmdRun(cmd, False)

			url = os.path.join(toolsUrl, file)
			cmd = 'wget ' + url + ' 2>/dev/null 1>/dev/null'
			self.cmdRun(cmd, False)
			if not os.path.exists(file):
				self.logger.debug('%s is not exist', file)
				return {
					'magic'		: SSDMAGIC,
					'result'	: -1,
					'error'		: ERRDOWN
				}

			cmd = 'mv -f ' + file + ' ' + rootDir
			self.cmdRun(cmd, False)
		
		cmd = 'cd ' + rootDir + ' && tar zxf '
		cmd_1 = cmd + 'flash_tools.tar.gz'
		self.cmdRun(cmd_1, False)

		cmd_2 = cmd + 'op_tools.tar'
		self.cmdRun(cmd_2, False)

		return {
			'magic'		: SSDMAGIC,
			'result'	: fileList,
			'error'		: NOERR
		}

	def cfgFlash(self, rootDir):
		fileList = ['flash_tools', 'bridge', 'controller']
		for file in fileList:
			fileName = os.path.join(rootDir, file)
			if not os.path.exists(fileName):
				res = self.downLoads(rootDir)
				if NOERR != res['error']:
					return res

		#get erase count from huawei
		res = self.getEcFromHuawei(rootDir)
		if NOERR != res['error']:
			return res

		cmd = 'cd ' + rootDir + ' '
		cmd += '&& mv bridge controller flash_tools/huawei-mlc-3G/ssd_utils '
		cmd += '&& cd flash_tools/huawei-mlc-3G/ssd_utils '
		cmd += '&& ./ssd_fwcrc -f . 2>/dev/null 1>/dev/null '
		cmd += '&& ./ssd_firmware -d /dev/ssda -f ssd_fw 2>/dev/null 1>/dev/null '
		self.cmdRun(cmd, False)

		cmd = 'init 6'
		self.cmdRun(cmd, False)
		
		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}

	def reloadS6(self, rootDir, checkFlash = False):
		cmd = 'cd ' + rootDir + ' '
		#step 2: check V5
		cmd_v5_check = cmd + '&& ./wr_n 0x80f8 0 '
		self.cmdRun(cmd_v5_check, False)

		#step 3: reset
		cmd_v5_reset = cmd + '&& ./wr_n 0x80f8 1'
		self.cmdRun(cmd_v5_reset, False)

		cmd_v5_check = cmd + '&& ./rd_n 0x8068'
		res = self.cmdRun(cmd_v5_check, True)
		lastChar = res[-1]

		#unlikely
		if '0' != lastChar and checkFlash:
			self.logger.debug('check V5 error: %r', res)
			cmd_s6 = cmd + '&& ./cfg_flash_n final_new.mcs '
			self.cmdRun(cmd_s6, False)
			cmd_v5_n = cmd + '&& ./cfg_v5_n '
			self.cmdRun(cmd_v5_n, False)
			####reboot?
			self.cmdRun('reboot', False)

			return {
			'magic'		: SSDMAGIC,
			'result'	: res,
			'error'		: ERRV5
			}
			
		cmd_s6 = cmd + '&& ./cfg_s6_n_40 1 '
		res = self.cmdRun(cmd_s6, True)
		
		self.logger.debug('load S6: %r', res)
		if 'sucess' not in res:
			self.logger.debug('load S6 error: %r', res)

			return {
			'magic'		: SSDMAGIC,
			'result'	: res,
			'error'		: ERRS6
			}

		#init newcard
		cmd_init = cmd + '&& ./open_newcard'
		res = self.cmdRun(cmd_init, True)
		self.logger.debug('open new card: %r', res)
		if 'PASS' not in res:
			self.logger.debug('open newcard error: %r', res)
			return {
				'magic'		: SSDMAGIC,
				'result'	: res,
				'error'		: ERRNEWCARD
			}
		
		#success
		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}
		
	def checkFlash(self, rootDir):
		#check pci
		cmd_pci = 'lspci | grep \'RAM memory\''
		res = self.cmdRun(cmd_pci, True)
		if not 'RAM memory' in res:
			self.logger.debug('change pci error: %r', res)
			return {
				'magic'		: SSDMAGIC,
				'result'	: res,
				'error'		: ERRPCI
			}
		
		#load ssd_drv-ne.ko
		ssdChkName = 'ssd_drv'
		if self.checkSsdMod(ssdChkName):
			self.logger.debug('we need to rmmod driver')
			cmd_chk = 'rmmod ' + ssdChkName
			if self.cmdRun(cmd_chk, True):
				self.logger.debug('fail to rmmod driver')
				return {
					'magic'		: SSDMAGIC,
					'result'	: -1,
					'error'		: ERRRMMOD
				}

		cmd = 'cd ' + rootDir + ' '
		"""
		cmd_tar = cmd + '&& tar zxf op_tools.tar '
		self.cmdRun(cmd_tar, False)
		"""
		cmd += '&& cd op_tools '
		cmd_insmod = cmd + '&& insmod ssd_drv-ne.ko'
		self.cmdRun(cmd_insmod, False)

		if not self.checkSsdMod(ssdChkName):
			self.logger.debug('fail to insmod driver')
			return {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRINSMOD
			}

		res = self.checkDevice()
		if NOERR != res['error']:
			return res

		#load S6
		cmd_s6 = cmd + '&& ./cfg_s6_n_40 1 '
		res = self.cmdRun(cmd_s6, True)

		self.logger.debug('load S6: %r', res)
		if 'sucess' not in res:
			self.logger.debug('load S6 error: %r', res)

			return {
			'magic'		: SSDMAGIC,
			'result'	: res,
			'error'		: ERRS6
			}
		
		cmd_s6_2 = cmd + '&& ./wr_n 0x80e8 1 '
		self.cmdRun(cmd_s6_2, False)
		#step 1: check version of V5
		cmd_v5_version = cmd + '&& ./rd_n 0x8000'
		res = self.cmdRun(cmd_v5_version, True)
		#get the lastest charactor, expect: '9'
		lastChar = res[-1]
		if '9' != lastChar:
			self.logger.debug('check version of V5 error: %r', res)
			#########reboot?
			self.cmdRun('reboot', False)

			return {
			'magic'		: SSDMAGIC,
			'result'	: res,
			'error'		: ERRV5V
			}
		
		cmd_v5 = cmd + '&& ./rd_n 0x8068 '
		res = self.cmdRun(cmd_v5, True)

		self.logger.debug('check V5: %r', res)
		if '0' != res[-1]:
			cmd_v5_load = cmd + '&& ./cfg_v5_n '
			self.cmdRun(cmd_v5_load, False)

			self.cmdRun('reboot', False)

			return {
			'magic'		: SSDMAGIC,
			'result'	: res,
			'error'		: ERRV5
			}

		self.logger.debug('open new card for Baidu SSD')
		cmd_init = cmd + '&& ./open_newcard'
		res = self.cmdRun(cmd_init, True)
		if 'PASS' not in res:
			self.logger.debug('open newcard error: %r', res)
			dir = os.path.join(rootDir, 'op_tools')
			res = self.reloadS6(dir, True)

			if NOERR != res['error']:
				self.logger.debug('check V5 and S6 error, errorno: %r', res['error'])
				if ERRNEWCARD == res['error']:
					res = self.reloadS6(dir, False)
					#unlikely
					if NOERR != res['error']:
						cmd_v5_load = cmd + '&& ./cfg_v5_n '
						self.cmdRun(cmd_v5_load, False)

						self.cmdRun('reboot', False)
						return res
				else:
					return res

		#replace ssd driver
		cmd_rmmod = 'rmmod ssd_drv'
		self.cmdRun(cmd_rmmod, False)
		#get udev version
		res = self.cmdRun('udev -V', True)
		if int(res) < 70:
			udev_name = 'udev-070.tar.gz'
			cmd_udev = 'wget ' + udevUrl + udev_name + ' >/dev/null 2>/dev/null'
			self.cmdRun(cmd_udev, False)
			cmd_udev = 'tar zxf ' + udev_name + ' && cd udev-070 && make >/dev/null 2>/dev/null && make install >/dev/null 2>/dev/null && cd .. && rm udev-070* -fr'
			self.cmdRun(cmd_udev, False)
			self.logger.debug('update udev version to 070')

		#copy rules
		cmd_rules = cmd + '&& cp -f --reply=yes 60-BaiduSSD.rules /etc/udev/rules.d/ '
		self.cmdRun(cmd_rules, False)
		
		res = self.insmodSsdDriver(rootDir)
		if NOERR != res['error']:
			self.logger.debug('load driver error: %r', res)
			return res

		#init newcard again
		self.logger.debug('open new card for new Baidu SSD')
		cmd_init = cmd + '&& ./init_newcard'
		res = self.cmdRun(cmd_init, True)
		if 'PASS' not in res:
			self.logger.debug('open newcard error: %r', res)
			return {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRNEWCARD
			}
		"""
		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}
		"""
		#set erase table to baidu SSD
		res = self.setEcToBaidu(rootDir)
		return res

	def softLinkTools(self, rootDir):
		dir = os.path.join(rootDir, 'op_tools')
		softLinks = ['ssd_error', 'ssd_ls', 'ssd_stat', 'ssd_read_id', 'ssd_read_table', 'util_erasetable', 'close_force', 'ssd_mark_bad_block', 'ssd_erase_id', 'ssd_mark_erase_count']

		for link in softLinks:
			src = os.path.join(dir, link)
			dst = os.path.join('/bin', link)
			cmd = 'ln -s ' + src + ' ' + dst

			res = self.cmdRun(cmd, True)
			if 'exists' in res:
				self.logger.debug('%s exists: %r', link, res)

		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}
	
	def depMod(self, rootDir):
		ssdName = 'ssd_drv.ko'
		ssdPath = os.path.join(rootDir, ssdName)

		if not os.path.exists(ssdPath):
			self.insmodSsdDriver(rootDir)
		else:
			cmd = 'uname -r'
			path = self.cmdRun(cmd, True)
			modPath = '/lib/modules/' + path + '/kernel/drivers/block/'

			cmd = 'cp -f --reply=yes ' + ssdPath + ' ' + modPath
			self.cmdRun(cmd, False)

			cmd = 'depmod -a'
			self.cmdRun(cmd, False)

		"""add ssd driver to rc.local"""
		cmd = 'sed -i \'/modprobe ssd_drv/d\' /etc/rc.d/rc.local'
		self.cmdRun(cmd, False)
		cmd = 'echo modprobe ssd_drv >> /etc/rc.d/rc.local'
		self.cmdRun(cmd, False)
		#reload ssd driver
		self.cmdRun('rmmod ssd_drv', False)
		self.cmdRun('modprobe ssd_drv', False)

		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}

	def checkSsd(self, rootDir):
		res = self.insmodSsdDriver('ssd_drv')
		if res['error'] != NOERR:
			self.logger.debug('insmod driver error')
			return {
				'magic'		: SSDMAGIC,
				'result'	: res,
				'error'		: ERRCHECK
			}

		toolPath = os.path.join(rootDir, 'op_tools')	
		cmd = 'cd ' + toolPath + ' && ./ssd_check_all > ssd_check.log'

		self.cmdRun(cmd, False)

		cmd_cat = 'cd ' + toolPath + ' && cat ssd_check.log'
		res = self.cmdRun(cmd_cat, True)
		if 'error' not in res:
			return {
				'magic'		: SSDMAGIC,
				'result'	: 0,
				'error'		: NOERR
			}
		else:
			return {
				'magic'		: SSDMAGIC,
				'result'	: res,
				'error'		: ERRCHECK
			}
			
	def getEcFromHuawei(self, rootDir):
		tools = os.path.join(rootDir, 'flash_tools')
		table = 'erase_table_huawei'
		if not os.path.exists(tools):
			self.logger.debug('we need download tools')
			self.downLoads(rootDir)

		huawei_tools_path = rootDir + '/flash_tools/huawei-mlc-3G/ssd_utils'
		table_path = os.path.join(rootDir, table)
		cmd = 'cd ' + huawei_tools_path + ' && ./ssd_ecinfo -d /dev/ssda > ' + table_path
		self.cmdRun(cmd, False)

		cmd = 'cat ' + table_path + ' | wc -l'
		res = self.cmdRun(cmd, True)
		if res != '45056':
			self.logger.debug('erase table error')
			return {
				'magic'		: SSDMAGIC,
				'result'	: res,
				'error'		: ERRGETEC
			}

		self.logger.debug("get erase count from huawei: %r", table_path)
		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}

	def setEcToBaidu(self, rootDir):
		table = 'erase_table_huawei'
		table_path = os.path.join(rootDir, table)
		if not os.path.exists(table_path):
			self.logger.debug('%r is not exist', table_path)
			return {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRGETEC
			}

		cmd_path = os.path.join(rootDir, 'op_tools')
		cmd_path = os.path.join(cmd_path, 'ssd_mark_erase_count')

		cmd = cmd_path + ' -f ' + table_path
		res = self.cmdRun(cmd, True)

		if 'fail' in res:
			self.logger.debug("fail to set erase count to baidu SSD")
			return {
				'magic'		: SSDMAGIC,
				'result'	: res,
				'error'		: ERRSETEC
			}

		self.logger.debug('success to set erase count to baidu SSD')
		return {
			'magic'		: SSDMAGIC,
			'result'	: 0,
			'error'		: NOERR
		}

	def opCall(self, request):
		self.logger.debug('recieve request: %r', request)
		reply = None
		if SSDMAGIC != request['magic']:
			reply = {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERRMAGIC
			}
			self.logger.debug('send reply: %r', reply)
			return reply
		
		try:	
			reply = {
				SCAN		: lambda x	: self.hostScan(),
				GETKERNEL	: lambda x	: self.getKernel(),
				CHKERNEL	: lambda x	: self.changeKernel(x),
				CHSSDDRV	: lambda x	: self.loadSsdDriver(x),
				CFGFLASH	: lambda x	: self.cfgFlash(x),
				DOWNLOAD	: lambda x	: self.downLoads(x),
				CHKFLASH	: lambda x	: self.checkFlash(x),
				INSMODDRV	: lambda x	: self.insmodSsdDriver(x),
				LINK		: lambda x	: self.softLinkTools(x),
				DEPDRIVER	: lambda x	: self.depMod(x),
				CHECKSSD	: lambda x	: self.checkSsd(x),
				GETEC		: lambda x	: self.getEcFromHuawei(x),
				SETEC		: lambda x	: self.setEcToBaidu(x),
			}[request['operation']](request['handle'])
		except Exception:
			reply = {
				'magic'		: SSDMAGIC,
				'result'	: -1,
				'error'		: ERROPER
			}

		self.logger.debug('send reply: %r', reply)
		return reply
Example #43
0
	(options, args) = parser.parse_args()

	# Change-key mode
	if options.key or options.user:
		if not (options.key and options.user):
			parser.error("options -c and -u must be used together")
		ssc = SSConf() # the easiest way to read config ;-)
		server = xmlrpclib.ServerProxy("http://%s:%d/" % (ssc.address, ssc.port))
		server.set_key(ssc.admin, ssc.passhash, options.user, options.key)
	else:
		# Server mode
		logging.basicConfig(filename="/opt/szarp/logs/ssconf.log", level=logging.INFO)
		# daemonize
		if options.fork:
			pid = os.fork()
			if pid != 0:
				# parent process, kill myself
				sys.exit()

		logging.info("Starting ssconf")
		ssc = SSConf()
		server = SimpleXMLRPCServer((ssc.address, ssc.port), logRequests = (not options.fork))
		server.register_instance(ssc)
		try:
			server.serve_forever()
		except Exception(e):
			logging.error("Unexpected exception: " + str(e))
			raise e

 def close_request(self, request):
     if request is None:
         return
     SimpleXMLRPCServer.close_request(self, request)
Example #45
0
def aStream():

    #aFile = open("./_THE_STREAM_.txt", "w")
    oFile = sys.stdout
    iFile = sys.stdin

    fakeStdOut = SimpleXMLRPCServer(("localhost", 0),
                                    allow_none=True,
                                    logRequests=False)
    fakeStdOut.register_function(lambda t: "pong", 'Stream.ping')
    fakeStdOut.register_function(lambda t: "pong", 'Listener.ping')
    fakeStdOut.register_function(
        lambda t, s: oFile.write("RPC: " + s + "\n") or True, 'Stream.write')
    fakeStdOut.register_function(
        lambda *args: oFile.write("RPC: CLOSE!") or True, 'Stream.close')
    fakeStdOut.register_function(
        lambda t: oFile.write("RPC Input: ") or iFile.readline(),
        'Stream.readline')
    fakeStdOut.register_function(
        lambda t, en, *args: oFile.write("RPC Notify: [%s] %s\n" %
                                         (en, repr(args))) or True,
        'Listener.notify')

    thread.start_new_thread(fakeStdOut.serve_forever, ())

    #return fakeStdOut.server_address
    return "http://%s:%s" % tuple([str(x) for x in fakeStdOut.server_address])
Example #46
0
def start_reload(zope_layer_dotted_name, reload_paths=('src',),
                 preload_layer_dotted_name='plone.app.testing.PLONE_FIXTURE',
                 extensions=None):

    print WAIT("Starting Zope 2 server")

    zsl = Zope2Server()
    zsl.start_zope_server(preload_layer_dotted_name)

    forkloop = ForkLoop()
    watcher = Watcher(reload_paths, forkloop)
    if extensions:
        watcher.allowed_extensions = extensions
    elif HAS_DEBUG_MODE:
        watcher.allowed_extensions.remove('pt')
    watcher.start()
    forkloop.start()

    if forkloop.exit:
        print WAIT("Stopping Zope 2 server")
        zsl.stop_zope_server()
        print READY("Zope 2 server stopped")
        return

    # XXX: For unknown reason call to socket.gethostbyaddr may cause malloc
    # errors on OSX in forked child when called from medusa http_server, but
    # proper sleep seem to fix it:
    import time
    import socket
    import platform
    if 'Darwin' in platform.uname():
        gethostbyaddr = socket.gethostbyaddr
        socket.gethostbyaddr = lambda x: time.sleep(0.5) or (ZSERVER_HOST,)

    # Setting smaller asyncore poll timeout will speed up restart a bit
    import plone.testing.z2
    plone.testing.z2.ZServer.timeout = 0.5

    zsl.amend_zope_server(zope_layer_dotted_name)

    if HAS_DEBUG_MODE:
        import App.config
        config = App.config.getConfiguration()
        config.debug_mode = HAS_DEBUG_MODE
        App.config.setConfiguration(config)

    if 'Darwin' in platform.uname():
        socket.gethostbyaddr = gethostbyaddr

    print READY("Zope 2 server started")

    try:
        listener = SimpleXMLRPCServer((LISTENER_HOST, LISTENER_PORT),
                                      logRequests=False)
    except socket.error as e:
        print ERROR(str(e))
        print WAIT("Pruning Zope 2 server")
        zsl.prune_zope_server()
        return

    listener.timeout = 0.5
    listener.allow_none = True
    listener.register_function(zsl.zodb_setup, 'zodb_setup')
    listener.register_function(zsl.zodb_teardown, 'zodb_teardown')

    try:
        while not forkloop.exit:
            listener.handle_request()
    except select.error:  # Interrupted system call
        pass
    finally:
        print WAIT("Pruning Zope 2 server")
        zsl.prune_zope_server()
Example #47
0
                if f == idc.SetColor:
                    flags |= idaapi.MFF_NOWAIT
                    rv.append(None)
                idaapi.execute_sync(work, flags)
            return rv[0]
        except:
            import traceback
            traceback.print_exc()
            raise

    return wrapper


def register_module(module):
    for name, function in module.__dict__.items():
        if hasattr(function, '__call__'):
            server.register_function(wrap(function), name)


server = SimpleXMLRPCServer(('127.0.0.1', port),
                            logRequests=True,
                            allow_none=True)
register_module(idc)
register_module(idautils)
register_module(idaapi)
server.register_introspection_functions()

thread = threading.Thread(target=server.serve_forever)
thread.daemon = True
thread.start()
Example #48
0
class MasterMonitor(object):
    '''
  This class provides methods to get the state from the ROS master using his 
  RPC API and test for changes. Furthermore an XML-RPC server will be created
  to offer the complete current state of the ROS master by one method call.
  @see: L{getState()}
  RPC Methods:
  @see: L{getListedMasterInfo()} or L{getMasterContacts()} as RPC: C{masterInfo()} and 
  C{masterContacts()}
  @group RPC-methods: getListedMasterInfo, getMasterContacts
  '''
    def __init__(self, rpcport=11611):
        '''
    Initialize method. Creates an XML-RPC server on given port and starts this
    in its own thread.
    @param rpcport: the port number for the XML-RPC server
    @type rpcport:  C{int}
    '''
        self._lock = threading.RLock()
        self.__masteruri = self._masteruri_from_ros()

        self.__masteruri_rpc = None
        self.__mastername = None
        if rospy.has_param('~name'):
            self.__mastername = rospy.get_param('~name')

        self.master_state = None
        '''@ivar: the current state of the ROS master'''
        self.rpcport = rpcport
        '''@ivar: the port number of the RPC server'''

        # Create an XML-RPC server
        ready = False
        while not ready and (not rospy.is_shutdown()):
            try:
                self.rpcServer = SimpleXMLRPCServer(('', rpcport),
                                                    logRequests=False,
                                                    allow_none=True)
                rospy.loginfo("Start RPC-XML Server at %s",
                              self.rpcServer.server_address)
                self.rpcServer.register_introspection_functions()
                self.rpcServer.register_function(self.getListedMasterInfo,
                                                 'masterInfo')
                self.rpcServer.register_function(self.getMasterContacts,
                                                 'masterContacts')
                self._rpcThread = threading.Thread(
                    target=self.rpcServer.serve_forever)
                self._rpcThread.setDaemon(True)
                self._rpcThread.start()
                ready = True
            except socket.error:
                rospy.logwarn(''.join([
                    "Error while start RPC-XML server on port ",
                    str(rpcport), ". Try again..."
                ]))
                time.sleep(1)
            except:
                import traceback
                print traceback.format_exc()

    def _masteruri_from_ros(self):
        '''
    Returns the master URI depending on ROS distribution API.
    @return: ROS master URI
    @rtype C{str}
    '''
        try:
            import rospkg.distro
            distro = rospkg.distro.current_distro_codename()
            if distro in ['electric', 'diamondback', 'cturtle']:
                return roslib.rosenv.get_master_uri()
            else:
                import rosgraph
                return rosgraph.rosenv.get_master_uri()
        except:
            return roslib.rosenv.get_master_uri()

    def shutdown(self):
        '''
    Shutdown the RPC Server.
    '''
        if hasattr(self, 'rpcServer'):
            self.rpcServer.shutdown()

    def getNodePid(self, nodes):
        '''
    Gets process id of the node.
    @param nodename: the name of the node
    @type nodename: C{str}
    @param uri: the uri of the node
    @type uri: C{str}
    '''
        for (nodename, uri) in nodes.items():
            if not uri is None:
                pid = None
                try:
                    node = xmlrpclib.ServerProxy(uri)
                    pid = _succeed(node.getPid(rospy.get_name()))
                except (Exception, socket.error):
                    #      import traceback
                    #      print traceback.format_exc()
                    self._lock.acquire(True)
                    master = xmlrpclib.ServerProxy(self.__masteruri)
                    #      print "request again nodeuri for", nodename
                    code, message, self.new_master_state.getNode(
                        nodename).uri = master.lookupNode(
                            rospy.get_name(), nodename)
                    self._lock.release()
                    if (code == -1):
                        self._lock.acquire(True)
                        self.new_master_state.getNode(nodename).uri = None
                        self._lock.release()
                else:
                    self._lock.acquire(True)
                    self.new_master_state.getNode(nodename).pid = pid
                    self._lock.release()

    def getServiceInfo(self, services):
        '''
    Gets service info through the RPC interface of the service.
    @param service: the name of the service
    @type service: C{str}
    @param uri: the uri of the service
    @type uri: C{str}
    '''
        for (service, uri) in services.items():
            if not uri is None:
                type = dest_addr = dest_port = None
                try:
                    dest_addr, dest_port = rospy.parse_rosrpc_uri(uri)
                except:
                    #      print "ERROR while get service info"
                    continue
#          return
#      raise ROSServiceException("service [%s] has an invalid RPC URI [%s]"%(service, uri))
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                try:
                    # connect to service and probe it to get the headers
                    s.settimeout(0.5)
                    s.connect((dest_addr, dest_port))
                    header = {
                        'probe': '1',
                        'md5sum': '*',
                        'callerid': rospy.get_name(),
                        'service': service
                    }
                    roslib.network.write_ros_handshake_header(s, header)
                    type = roslib.network.read_ros_handshake_header(
                        s, cStringIO.StringIO(), 2048)
                except socket.error:
                    pass
        #      raise ROSServiceIOException("Unable to communicate with service [%s], address [%s]"%(service, uri))
                except:
                    pass
                finally:
                    if s is not None:
                        s.close()

        self._lock.acquire(True)
        try:
            self.new_master_state.getService(service).type = type['type']
        except:
            pass
#      print "ignored:"
#      import traceback
#      traceback.print_exc()
#      print "type field in service header not available, type:", type
        self._lock.release()

    def getListedMasterInfo(self):
        '''
    Returns a extended roscore state. 
    @return: complete roscore state as
             
             C{(stamp, masteruri, name, publishers, subscribers, services, topicTypes, nodes, serviceProvider)}
             
               - C{publishers} is of the form
                 
                 C{[ [topic1, [topic1Publisher1...topic1PublisherN]] ... ]}
               
               - C{subscribers} is of the form
                 
                 C{[ [topic1, [topic1Subscriber1...topic1SubscriberN]] ... ]}
               
               - C{services} is of the form
                 
                 C{[ [service1, [service1Provider1...service1ProviderN]] ... ]}
               
               - C{topicTypes} is a list of 
                 
                 C{[[topicName1, topicType1], ... ]}
               
               - C{nodes} is a list of (the pid of remote Nodes will not be resolved)
                 
                 C{[nodename, XML-RPC URI, pid, E{lb} local, remote E{rb}]}
               
               - C{serviceProvider} is a list of (the type, serviceClass and args of remote Services will not be resolved)
                 
                 C{[service, XML-RPC URI, type, E{lb} local, remote E{rb}]}
               
    @rtype: C{(float, 
               str,
               str,
               [ [str,[str] ] ], 
               [ [str,[str] ] ], 
               [ [str,[str] ] ], 
               [ [str,str] ], 
               [ [str,str,int,str] ], 
               [ [str,str,str,str] ])}
    '''
        self._lock.acquire(True)
        result = (str(time.time()), self.getMasteruri(),
                  str(self.getMastername()), [], [], [], [], [], [])
        if not (self.master_state is None):
            try:
                result = self.master_state.listedState()
            except:
                import traceback
                print traceback.format_exc()
        self._lock.release()
        return result

    def getState(self):
        '''
    Gets state from the ROS master through his RPC interface.
    @rtype: L{MasterInfo}
    @raise MasterConnectionException: if not complete information was get from the ROS master.
    '''
        now = time.time()

        threads = []
        try:
            #      import os
            #      cputimes = os.times()
            #      cputime_init = cputimes[0] + cputimes[1]
            self._lock.acquire(True)
            self.new_master_state = master_state = MasterInfo(
                self.getMasteruri(), self.getMastername())
            #      print "get state from ros master", self.__masteruri
            master = xmlrpclib.ServerProxy(self.__masteruri)
            # get system state
            code, message, state = master.getSystemState(rospy.get_name())
            # get topic types
            code, message, topicTypes = master.getTopicTypes(rospy.get_name())
            #convert topicType list to the dict
            topicTypesDict = {}
            for topic, type in topicTypes:
                topicTypesDict[topic] = type

            # add published topics
            for t, l in state[0]:
                master_state.topics = t
                for n in l:
                    master_state.nodes = n
                    master_state.getNode(n).publishedTopics = t
                    master_state.getTopic(t).publisherNodes = n
                    master_state.getTopic(t).type = topicTypesDict.get(
                        t, 'None')
            # add subscribed topics
            for t, l in state[1]:
                master_state.topics = t
                for n in l:
                    master_state.nodes = n
                    master_state.getNode(n).subscribedTopics = t
                    master_state.getTopic(t).subscriberNodes = n
                    master_state.getTopic(t).type = topicTypesDict.get(
                        t, 'None')
#      cputimes = os.times()
#      print "Auswertung: ", (cputimes[0] + cputimes[1] - cputime_init)

# add services
#      cputimes = os.times()
#      cputime_init = cputimes[0] + cputimes[1]

            services = dict()
            tmp_slist = []
            # multi-call style xmlrpc to lock up the service uri
            param_server_multi = xmlrpclib.MultiCall(master)
            for t, l in state[2]:
                master_state.services = t
                for n in l:
                    master_state.nodes = n
                    master_state.getNode(n).services = t
                    service = master_state.getService(t)
                    service.serviceProvider = n
                    tmp_slist.append(service)
                    param_server_multi.lookupService(rospy.get_name(), t)
#          code, message, service.uri = master.lookupService(rospy.get_name(), t)
#          if (code == -1):
#            service.uri = None
#          elif service.isLocal:
#            services[service.name] = service.uri
            try:
                r = param_server_multi()
                for (code, msg, uri), service in zip(r, tmp_slist):
                    if code == 1:
                        service.uri = uri
                        if service.isLocal:
                            services[service.name] = uri
            except:
                import traceback
                traceback.print_exc()

            if services:
                pidThread = threading.Thread(target=self.getServiceInfo,
                                             args=((services, )))
                pidThread.start()
                threads.append(pidThread)
#          if service.isLocal:
#            try:
#              pidThread = threading.Thread(target = self.getServiceInfo, args=(t, service.uri))
#      #        self._pidThread.setDaemon(True)
#              pidThread.start()
#              threads.append(pidThread)
#  #            master_state.getService(t).type = rosservice.get_service_headers(t, master_state.getService(t).uri).get('type', None)
#  #            master_state.getService(t).serviceClass = get_service_class_by_type(master_state.getService(t).type)
#  #            master_state.getService(t).args = roslib.message.get_printable_message_args(master_state.getService(t).serviceClass._request_class)
#            except rosservice.ROSServiceIOException, ROSServiceException:
#              pass

#get additional node information
            nodes = dict()
            #      for n in master_state.nodes:
            #        node = master_state.getNode(n)
            #        code, message, node.uri = master.lookupNode(rospy.get_name(), n)
            #        if (code == -1):
            #          node.uri = None
            #        elif node.isLocal:
            #          nodes[node.name] = node.uri

            try:
                # multi-call style xmlrpc to loock up the node uri
                param_server_multi = xmlrpclib.MultiCall(master)
                tmp_nlist = []
                for name, node in master_state.nodes.items():
                    tmp_nlist.append(node)
                    param_server_multi.lookupNode(rospy.get_name(), name)
                r = param_server_multi()
                for (code, msg, uri), node in zip(r, tmp_nlist):
                    if code == 1:
                        node.uri = uri
                        if node.isLocal:
                            nodes[node.name] = uri
            except:
                import traceback
                traceback.print_exc()

#      cputimes = os.times()
#      print "Nodes+Services:", (cputimes[0] + cputimes[1] - cputime_init), ", count nodes:", len(nodes)
            if nodes:
                # get process id of the nodes
                pidThread = threading.Thread(target=self.getNodePid,
                                             args=((nodes, )))
                pidThread.start()
                threads.append(pidThread)

            master_state.timestamp = now
        except socket.error, (errn, msg):
            if not errn in [100, 101, 102]:
                import traceback
                formatted_lines = traceback.format_exc().splitlines()
                #      print "Service call failed: %s"%traceback.format_exc()
                raise MasterConnectionException(formatted_lines[-1])
        except:
   def do_OPTIONS(self):
       self.send_response(200)
       self.end_headers()

   # Add these headers to all responses
   def end_headers(self):
       self.send_header("Access-Control-Allow-Headers", 
                        "Origin, X-Requested-With, Content-Type, Accept")
       self.send_header("Access-Control-Allow-Origin", "*")
       SimpleXMLRPCRequestHandler.end_headers(self)    

#Set up logging
logging.basicConfig(level=logging.DEBUG)

server = SimpleXMLRPCServer (('localhost', 9000),logRequests=True,requestHandler=RequestHandler)

#register XML-RPC introspextion functions such as system.listMethods()
server.register_introspection_functions()

#implement Multicall (added by Ruben)
server.register_multicall_functions()

#Expose functions

def get_weather_station_location():
	return "Oizy - Belgium"
server.register_function(get_weather_station_location)

def get_weather_station_coordinates():
	return "49.8966N-5.011E"
Example #50
0
class XmlRpcServer(object):
    """The class running the server so we can import and start it manually."""
    def __init__(self):
        """Default initialization.

    Attributes:
      _server: A SimpleXMLRPCServer so make our objects and method available.
      _thread: A Thread in which to run the shutdown code to avoid deadlocks.
    """
        self._server = None
        self._thread = None

    def _ShutdownServer(self):
        """Shutting down the server from another thread."""
        assert self._thread.ident == threading.currentThread().ident

        if self._server:
            logging.debug('XmlRpcServer shutting down the server')
            self._server.shutdown()
            self._server.server_close()
            self._server = None
            logging.debug('XmlRpcServer _Shutdown done')

    def Shutdown(self):
        """Shuts down the server.

    Returns:
      True.
    """
        # We must do this from another thread since it blocks and would create
        # a deadlock while the server waits for this request to be handled.
        if self._server:
            self._thread = threading.Thread(target=self._ShutdownServer)
            logging.debug('shutdown pending')
            self._thread.start()
        return True

    def Start(self, verbose, started_event=None, done_event=None):
        """Start the server.

    Args:
      verbose: True for verbose logging, False for errors only.
      started_event: An event to signal when we are ready to start.
          Used mainly for testing purposes. Defaults to None.
      done_event: An event to signal when we are done shutting down.
          Used mainly for testing purposes. Defaults to None.
    """
        if verbose:
            logging.getLogger().setLevel(logging.DEBUG)
        else:
            logging.getLogger().setLevel(logging.ERROR)

        logging.debug('Creating server')
        #TODO(user): Dynamically choose a port.
        self._server = SimpleXMLRPCServer(('', 7399),
                                          logRequests=verbose,
                                          requestHandler=RequestHandler)

        logging.debug('registering RemoteExecutor')
        self._server.register_instance(_RemoteExecutor())

        logging.debug('registering introspection functions')
        self._server.register_introspection_functions()

        logging.debug('registering Shutdown function')
        self._server.register_function(self.Shutdown)

        if started_event:
            started_event.set()

        # Run the server's main loop
        logging.debug('Serving until Shutdown is called.')
        self._server.serve_forever()
        logging.debug('shutdown complete')

        if self._thread.isAlive():
            logging.debug('joining shutdown thread')
            self._thread.join()
            logging.debug('joined shutdown thread')
        self._thread = None

        if done_event:
            logging.debug('signaling done event')
            done_event.set()
#!/usr/bin/env python
# encoding: utf-8
#
# Copyright (c) 2008 Doug Hellmann All rights reserved.
#
"""
"""

__version__ = "$Id: SimpleXMLRPCServer_alternate_name.py 1882 2009-01-04 15:38:33Z dhellmann $"
#end_pymotw_header

from SimpleXMLRPCServer import SimpleXMLRPCServer
import os

server = SimpleXMLRPCServer(('localhost', 9000))


# Expose a function with an alternate name
def list_contents(dir_name):
    return os.listdir(dir_name)


server.register_function(list_contents, 'dir')

try:
    print 'Use Control-C to exit'
    server.serve_forever()
except KeyboardInterrupt:
    print 'Exiting'
Example #52
0
 def __init__(self, addr, *args, **kwargs):
     if not args and not 'requestHandler' in kwargs:
         kwargs['requestHandler'] = TLSXMLRPCRequestHandler
     SimpleXMLRPCServer.__init__(self, addr, *args, **kwargs)
Example #53
0
class StorageNode(object):
    """
    A storage node. 
    """
    GET = 'GET'
    PUT = 'PUT'

    def __init__(self, servers, port):
        """
        Parameters:
            servers : list(str)
                A list of servers.  Each server name is in the 
                format {host/ip}:port
            port : int
                Port number to start on
        """
        self.port = int(port)
        self.server = None
        if servers is None:
            servers = []

        # Add myself to the servers list
        self.my_name = str(self)
        servers.append(self.my_name)
        self.datastore_view = DataStoreView(servers)

        # Load the persistence layer
        self._load_persistence_layer()

    def __del__(self):
        """
        Destructor
        """
        if self.persis:
            self.persis.close()
        if self.server:
            self.server.server_close()

    def __str__(self):
        """
        Builds a string representation of the storage node
        
        :rtype: str
        :returns: A string representation of the storage node 
        """
        if getattr(self, 'port'):
            return '%s:%s' % (socket.gethostbyname(
                socket.gethostname()), self.port)
        else:
            return '%s' % socket.gethostbyname(socket.gethostname())

    # ------------------------------------------------------
    # Public methods
    # ------------------------------------------------------
    def run(self):
        """
        Main storage node loop
        """
        self.server = SimpleXMLRPCServer(('', self.port), allow_none=True)
        self.server.register_function(self.get, "get")
        self.server.register_function(self.put, "put")
        self.server.serve_forever()

    # ------------------------------------------------------
    # RPC methods
    # ------------------------------------------------------
    def get(self, key):
        """
        Gets a key
        
        :Parameters:
            key : str
                The key value
        """
        logging.debug('Getting key=%s' % key)
        # Make sure I am supposed to have this key
        respon_node = self.datastore_view.get_node(key)
        if respon_node != self.my_name:
            logging.info("I'm not responsible for %s (%s vs %s)" %
                         (key, respon_node, self.my_name))
            return None

        # Read it from the database
        result = self.persis.get_key(key)

        # If the contexts don't line up then return the most recent
        value = None
        if len(result) == 1:
            value = result[0][1]
        else:
            value = self._reconcile_conflict(result)[0]

        logging.debug('Returning value=%s' % value)
        return value

    def put(self, key, value, context=None):
        """
        Puts a key value in the datastore
        
        :Parameters:
            key : str
                The key name
            value : str
                The value
            context : str
                Should be only be None for now.  In the future an application will be
                able to add a custom context string
                
        :rtype: str
        :returns 200 if the operation succeeded, 400 otherwise
        """
        # Make sure I am supposed to have this key
        if self.datastore_view.get_node(key) != self.my_name:
            logging.info("I'm not responsible for %s" % key)
            return None

        res_code = None
        try:
            # Read it from the database
            result = self.persis.put_key(key, value)
            res_code = '200'
        except:
            logging.error(
                'Error putting key=%s value=%s into the persistence layer' %
                (key, value))
            res_code = '400'

        return res_code

    # ------------------------------------------------------
    # Private methods
    # ------------------------------------------------------
    def _reconcile_conflict(self, result):
        """
        Reconciles the conflict between a number of values.  Note
        that currently this defaults to taking the last written value.
        In the future this will be expanded to allow application specific
        conflict resolution
        
        :Parameters:
            result : list(tuples)
                A list of result tuples from the persistence layer in the form
                [(id, "value", "date"), ...]
        :rtype: tuple(int, str)
        :returns An id, string tuple of the chosen version
        """
        last_result = None
        last_date = None
        for res in result:
            if last_result is None:
                last_result = res[1]
                last_date = self._parse_date(res[2])
            else:
                date = self._parse_date(res[2])
                if date > last_date:
                    last_date = date
                    last_result = res[1]

        return (last_result, last_date)

    def _load_persistence_layer(self):
        """
        Loads the persistence layer
        """
        # Setup my persistence layer
        self.persis = SqlitePersistenceLayer(self.my_name)
        self.persis.init_persistence()

    def _parse_date(self, datestr):
        """
        Parses an iso formatted date
        
        :Parameters:
            datestr : str
                An iso formatted date
        :rtype: datetime
        :returns A date object
        """
        date_str, micros = datestr.split('.')
        date = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
        date += timedelta(microseconds=float(micros))

        return date
 def __init__(self, host, port):
     SimpleXMLRPCServer.__init__(self, (host, port),
                                 logRequests=False,
                                 bind_and_activate=False)
     self._activated = False
     self._stopper_thread = None
Example #55
0
class backend(iot.device):
    #The class defining backend devices, which manage persistent database storage
    #Uses two separate database files, one for current device states, and another for the full history of past and present states
    #Uses python's native shelve module to read and write the database files
    #
    #Note that shelve files are not human readable
    #The following example illustrates how to manually retrieve a value from key 'bulb' in the state database
    #
    #>>> import shelve
    #>>> d = shelve.open('state_db')
    #>>> value = d['bulb']
    #>>> d.close()
    #>>> return value

    def __init__(self):
        iot.device.__init__(self)
        self.name = 'backend'
        self.category = 'backend'
        '''
		#Initialize and start daemon thread for serving as the clock synchronization leader
		leader_thread=Thread(target=self.lead, name='Bulb Leader Thread')
		leader_thread.daemon = True
		leader_thread.start()
		'''

        #Set up logging and create the database files
        self.setup()

        #Find an open request file from a gateway and contact it to register
        self.register()

        #Initialize and start daemon thread for checking to see if the gateway is still up
        gateway_heartbeat = Thread(target=self.gateway_heartbeat,
                                   name='Gateway Heartbeat Thread')
        gateway_heartbeat.daemon = True
        gateway_heartbeat.start()

        #Start listening for requests
        self.serve()

    def serve(self):
        self.server = SimpleXMLRPCServer((self.ip, self.port),
                                         logRequests=False,
                                         allow_none=True)
        self.server.register_function(self.ping)
        self.server.register_function(self.serve)
        self.server.register_function(self.register)
        self.server.register_function(self.timestamp)
        #self.server.register_function(self.start_election)
        #self.server.register_function(self.lead)
        #self.server.register_function(self.get_time)
        #self.server.register_function(self.set_time)
        self.server.register_function(self.get_attr)
        self.server.register_function(self.set_attr)
        self.server.register_function(self.db_get_state)
        self.server.register_function(self.db_get_history)
        #self.server.register_function(self.set_leader)
        self.server.register_function(self.device_by_name)
        self.server.register_function(self.devices_by_name)
        self.server.register_function(self.update_device_list)

        self.server.register_function(self.db_put)
        self.server.register_function(self.db_get_state)
        self.server.register_function(self.db_get_history)

        self.clock += 1
        try:
            print '\nStarting Server'
            print 'Use Control-C to exit'
            logging.info(
                str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
                'Starting Server')
            self.server.serve_forever()
        except KeyboardInterrupt:
            logging.info(
                str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
                'Received keyboard interrupt, stopping server')
            print 'Exiting'

    def setup(self):
        #Set up logging and initialize database files
        t = time.localtime()
        iot.setup_log(self.name, time.localtime())
        logging.info('Initializing')
        timestamp = (str(t[0]) + '_' + str(t[1]) + '-' + str(t[2]) + '_' +
                     str(t[3]) + '-' + str(t[4]) + '-' + str(t[5]))
        self.history_file = ('db/' + str(timestamp) + '_history')
        h = shelve.open(self.history_file)
        h.close()
        self.state_file = ('db/' + str(timestamp) + '_state')
        s = shelve.open(self.state_file)
        s.close()

    def register(self):
        registered = False
        while not registered:
            requests = os.listdir('db_requests/')
            valid_requests = []
            for i in requests:
                if not i.startswith('req_'):
                    logging.debug(
                        str(self.clock) + ' | ' + str(self.timestamp()) +
                        ': ' + 'Ignoring improperly named request file: ' +
                        str(i))
                else:
                    valid_requests.append(i)
            if (len(valid_requests) == 0):
                #If there are no open gateway requests, wait five seconds and check again
                time.sleep(5)
                continue
            request = min(valid_requests)
            print('Attempting to answer request: ' + str(request))
            filename = ('db_requests/' + str(request))
            f = open(filename, 'r')
            address = f.readlines()
            ip = address[0].strip()
            port = int(address[1].strip())
            print('Found request address of: ' +
                  str(iot.compose_address(ip, port)))
            gateway = {'ip': ip, 'port': port}

            try:
                logging.debug(
                    str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
                    'Attempting to register with gateway at: ' +
                    str(iot.compose_address(ip, port)))
                g = iot.build_receiver(gateway)
                self.ip = socket.gethostbyname(socket.gethostname())
                self.clock += 1
                c, id, port, devices = g.register_db(self.clock, self.name,
                                                     self.ip)
                self.update_clock(c)
                if ((id == False) or (port == False)):
                    continue
                else:
                    print('Registered with gateway. Received:\n\tID: ' +
                          str(id) + '\n\tPort: ' + str(port))
                    logging.info(
                        str(self.clock) + ' | ' + str(self.timestamp()) +
                        ': ' + 'Registered with gateway. Using port number: ' +
                        str(port))
                    self.id = id
                    self.port = port
                    self.devices = devices
                    self.gateway_ip = gateway['ip']
                    print self.gateway_ip
                    self.gateway_port = gateway['port']
                    print self.gateway_port
                    registered = True
                    print registered
                    break
            except:
                logging.warning(
                    str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
                    'Failed to register with the gateway, trying another request'
                )
                time.sleep(5)
                continue

    def gateway_heartbeat(self):
        while 1:
            if ((self.gateway_ip == False) or (self.gateway_port == False)):
                print('gateway_ip: ' + str(self.gateway_ip))
                print('gateway_port: ' + str(self.gateway_port))
                print 'Reregistering!'
                self.register()
            else:
                g = {'ip': self.gateway_ip, 'port': self.gateway_port}
                g = iot.build_receiver(g)
                try:
                    c = g.ping(self.clock)
                    self.update_clock(c)
                    logging.debug(
                        str(self.clock) + ' | ' + str(self.timestamp()) +
                        ': ' +
                        'Gateway still alive, checking again in 5 seconds')
                    time.sleep(5)
                except:
                    logging.debug(
                        str(self.clock) + ' | ' + str(self.timestamp()) +
                        ': ' +
                        'Gateway unreachable, checking for a new registration request'
                    )

                    self.gateway_ip = False
                    self.gateway_port = False
                    continue

    def db_put(self, c, k, v):
        #Store something in the persistent databases

        self.update_clock(c)

        #Store a 3-tuple of (key, value, timestamp) in the history file with the current logical clock value as the key
        h = shelve.open(self.history_file)
        key = self.clock
        h[str(key)] = (k, v, self.timestamp())
        logging.debug(
            str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
            'Put history item at key ' + str(key))
        h.close()
        self.clock += 1

        #Store a 3-tuple of (value, logical_clock_value, timestamp) in the state file under the given key
        s = shelve.open(self.state_file)
        s[str(k)] = (v, self.clock, self.timestamp())
        logging.debug(
            str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
            'Put state item at key ' + str(k))
        s.close()
        self.clock += 1

        return self.clock

    def db_get_history(self, c, k):
        #Retrieve an entry from the persistent history database
        #Returns the value as a 3-tuple of (key, value, timestamp) where the key is the name of the deivce related to the state value

        self.update_clock(c)
        f = shelve.open(self.history_file)
        v = f[str(k)]
        f.close()
        self.clock += 1
        logging.debug(
            str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
            'Returning history item at key ' + str(k))
        return (self.clock, v)

    def db_get_state(self, c, k):
        #Retrieve an entry from the persistent state database
        #Returns the value as a 3-tuple of (key, value, timestamp) where the key is the name of the deivce related to the state value

        self.update_clock(c)
        f = shelve.open(self.state_file)
        v = f[str(k)]
        f.close()
        self.clock += 1
        logging.debug(
            str(self.clock) + ' | ' + str(self.timestamp()) + ': ' +
            'Returning state item at key ' + str(k))
        return (self.clock, v)
Example #56
0
 def __init__(self, port, interpreter):
     SimpleXMLRPCServer.__init__(self, ('localhost', port), allow_none=True)
     self.register_instance(self.methods(interpreter))
     self.register_introspection_functions()
Example #57
0
                archive_name = os.path.join(archive_root, name)

                try:
                    zip_file.write(path, archive_name)
                except IOError as e:
                    continue
        
        zip_file.close()
        data = xmlrpclib.Binary(zip_data.getvalue())
        zip_data.close()

        return data

if __name__ == "__main__":
    try:
        if not BIND_IP:
            BIND_IP = socket.gethostbyname(socket.gethostname())

        print("[+] Starting agent on %s:%s ..." % (BIND_IP, BIND_PORT))

        # Disable DNS lookup, by Scott D.
        def FakeGetFQDN(name=""):
            return name
        socket.getfqdn = FakeGetFQDN

        server = SimpleXMLRPCServer((BIND_IP, BIND_PORT), allow_none=True)
        server.register_instance(Agent())
        server.serve_forever()
    except KeyboardInterrupt:
        server.shutdown()
Example #58
0
class ServerThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.disparador = SimpleXMLRPCServer((ip, porta))
        self.disparador.register_function(sucesso,
                                          "sucesso")  #just return a string
        self.disparador.register_function(setInfo, "setInfo")
        self.disparador.register_function(encerrarServidor, "quit")
        self.disparador.register_function(outroServidor, "statusEspelho")
        self.disparador.register_function(postar, "postar")
        self.disparador.register_function(apresentar, "apresentar")
        self.disparador.register_function(seguir, "seguir")
        self.disparador.register_function(parardeSeguir, "parardeSeguir")
        self.disparador.register_function(mostrarPost, "mostrarPost")
        self.disparador.register_function(mostrarPostTop, "mostrarPostTop")
        print("Disparador criado na porta", porta)

    def run(self):
        self.disparador.serve_forever()
Example #59
0
 def run(self):
     se = SimpleXMLRPCServer((shared.config.get('bitmessagesettings', 'apiinterface'), shared.config.getint(
         'bitmessagesettings', 'apiport')), MySimpleXMLRPCRequestHandler, True, True)
     se.register_introspection_functions()
     se.serve_forever()
Example #60
0
class Server:
    quit = False

    def __init__(self):
        self.server = SimpleXMLRPCServer(("0.0.0.0", 8002),
                                         requestHandler=RequestHandler,
                                         logRequests=False)
        self.server.register_introspection_functions()
        self.server.register_function(self.shutdown)
        self.server.register_instance(BenchTurnFunctions.BenchTurnFunctions())
        self.server.register_function(self.test)
        print("started main server")
        while not self.quit:
            self.server.handle_request()
        self.server.stop_all()

    def test(self):
        print("test")
        return True

    def shutdown(self):
        print "exiting ..."
        self.quit = True
        return 0