Python ServerProxy.query方法代码示例

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
    def _do_update(self, hwids):
        '''Query remote server for driver updates for a set of HardwareIDs.'''

        logging.debug('Querying XML-RPC driver database %s...', self.url)
        client = ServerProxy(self.url)
        # TODO: error handling; pass kernel_version, architecture
        (res_proto_ver, res_proto_subver, drivers) = client.query(
            '20080407', '0', { 
            'os_name': OSLib.inst.os_vendor,
            'os_version': OSLib.inst.os_version, 
            'system_vendor': self.sys_vendor,
            'system_product': self.sys_product,
            'components': ['%s:%s' % (h.type, h.id) for h in hwids]
            })
        logging.debug('  -> protocol: %s/%s, drivers: %s', res_proto_ver,
            res_proto_subver, str(drivers))

        self.cache = {}
        if res_proto_ver != '20080407':
            logging.warning('   unknown protocol version, not updating')
            return

        for hwid in hwids:
            for drv in drivers.get('%s:%s' % (hwid.type, hwid.id), []):
                if 'driver_type' not in drv:
                    continue
                self.cache.setdefault(hwid, []).append(DriverID(**drv))

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
    def _do_update(self, hwids):
        """Query remote server for driver updates for a set of HardwareIDs."""

        logging.debug("Querying XML-RPC driver database %s...", self.url)
        client = ServerProxy(self.url)
        # TODO: error handling; pass kernel_version, architecture
        (res_proto_ver, res_proto_subver, drivers) = client.query(
            "20080407",
            "0",
            {
                "os_name": OSLib.inst.os_vendor,
                "os_version": OSLib.inst.os_version,
                "system_vendor": self.sys_vendor,
                "system_product": self.sys_product,
                "components": ["%s:%s" % (h.type, h.id) for h in hwids],
            },
        )
        logging.debug("  -> protocol: %s/%s, drivers: %s", res_proto_ver, res_proto_subver, str(drivers))

        self.cache = {}
        if res_proto_ver != "20080407":
            logging.warning("   unknown protocol version, not updating")
            return

        for hwid in hwids:
            for drv in drivers.get("%s:%s" % (hwid.type, hwid.id), []):
                if "driver_type" not in drv:
                    continue
                self.cache.setdefault(hwid, []).append(DriverID(**drv))

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
 def _broadcast(self, query, history):
     for other in self.known.copy():
         if other in history: continue
         try:
             s = ServerProxy(other)
             #print(other)
             code, data = s.query(query, history)
             if code == OK:
                 return code, data
         except: self.known.remove(other)
     return FAIL, EMPTY

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
 def _broadcast(self, query, history):
     for other in self.known.copy():
         if other in history: continue
         try:
             s = ServerProxy(other)
             return s.query(query, history)
         except Fault as f:
             if f.faultCode == UNHADLED:pass
             else: self.known.remove(other)
         except:
             self.known.remove(other)
     raise UnhandledQuery

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
def start_driverdb_server(correct_protocol=True):
    '''Create XML-RPC driver db server.

    This will listen on localhost:8080 and serve fake_db. This must be
    terminated with stop_driverdb_server().

    If correct_protocol is False, this will answer with a bogus protocol
    version.
    '''

    start_driverdb_server.pid = os.fork()
    if start_driverdb_server.pid == 0:
        try:
            s = SimpleXMLRPCServer(('localhost', 8080), logRequests=False)
            s.register_introspection_functions()
            if correct_protocol:
                s.register_function(xmlrpc_driverdb_query, 'query')
            else:
                s.register_function(xmlrpc_driverdb_query_bogus, 'query')
            s.serve_forever()
        except:
            sys.stderr.write('********** DEMO XML-RPC server failed: ***********\n')
            traceback.print_exc()
            os._exit(1)

    # wait until it is ready
    c = ServerProxy('http://localhost:8080')
    timeout = 100
    while timeout > 0:
        time.sleep(0.1)
        try:
            c.query('0', '0', {})
        except socket.error:
            timeout -= 1
            continue
        break
    if timeout == 0:
        raise SystemError('XML-RPC demo server did not start')

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
 def _broadcast(self, query, history):
     """
     Used internally to broadcast a query to all known Nodes.
     """
     for other in self.known.copy():
         if other in history: continue
         try:
             s = ServerProxy(other)
             code, data = s.query(query, history)
             if code == OK:
                 return code, data
         except:
             self.known.remove(other)
     return FAIL, EMPTY

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
    def _broadcast(self, query, history):
        """
        Used internally to broadcast a query to all known Nodes.
        """
        for other in self.known.copy():
            if other in history: continue
            try:
                s = ServerProxy(other)
                return s.query(query, history)

            except Fault as f:
                if f.faultCode == UNHANDLED: pass
                else: self.known.remove(other)
            except:
                self.known.remove(other)
        raise UnhandledQuery

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import query [as 别名]
class TestXMLRPCDriverDBConsistency(unittest.TestCase):
    def setUp(self):
        start_driverdb_server()
        self.xmlrpc_client = ServerProxy('http://localhost:8080')

    def tearDown(self):
        stop_driverdb_server()

    def test_consistency(self):
        '''XML-RPC driver DB server answers are consistent with fake_db'''

        # TODO: kernel_ver, and architecture specific tests
        self.assertEqual(self.xmlrpc_client.query('20080407', '0', {
            'os_name': 'Foonux', 'os_version': '42', 'system_vendor': '',
            'system_product': '', 'components': [
                'modalias:pci:v00001001d00003D11sv01sd02bc03sc00i00',
                'modalias:dmi:123456']}),
            ['20080407', '0', {
                'modalias:pci:v00001001d00003D11sv01sd02bc03sc00i00': [
                    {'driver_type': 'kernel_module', 'jockey_handler':
                     'VanillaGfxHandler', 'description': {'C': 'desc'}}, 
                    {'driver_type': 'kernel_module', 'foobar':
                    'IHaveNoHandler', 'description': {'C': 'desc'}}],
                'modalias:dmi:123456': []}
            ]
        )

        self.assertEqual(self.xmlrpc_client.query('20080407', '0', {
            'os_name': 'RedSock', 'os_version': '2.0', 'system_vendor': '',
            'system_product': '', 'components': [
                'modalias:pci:v00001001d00003D11sv01sd02bc03sc00i00']}),
            ['20080407', '0', {
                'modalias:pci:v00001001d00003D11sv01sd02bc03sc00i00': [
                    {'driver_type': 'kernel_module', 'jockey_handler':
                     'Vanilla3DHandler', 'description': {'C': 'desc'},
                     'repository': 'http://nonfree.redsock.com/addons'}]
            }]
        )

        self.assertEqual(self.xmlrpc_client.query('20080407', '0', {
            'os_name': 'Foonux', 'os_version': '40', 'system_vendor': '',
            'system_product': '', 'components': [
                'modalias:pci:v00001001d00003D11sv01sd02bc03sc00i00',
                'modalias:othertype:foobar12']}),
            ['20080407', '0', {
                'modalias:pci:v00001001d00003D11sv01sd02bc03sc00i00': [],
                'modalias:othertype:foobar12': []}
            ]
        )

        self.assertEqual(self.xmlrpc_client.query('20080407', '0', {
            'os_name': 'Foonux', 'os_version': '42', 'system_vendor':
            'VaporTech Inc.', 'system_product': 'Virtualtop X-1', 
            'components': ['modalias:pci:v0000FFF0d00000001sv01sd01bc06sc01i00']}),
            ['20080407', '0', {
                'modalias:pci:v0000FFF0d00000001sv01sd01bc06sc01i00': [
                    {'driver_type': 'kernel_module', 'kernel_module':
                     'chocolate', 'description': {'C': 'VaporTech choc handler', 'de_DE':
                         'German description', 'cs': 'Czech description'},
                     'long_description': {'C': 'Multi\nline'},
                     'driver_vendor': 'VaporTech', 'package': 'spam-x1', 'repository':
                     'http://vaportech.com/x1', 'version': '1.1-foo42-vt3',
                     'fingerprint': '0000 FFFF 1111 EEEE 2222  DDDD 3333 CCCC 4444 BBBB'},
                    {'driver_type': 'kernel_module', 'jockey_handler':
                     'NoDetectMod', 'driver_vendor': 'White Hat',
                     'description': {'C': 'WhiteHat ndmod'}},
                    {'driver_type': 'kernel_module', 'jockey_handler':
                     'NoDetectMod', 'driver_vendor': 'Black Hat',
                     'description': {'C': 'BlackHat ndmod'}},
                    {'driver_type': 'kernel_module', 'kernel_module':
                     'mint', 'driver_vendor': 'UbuOne',
                     'description': {'C': 'UbuOne mintmod'}},
                    {'driver_type': 'kernel_module', 'kernel_module':
                     'mint', 'driver_vendor': 'UbunTwo',
                     'description': {'C': 'UbunTwo mintmod'},
                     'recommended': True},
                    {'driver_type': 'kernel_module', 'kernel_module':
                     'apple', 'driver_vendor': 'Apple', 'description':
                     {'C': 'Unknown local kmod'}, 'free': False, 
                     'license': 'Kills kittens', 'package': 'pretzel'},
                ]}
            ]
        )

    def test_invalid_query(self):
        '''XML-RPC driver DB server/client survive incomplete queries'''

        self.assertEqual(self.xmlrpc_client.query('20080407', '0', {}), 
            ['20080407', '0', {}])
        self.assertEqual(self.xmlrpc_client.query('20080407', '0', {
            'components': ['modalias:pci:foo']}),
            ['20080407', '0', {}])
        self.assertEqual(self.xmlrpc_client.query('20080407', '0', {
            'os_name': 'Foonux', 'components': ['modalias:pci:foo']}),
            ['20080407', '0', {}])

    def test_introspection(self):
        '''XML-RPC driver DB server supports expected methods'''

        self.assert_('query' in self.xmlrpc_client.system.listMethods())