网络实战(二)：应用层 Part X：RPC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import operator, math
from xmlrpc.server import SimpleXMLRPCServer
from functools import reduce

def main():
    server = SimpleXMLRPCServer(('127.0.0.1',7001))  #create ROC Server
    server.register_introspection_functions()        #enable introspection
    server.register_multicall_functions()            #enable mutlcall
    server.register_function(addtogether)            #register 3 functions
    server.register_function(quadratic)
    server.register_function(remote_repr)
    print("Server ready")
    server.serve_forever()                           #server run forever


def addtogether(*things):
    '''Add together everying in the list `things`.'''
    return reduce(operator.add,things)

def quadratic(a,b,c):
    '''Determing `x` values satisfying `a` *x*x + `b`*x + c == 0 '''
    b24ac = math.sqrt(b*b-4.0*a*c)
    return list(set([(-b-b24ac)/2.0*a, (-b+b24ac)/2.0*a]))  #RPC function can only return 1 argument or list

def remote_repr(arg):
    '''Return the `repr()` rendering of the supplied `arg`.'''
    return  arg

if __name__ == '__main__':
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import  xmlrpc.client

def main():
    proxy = xmlrpc.client.ServerProxy('http://127.0.0.1:7001')

    print('Here are the functions supported by this server:')
    for method_name in proxy.system.listMethods():

        if method_name.startswith('system.'):
            continue

        signatures = proxy.system.methodSignature(method_name)
        if isinstance(signatures,list) and signatures:
            for signature in signatures:
                print('%s(%s)' % (method_name,signature))

        else:
            print('%s(...)' % (method_name,))

        method_help = proxy.system.methodHelp(method_name)
        if method_help:
            print(' ',method_help)

if __name__ == '__main__':
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import  xmlrpc.client

def main():
    proxy = xmlrpc.client.ServerProxy('http://127.0.0.1:7001')
    print(proxy.addtogether('x','y','z'))
    print(proxy.addtogether(20,30,4,1))
    print(proxy.quadratic(2,-4,0))
    print(proxy.quadratic(1,2,1))
    print(proxy.remote_repr((1,2.0,'three')))
    print(proxy.remote_repr([1,2.0,'three']))
    print(proxy.remote_repr({'name': 'Arthur',
                             'data':{'age':42,'sex':'M'}}))
    print(proxy.quadratic(1,0,1))

if __name__ == '__main__':
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import  xmlrpc.client

def main():
    proxy = xmlrpc.client.ServerProxy('http://127.0.0.1:7001')
    multicall = xmlrpc.client.MultiCall(proxy)
    multicall.addtogether('x','y','z')
    multicall.addtogether(20,30,4,1)
    multicall.quadratic(2,-4,0)
    multicall.remote_repr({'name': 'Arthur',
                             'data':{'age':42,'sex':'M'}})

    for answer in multicall():
        print(answer)

if __name__ == '__main__':
    main()

1
localhost - - [04/Oct/2010 00:16:19] "POST /RPC2 HTTP/1.0" 200 -

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# the first call to quadratic() that the sample client program makes:
<?xml version='1.0'?>
<methodCall>
<methodName>quadratic</methodName>
  338
<params>
<param>
<value><int>2</int></value>
</param>
<param>
<value><int>-4</int></value>
</param>
<param>
<value><int>0</int></value>
</param>
</params>
</methodCall>


#The response to the preceding call looks like this:
<?xml version='1.0'?>
<methodResponse>
<params>
<param>
<value><array><data>
<value><double>0.0</double></value>
<value><double>8.0</double></value>
</data></array></value>
</param>
</params>
</methodResponse>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer

def main():
    server = SimpleJSONRPCServer(('127.0.0.1',7001))    #create JSON Server
    server.register_introspection_functions()           #enable introspection
    server.register_function(lengths)
    print('server in running......')
    server.serve_forever()                              #run forever


def lengths(*args):
    '''Measure the length of each argument'''
    results = []

    for arg in args:
        try:
            arglen = len(arg)
        except TypeError:
            arglen = None
        results.append((arg,arglen))
    return results


if __name__ == '__main__':
    main()

1
2
3
4
5
6
7
8
from jsonrpclib import Server

def main():
    proxy = Server('http://127.0.0.1:7001')
    print(proxy.lengths(*['hi',27,'itsgoodday']))

if __name__ == '__main__':
    main()

1
2
3
4
5
{"version": "1.1",
 "params": [[1, 2, 3], 27, {"Rigel": 0.12, "Sirius": -1.46}],
 "method": "lengths"}
{"result": [[3, [1, 2, 3]], [null, 27],
            [2, {"Rigel": 0.12, "Sirius": -1.46}]]}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import rpyc

def main():
    from rpyc.utils.server import ThreadedServer
    t = ThreadedServer(MyService, port = 18861)
    t.start()

class MyService(rpyc.Service):
    def exposed_line_counter(self, fileobj, function):      # let client call the exposed_method
        print('Client has invoked exposed_line_counter()')  # pass the filobj ID back to client to call the function.
        for linenum, line in enumerate(fileobj.readlines()):
            function(line)
        return linenum+1

if __name__ == '__main__':
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import rpyc

def main():

    config = {'allow_public_attrs': True}
    proxy = rpyc.connect('localhost',18861,config=config)
    fileobj = open('testfile.txt')
    linecount = proxy.root.line_counter(fileobj,noisy)
    print('The number of lines in the file was', linecount)

def noisy(string):
    print('Noisy:',repr(string))

if __name__ == '__main__':
    main()