diff options
Diffstat (limited to 'python-jsonrpclib-pelix.spec')
| -rw-r--r-- | python-jsonrpclib-pelix.spec | 1539 |
1 files changed, 1539 insertions, 0 deletions
diff --git a/python-jsonrpclib-pelix.spec b/python-jsonrpclib-pelix.spec new file mode 100644 index 0000000..7aaa360 --- /dev/null +++ b/python-jsonrpclib-pelix.spec @@ -0,0 +1,1539 @@ +%global _empty_manifest_terminate_build 0 +Name: python-jsonrpclib-pelix +Version: 0.4.3.2 +Release: 1 +Summary: This project is an implementation of the JSON-RPC v2.0 specification (backwards-compatible) as a client library, for Python 2.7 and Python 3. This version is a fork of jsonrpclib by Josh Marshall, made to be also usable with Pelix/iPOPO remote services. +License: Apache License 2.0 +URL: http://github.com/tcalmant/jsonrpclib/ +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/f5/10/839b1d2cbd6157e4b09d4499c849b48127cd1d761e1d5bfeb1522c8be50d/jsonrpclib-pelix-0.4.3.2.tar.gz +BuildArch: noarch + + +%description +# JSONRPClib (patched for Pelix and Python 3) + +[](https://pypi.python.org/pypi/jsonrpclib-pelix/) +[](https://pypi.python.org/pypi/jsonrpclib-pelix/) +[](https://travis-ci.org/tcalmant/jsonrpclib) +[](https://coveralls.io/r/tcalmant/jsonrpclib?branch=master) + +This library is an implementation of the JSON-RPC specification. +It supports both the original 1.0 specification, as well as the new +(proposed) 2.0 specification, which includes batch submission, keyword +arguments, etc. + +This library is licensed under the terms of the +[Apache Software License 2.0](<http://www.apache.org/licenses/LICENSE-2.0.html>). + + +## About this version + +This is a patched version of the original `jsonrpclib` project by Josh Marshall, +available at +[joshmarshall/jsonrpclib](<https://github.com/joshmarshall/jsonrpclib>). + +The suffix *-pelix* only indicates that this version works with Pelix +Remote Services, but it is **not** a Pelix specific implementation. + +* This version adds support for Python 3, staying compatible with Python 2.7. + The support for Python 2.6 has been dropped, as it was becoming to hard to + maintain. +* It is now possible to use the `dispatch_method` argument while extending the + `SimpleJSONRPCDispatcher`, to use a custom dispatcher. + This allows to use this package by Pelix Remote Services. +* It can use thread pools to control the number of threads spawned to handle + notification requests and clients connections. +* The modifications added in other forks of this project have been added: + * From [drdaeman/jsonrpclib](<https://github.com/drdaeman/jsonrpclib>): + * Improved JSON-RPC 1.0 support + * Less strict error response handling + * From [tuomassalo/jsonrpclib](<https://github.com/tuomassalo/jsonrpclib>): + * In case of a non-predefined error, raise an AppError and give access + to *error.data* + * From [dejw/jsonrpclib](<https://github.com/dejw/jsonrpclib>): + * Custom headers can be sent with request and associated tests +* Since version 0.4, this package added back the support of Unix sockets. +* This package cannot be installed with the original `jsonrpclib`, as it uses + the same name. + +## Summary + +This library implements the JSON-RPC 2.0 proposed specification in pure Python. +It is designed to be as compatible with the syntax of `xmlrpclib` as possible +(it extends where possible), so that projects using `xmlrpclib` could easily be +modified to use JSON and experiment with the differences. + +It is backwards-compatible with the 1.0 specification, and supports all of the +new proposed features of 2.0, including: + +- Batch submission (via the `MultiCall` class) +- Keyword arguments +- Notifications (both in a batch and 'normal') +- Class translation using the `__jsonclass__` key. + +A `SimpleJSONRPCServer` class has been added. It is intended to emulate the +`SimpleXMLRPCServer` from the default Python distribution. + +## Requirements + +This library supports `ujson`, `cjson` and `simplejson`, and looks for the +parsers in that order (searching first for `ujson`, `cjson`, `simplejson` +and finally for the *built-in* `json`). +One of these must be installed to use this library, although if you have a +standard distribution of 2.7+, you should already have one. +Keep in mind that `ujson` is supposed to be the quickest, I believe, so if you +are going for full-on optimization you may want to pick it up. + +## Installation + +You can install this from PyPI with one of the following commands (`sudo` +might be required): + +``` +# Global installation +pip install jsonrpclib-pelix + +# Local installation +pip install --user jsonrpclib-pelix +``` + +Alternatively, you can download the source from the GitHub repository at +[tcalmant/jsonrpclib](http://github.com/tcalmant/jsonrpclib) and manually +install it with the following commands: + +``` +git clone git://github.com/tcalmant/jsonrpclib.git +cd jsonrpclib +python setup.py install +``` + +## A note on logging + +`jsonrpclib-pelix` uses the `logging` module from the standard Python +library to trace warnings and errors, but doesn't set it up. +As a result, you have to configure the Python logging to print out traces. + +The easiest way to do it is to add those lines at the beginning of your code: +```python +import logging +logging.basiConfig() +``` + +More information can be found in the +[`logging` documentation page](https://docs.python.org/3/library/logging.html). + +## `SimpleJSONRPCServer` + +This is identical in usage (or should be) to the `SimpleXMLRPCServer` in the +Python standard library. +Some of the differences in features are that it obviously supports notification, +batch calls, class translation (if left on), etc. + +**Note:** The import line is slightly different from the regular +`SimpleXMLRPCServer`, since the `SimpleJSONRPCServer` is provided by th +`jsonrpclib` library. + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer + +server = SimpleJSONRPCServer(('localhost', 8080)) +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') +server.serve_forever() +``` + +To start protect the server with SSL, use the following snippet: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +import ssl + +# Setup the SSL socket +server = SimpleJSONRPCServer(('localhost', 8080), bind_and_activate=False) +server.socket = ssl.wrap_socket(server.socket, certfile='server.pem', + server_side=True) +server.server_bind() +server.server_activate() + +# ... register functions +# Start the server +server.serve_forever() +``` + +### Notification Thread Pool + +By default, notification calls are handled in the request handling thread. +It is possible to use a thread pool to handle them, by giving it to the server +using the `set_notification_pool()` method: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +from jsonrpclib.threadpool import ThreadPool + +# Setup the thread pool: between 0 and 10 threads +pool = ThreadPool(max_threads=10, min_threads=0) + +# Don't forget to start it +pool.start() + +# Setup the server +server = SimpleJSONRPCServer(('localhost', 8080)) +server.set_notification_pool(pool) + +# Register methods +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') + +try: + server.serve_forever() +finally: + # Stop the thread pool (let threads finish their current task) + pool.stop() + server.set_notification_pool(None) +``` + +### Threaded server + +It is also possible to use a thread pool to handle clients requests, using the +`PooledJSONRPCServer` class. +By default, this class uses pool of 0 to 30 threads. +A custom pool can be given with the `thread_pool` parameter of the class +constructor. + +The notification pool and the request pool are different: by default, a server +with a request pool doesn't have a notification pool. + +```python +from jsonrpclib.SimpleJSONRPCServer import PooledJSONRPCServer +from jsonrpclib.threadpool import ThreadPool + +# Setup the notification and request pools +nofif_pool = ThreadPool(max_threads=10, min_threads=0) +request_pool = ThreadPool(max_threads=50, min_threads=10) + +# Don't forget to start them +nofif_pool.start() +request_pool.start() + +# Setup the server +server = PooledJSONRPCServer(('localhost', 8080), thread_pool=request_pool) +server.set_notification_pool(nofif_pool) + +# Register methods +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') + +try: + server.serve_forever() +finally: + # Stop the thread pools (let threads finish their current task) + request_pool.stop() + nofif_pool.stop() + server.set_notification_pool(None) +``` + +### Unix socket + +To start a server listening on a Unix socket, you will have to use the +following snippet: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +import os +import socket + +# Set the path to the socket file +socket_name = "/tmp/my_socket.socket" + +# Ensure that the file doesn't exist yet (or an error will be raised) +if os.path.exists(socket_name): + os.remove(socket_name) + +try: + # Start the server, indicating the socket family + # The server will force some flags when in Unix socket mode + # (no log request, no reuse address, ...) + srv = SimpleJSONRPCServer(socket_name, address_family=socket.AF_UNIX) + + # ... register methods to the server + # Run the server + srv.serve_forever() +except KeyboardInterrupt: + # Shutdown the server gracefully + srv.shutdown() + srv.server_close() +finally: + # You should clean up after the server stopped + os.remove(socket_name) +``` + +This feature is tested on Linux during Travis-CI builds. It also has +been tested on Windows Subsystem for Linux (WSL) on Windows 10 1809. + +This feature is not available on "pure" Windows, as it doesn't provide +the `AF_UNIX` address family. + +## Client Usage + +This is (obviously) taken from a console session. + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.ServerProxy('http://localhost:8080') +>>> server.add(5,6) +11 +>>> server.add(x=5, y=10) +15 +>>> server._notify.add(5,6) +# No result returned... +>>> batch = jsonrpclib.MultiCall(server) +>>> batch.add(5, 6) +>>> batch.ping({'key':'value'}) +>>> batch._notify.add(4, 30) +>>> results = batch() +>>> for result in results: +>>> ... print(result) +11 +{'key': 'value'} +# Note that there are only two responses -- this is according to spec. + +# Clean up +>>> server('close')() + +# Using client history +>>> history = jsonrpclib.history.History() +>>> server = jsonrpclib.ServerProxy('http://localhost:8080', history=history) +>>> server.add(5,6) +11 +>>> print(history.request) +{"id": "f682b956-c8e1-4506-9db4-29fe8bc9fcaa", "jsonrpc": "2.0", + "method": "add", "params": [5, 6]} +>>> print(history.response) +{"id": "f682b956-c8e1-4506-9db4-29fe8bc9fcaa", "jsonrpc": "2.0", + "result": 11} + +# Clean up +>>> server('close')() +``` + +If you need 1.0 functionality, there are a bunch of places you can pass +that in, although the best is just to give a specific configuration to +`jsonrpclib.ServerProxy`: + +```python +>>> import jsonrpclib +>>> jsonrpclib.config.DEFAULT.version +2.0 +>>> config = jsonrpclib.config.Config(version=1.0) +>>> history = jsonrpclib.history.History() +>>> server = jsonrpclib.ServerProxy('http://localhost:8080', config=config, + history=history) +>>> server.add(7, 10) +17 +>>> print(history.request) +{"id": "827b2923-5b37-49a5-8b36-e73920a16d32", + "method": "add", "params": [7, 10]} +>>> print(history.response) +{"id": "827b2923-5b37-49a5-8b36-e73920a16d32", "error": null, "result": 17} +>>> server('close')() +``` + +The equivalent `loads` and `dumps` functions also exist, although with +minor modifications. +The `dumps` arguments are almost identical, but it adds three arguments: +`rpcid` for the `id` key, `version` to specify the JSON-RPC compatibility, +and `notify` if it's a request that you want to be a notification. + +Additionally, the `loads` method does not return the params and method like +`xmlrpclib`, but instead +a.) parses for errors, raising ProtocolErrors, and +b.) returns the entire structure of the request / response for manual parsing. + +### Unix sockets + +To connect a JSON-RPC server over a Unix socket, you have to use a specific +protocol: `unix+http`. + +When connecting to a Unix socket in the current working directory, you can use +the following syntax: `unix+http://my.socket` + +When you need to give an absolute path you must use the path part of the URL, +the host part will be ignored. For example, you can use this URL to indicate a +Unix socket in `/var/lib/daemon.socket`: `unix+http://./var/lib/daemon.socket` + +**Note:** Currently, only HTTP is supported over a Unix socket. +If you want HTTPS support to be implemented, please create an +[issue on GitHub](https://github.com/tcalmant/jsonrpclib/issues) + +### Additional headers + +If your remote service requires custom headers in request, you can pass them +using the `headers` keyword argument, when creating the `ServerProxy`: + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.ServerProxy("http://localhost:8080", + headers={'X-Test' : 'Test'}) +``` + +You can also put additional request headers only for certain method +invocation: + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.Server("http://localhost:8080") +>>> with server._additional_headers({'X-Test' : 'Test'}) as test_server: +... test_server.ping(42) +... +>>> # X-Test header will be no longer sent in requests +``` + +Of course `_additional_headers` contexts can be nested as well. + +## Class Translation + +The library supports an *"automatic"* class translation process, although it +is turned off by default. +This can be devastatingly slow if improperly used, so the following is just a +short list of things to keep in mind when using it. + +- Keep It (the object) Simple Stupid. (for exceptions, keep reading) +- Do not require init params (for exceptions, keep reading) +- Getter properties without setters could be dangerous (read: not tested) + +If any of the above are issues, use the `_serialize` method (see usage below). +The server and client must **BOTH** have the `use_jsonclass` configuration +item on and they must both have access to the same libraries used by the +objects for this to work. + +If you have excessively nested arguments, it would be better to turn off the +translation and manually invoke it on specific objects using +`jsonrpclib.jsonclass.dump` / `jsonrpclib.jsonclass.load` (since the +default behavior recursively goes through attributes and lists/dicts/tuples). + +* Sample file: `test_obj.py` + +```python +# This object is /very/ simple, and the system will look through the +# attributes and serialize what it can. +class TestObj(object): + foo = 'bar' + +# This object requires __init__ params, so it uses the _serialize method +# and returns a tuple of init params and attribute values (the init params +# can be a dict or a list, but the attribute values must be a dict.) +class TestSerial(object): + foo = 'bar' + def __init__(self, *args): + self.args = args + def _serialize(self): + return (self.args, {'foo':self.foo,}) +``` + +- Sample usage: + +```python +>>> import jsonrpclib +>>> import test_obj + +# History is used only to print the serialized form of beans +>>> history = jsonrpclib.history.History() +>>> testobj1 = test_obj.TestObj() +>>> testobj2 = test_obj.TestSerial() +>>> server = jsonrpclib.Server('http://localhost:8080', history=history) + +# The 'ping' just returns whatever is sent +>>> ping1 = server.ping(testobj1) +>>> ping2 = server.ping(testobj2) + +>>> print(history.request) +{"id": "7805f1f9-9abd-49c6-81dc-dbd47229fe13", "jsonrpc": "2.0", + "method": "ping", "params": [{"__jsonclass__": + ["test_obj.TestSerial", []], "foo": "bar"} + ]} +>>> print(history.response) +{"id": "7805f1f9-9abd-49c6-81dc-dbd47229fe13", "jsonrpc": "2.0", + "result": {"__jsonclass__": ["test_obj.TestSerial", []], "foo": "bar"}} +``` + +This behavior is turned on by default. +To deactivate it, just set the `use_jsonclass` member of a server `Config` to +`False`. +If you want to use a per-class serialization method, set its name in the +`serialize_method` member of a server `Config`. +Finally, if you are using classes that you have defined in the implementation +(as in, not a separate library), you'll need to add those +(on **BOTH** the server and the client) using the `config.classes.add()` method. + +Feedback on this "feature" is very, VERY much appreciated. + +## Tests + +Tests are an almost-verbatim drop from the JSON-RPC specification 2.0 +page. They can be run using *unittest* or *nosetest*: + +``` +python -m unittest discover tests +python3 -m unittest discover tests +nosetests tests +``` + +## Why JSON-RPC? + +In my opinion, there are several reasons to choose JSON over XML for RPC: + +* Much simpler to read (I suppose this is opinion, but I know I'm right. :) +* Size / Bandwidth - Main reason, a JSON object representation is just much + smaller. +* Parsing - JSON should be much quicker to parse than XML. +* Easy class passing with `jsonclass` (when enabled) + +In the interest of being fair, there are also a few reasons to choose XML over +JSON: + +* Your server doesn't do JSON (rather obvious) +* Wider XML-RPC support across APIs (can we change this? :)) +* Libraries are more established, *i.e.* more stable (Let's change this too) + + + + +%package -n python3-jsonrpclib-pelix +Summary: This project is an implementation of the JSON-RPC v2.0 specification (backwards-compatible) as a client library, for Python 2.7 and Python 3. This version is a fork of jsonrpclib by Josh Marshall, made to be also usable with Pelix/iPOPO remote services. +Provides: python-jsonrpclib-pelix +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-jsonrpclib-pelix +# JSONRPClib (patched for Pelix and Python 3) + +[](https://pypi.python.org/pypi/jsonrpclib-pelix/) +[](https://pypi.python.org/pypi/jsonrpclib-pelix/) +[](https://travis-ci.org/tcalmant/jsonrpclib) +[](https://coveralls.io/r/tcalmant/jsonrpclib?branch=master) + +This library is an implementation of the JSON-RPC specification. +It supports both the original 1.0 specification, as well as the new +(proposed) 2.0 specification, which includes batch submission, keyword +arguments, etc. + +This library is licensed under the terms of the +[Apache Software License 2.0](<http://www.apache.org/licenses/LICENSE-2.0.html>). + + +## About this version + +This is a patched version of the original `jsonrpclib` project by Josh Marshall, +available at +[joshmarshall/jsonrpclib](<https://github.com/joshmarshall/jsonrpclib>). + +The suffix *-pelix* only indicates that this version works with Pelix +Remote Services, but it is **not** a Pelix specific implementation. + +* This version adds support for Python 3, staying compatible with Python 2.7. + The support for Python 2.6 has been dropped, as it was becoming to hard to + maintain. +* It is now possible to use the `dispatch_method` argument while extending the + `SimpleJSONRPCDispatcher`, to use a custom dispatcher. + This allows to use this package by Pelix Remote Services. +* It can use thread pools to control the number of threads spawned to handle + notification requests and clients connections. +* The modifications added in other forks of this project have been added: + * From [drdaeman/jsonrpclib](<https://github.com/drdaeman/jsonrpclib>): + * Improved JSON-RPC 1.0 support + * Less strict error response handling + * From [tuomassalo/jsonrpclib](<https://github.com/tuomassalo/jsonrpclib>): + * In case of a non-predefined error, raise an AppError and give access + to *error.data* + * From [dejw/jsonrpclib](<https://github.com/dejw/jsonrpclib>): + * Custom headers can be sent with request and associated tests +* Since version 0.4, this package added back the support of Unix sockets. +* This package cannot be installed with the original `jsonrpclib`, as it uses + the same name. + +## Summary + +This library implements the JSON-RPC 2.0 proposed specification in pure Python. +It is designed to be as compatible with the syntax of `xmlrpclib` as possible +(it extends where possible), so that projects using `xmlrpclib` could easily be +modified to use JSON and experiment with the differences. + +It is backwards-compatible with the 1.0 specification, and supports all of the +new proposed features of 2.0, including: + +- Batch submission (via the `MultiCall` class) +- Keyword arguments +- Notifications (both in a batch and 'normal') +- Class translation using the `__jsonclass__` key. + +A `SimpleJSONRPCServer` class has been added. It is intended to emulate the +`SimpleXMLRPCServer` from the default Python distribution. + +## Requirements + +This library supports `ujson`, `cjson` and `simplejson`, and looks for the +parsers in that order (searching first for `ujson`, `cjson`, `simplejson` +and finally for the *built-in* `json`). +One of these must be installed to use this library, although if you have a +standard distribution of 2.7+, you should already have one. +Keep in mind that `ujson` is supposed to be the quickest, I believe, so if you +are going for full-on optimization you may want to pick it up. + +## Installation + +You can install this from PyPI with one of the following commands (`sudo` +might be required): + +``` +# Global installation +pip install jsonrpclib-pelix + +# Local installation +pip install --user jsonrpclib-pelix +``` + +Alternatively, you can download the source from the GitHub repository at +[tcalmant/jsonrpclib](http://github.com/tcalmant/jsonrpclib) and manually +install it with the following commands: + +``` +git clone git://github.com/tcalmant/jsonrpclib.git +cd jsonrpclib +python setup.py install +``` + +## A note on logging + +`jsonrpclib-pelix` uses the `logging` module from the standard Python +library to trace warnings and errors, but doesn't set it up. +As a result, you have to configure the Python logging to print out traces. + +The easiest way to do it is to add those lines at the beginning of your code: +```python +import logging +logging.basiConfig() +``` + +More information can be found in the +[`logging` documentation page](https://docs.python.org/3/library/logging.html). + +## `SimpleJSONRPCServer` + +This is identical in usage (or should be) to the `SimpleXMLRPCServer` in the +Python standard library. +Some of the differences in features are that it obviously supports notification, +batch calls, class translation (if left on), etc. + +**Note:** The import line is slightly different from the regular +`SimpleXMLRPCServer`, since the `SimpleJSONRPCServer` is provided by th +`jsonrpclib` library. + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer + +server = SimpleJSONRPCServer(('localhost', 8080)) +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') +server.serve_forever() +``` + +To start protect the server with SSL, use the following snippet: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +import ssl + +# Setup the SSL socket +server = SimpleJSONRPCServer(('localhost', 8080), bind_and_activate=False) +server.socket = ssl.wrap_socket(server.socket, certfile='server.pem', + server_side=True) +server.server_bind() +server.server_activate() + +# ... register functions +# Start the server +server.serve_forever() +``` + +### Notification Thread Pool + +By default, notification calls are handled in the request handling thread. +It is possible to use a thread pool to handle them, by giving it to the server +using the `set_notification_pool()` method: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +from jsonrpclib.threadpool import ThreadPool + +# Setup the thread pool: between 0 and 10 threads +pool = ThreadPool(max_threads=10, min_threads=0) + +# Don't forget to start it +pool.start() + +# Setup the server +server = SimpleJSONRPCServer(('localhost', 8080)) +server.set_notification_pool(pool) + +# Register methods +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') + +try: + server.serve_forever() +finally: + # Stop the thread pool (let threads finish their current task) + pool.stop() + server.set_notification_pool(None) +``` + +### Threaded server + +It is also possible to use a thread pool to handle clients requests, using the +`PooledJSONRPCServer` class. +By default, this class uses pool of 0 to 30 threads. +A custom pool can be given with the `thread_pool` parameter of the class +constructor. + +The notification pool and the request pool are different: by default, a server +with a request pool doesn't have a notification pool. + +```python +from jsonrpclib.SimpleJSONRPCServer import PooledJSONRPCServer +from jsonrpclib.threadpool import ThreadPool + +# Setup the notification and request pools +nofif_pool = ThreadPool(max_threads=10, min_threads=0) +request_pool = ThreadPool(max_threads=50, min_threads=10) + +# Don't forget to start them +nofif_pool.start() +request_pool.start() + +# Setup the server +server = PooledJSONRPCServer(('localhost', 8080), thread_pool=request_pool) +server.set_notification_pool(nofif_pool) + +# Register methods +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') + +try: + server.serve_forever() +finally: + # Stop the thread pools (let threads finish their current task) + request_pool.stop() + nofif_pool.stop() + server.set_notification_pool(None) +``` + +### Unix socket + +To start a server listening on a Unix socket, you will have to use the +following snippet: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +import os +import socket + +# Set the path to the socket file +socket_name = "/tmp/my_socket.socket" + +# Ensure that the file doesn't exist yet (or an error will be raised) +if os.path.exists(socket_name): + os.remove(socket_name) + +try: + # Start the server, indicating the socket family + # The server will force some flags when in Unix socket mode + # (no log request, no reuse address, ...) + srv = SimpleJSONRPCServer(socket_name, address_family=socket.AF_UNIX) + + # ... register methods to the server + # Run the server + srv.serve_forever() +except KeyboardInterrupt: + # Shutdown the server gracefully + srv.shutdown() + srv.server_close() +finally: + # You should clean up after the server stopped + os.remove(socket_name) +``` + +This feature is tested on Linux during Travis-CI builds. It also has +been tested on Windows Subsystem for Linux (WSL) on Windows 10 1809. + +This feature is not available on "pure" Windows, as it doesn't provide +the `AF_UNIX` address family. + +## Client Usage + +This is (obviously) taken from a console session. + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.ServerProxy('http://localhost:8080') +>>> server.add(5,6) +11 +>>> server.add(x=5, y=10) +15 +>>> server._notify.add(5,6) +# No result returned... +>>> batch = jsonrpclib.MultiCall(server) +>>> batch.add(5, 6) +>>> batch.ping({'key':'value'}) +>>> batch._notify.add(4, 30) +>>> results = batch() +>>> for result in results: +>>> ... print(result) +11 +{'key': 'value'} +# Note that there are only two responses -- this is according to spec. + +# Clean up +>>> server('close')() + +# Using client history +>>> history = jsonrpclib.history.History() +>>> server = jsonrpclib.ServerProxy('http://localhost:8080', history=history) +>>> server.add(5,6) +11 +>>> print(history.request) +{"id": "f682b956-c8e1-4506-9db4-29fe8bc9fcaa", "jsonrpc": "2.0", + "method": "add", "params": [5, 6]} +>>> print(history.response) +{"id": "f682b956-c8e1-4506-9db4-29fe8bc9fcaa", "jsonrpc": "2.0", + "result": 11} + +# Clean up +>>> server('close')() +``` + +If you need 1.0 functionality, there are a bunch of places you can pass +that in, although the best is just to give a specific configuration to +`jsonrpclib.ServerProxy`: + +```python +>>> import jsonrpclib +>>> jsonrpclib.config.DEFAULT.version +2.0 +>>> config = jsonrpclib.config.Config(version=1.0) +>>> history = jsonrpclib.history.History() +>>> server = jsonrpclib.ServerProxy('http://localhost:8080', config=config, + history=history) +>>> server.add(7, 10) +17 +>>> print(history.request) +{"id": "827b2923-5b37-49a5-8b36-e73920a16d32", + "method": "add", "params": [7, 10]} +>>> print(history.response) +{"id": "827b2923-5b37-49a5-8b36-e73920a16d32", "error": null, "result": 17} +>>> server('close')() +``` + +The equivalent `loads` and `dumps` functions also exist, although with +minor modifications. +The `dumps` arguments are almost identical, but it adds three arguments: +`rpcid` for the `id` key, `version` to specify the JSON-RPC compatibility, +and `notify` if it's a request that you want to be a notification. + +Additionally, the `loads` method does not return the params and method like +`xmlrpclib`, but instead +a.) parses for errors, raising ProtocolErrors, and +b.) returns the entire structure of the request / response for manual parsing. + +### Unix sockets + +To connect a JSON-RPC server over a Unix socket, you have to use a specific +protocol: `unix+http`. + +When connecting to a Unix socket in the current working directory, you can use +the following syntax: `unix+http://my.socket` + +When you need to give an absolute path you must use the path part of the URL, +the host part will be ignored. For example, you can use this URL to indicate a +Unix socket in `/var/lib/daemon.socket`: `unix+http://./var/lib/daemon.socket` + +**Note:** Currently, only HTTP is supported over a Unix socket. +If you want HTTPS support to be implemented, please create an +[issue on GitHub](https://github.com/tcalmant/jsonrpclib/issues) + +### Additional headers + +If your remote service requires custom headers in request, you can pass them +using the `headers` keyword argument, when creating the `ServerProxy`: + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.ServerProxy("http://localhost:8080", + headers={'X-Test' : 'Test'}) +``` + +You can also put additional request headers only for certain method +invocation: + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.Server("http://localhost:8080") +>>> with server._additional_headers({'X-Test' : 'Test'}) as test_server: +... test_server.ping(42) +... +>>> # X-Test header will be no longer sent in requests +``` + +Of course `_additional_headers` contexts can be nested as well. + +## Class Translation + +The library supports an *"automatic"* class translation process, although it +is turned off by default. +This can be devastatingly slow if improperly used, so the following is just a +short list of things to keep in mind when using it. + +- Keep It (the object) Simple Stupid. (for exceptions, keep reading) +- Do not require init params (for exceptions, keep reading) +- Getter properties without setters could be dangerous (read: not tested) + +If any of the above are issues, use the `_serialize` method (see usage below). +The server and client must **BOTH** have the `use_jsonclass` configuration +item on and they must both have access to the same libraries used by the +objects for this to work. + +If you have excessively nested arguments, it would be better to turn off the +translation and manually invoke it on specific objects using +`jsonrpclib.jsonclass.dump` / `jsonrpclib.jsonclass.load` (since the +default behavior recursively goes through attributes and lists/dicts/tuples). + +* Sample file: `test_obj.py` + +```python +# This object is /very/ simple, and the system will look through the +# attributes and serialize what it can. +class TestObj(object): + foo = 'bar' + +# This object requires __init__ params, so it uses the _serialize method +# and returns a tuple of init params and attribute values (the init params +# can be a dict or a list, but the attribute values must be a dict.) +class TestSerial(object): + foo = 'bar' + def __init__(self, *args): + self.args = args + def _serialize(self): + return (self.args, {'foo':self.foo,}) +``` + +- Sample usage: + +```python +>>> import jsonrpclib +>>> import test_obj + +# History is used only to print the serialized form of beans +>>> history = jsonrpclib.history.History() +>>> testobj1 = test_obj.TestObj() +>>> testobj2 = test_obj.TestSerial() +>>> server = jsonrpclib.Server('http://localhost:8080', history=history) + +# The 'ping' just returns whatever is sent +>>> ping1 = server.ping(testobj1) +>>> ping2 = server.ping(testobj2) + +>>> print(history.request) +{"id": "7805f1f9-9abd-49c6-81dc-dbd47229fe13", "jsonrpc": "2.0", + "method": "ping", "params": [{"__jsonclass__": + ["test_obj.TestSerial", []], "foo": "bar"} + ]} +>>> print(history.response) +{"id": "7805f1f9-9abd-49c6-81dc-dbd47229fe13", "jsonrpc": "2.0", + "result": {"__jsonclass__": ["test_obj.TestSerial", []], "foo": "bar"}} +``` + +This behavior is turned on by default. +To deactivate it, just set the `use_jsonclass` member of a server `Config` to +`False`. +If you want to use a per-class serialization method, set its name in the +`serialize_method` member of a server `Config`. +Finally, if you are using classes that you have defined in the implementation +(as in, not a separate library), you'll need to add those +(on **BOTH** the server and the client) using the `config.classes.add()` method. + +Feedback on this "feature" is very, VERY much appreciated. + +## Tests + +Tests are an almost-verbatim drop from the JSON-RPC specification 2.0 +page. They can be run using *unittest* or *nosetest*: + +``` +python -m unittest discover tests +python3 -m unittest discover tests +nosetests tests +``` + +## Why JSON-RPC? + +In my opinion, there are several reasons to choose JSON over XML for RPC: + +* Much simpler to read (I suppose this is opinion, but I know I'm right. :) +* Size / Bandwidth - Main reason, a JSON object representation is just much + smaller. +* Parsing - JSON should be much quicker to parse than XML. +* Easy class passing with `jsonclass` (when enabled) + +In the interest of being fair, there are also a few reasons to choose XML over +JSON: + +* Your server doesn't do JSON (rather obvious) +* Wider XML-RPC support across APIs (can we change this? :)) +* Libraries are more established, *i.e.* more stable (Let's change this too) + + + + +%package help +Summary: Development documents and examples for jsonrpclib-pelix +Provides: python3-jsonrpclib-pelix-doc +%description help +# JSONRPClib (patched for Pelix and Python 3) + +[](https://pypi.python.org/pypi/jsonrpclib-pelix/) +[](https://pypi.python.org/pypi/jsonrpclib-pelix/) +[](https://travis-ci.org/tcalmant/jsonrpclib) +[](https://coveralls.io/r/tcalmant/jsonrpclib?branch=master) + +This library is an implementation of the JSON-RPC specification. +It supports both the original 1.0 specification, as well as the new +(proposed) 2.0 specification, which includes batch submission, keyword +arguments, etc. + +This library is licensed under the terms of the +[Apache Software License 2.0](<http://www.apache.org/licenses/LICENSE-2.0.html>). + + +## About this version + +This is a patched version of the original `jsonrpclib` project by Josh Marshall, +available at +[joshmarshall/jsonrpclib](<https://github.com/joshmarshall/jsonrpclib>). + +The suffix *-pelix* only indicates that this version works with Pelix +Remote Services, but it is **not** a Pelix specific implementation. + +* This version adds support for Python 3, staying compatible with Python 2.7. + The support for Python 2.6 has been dropped, as it was becoming to hard to + maintain. +* It is now possible to use the `dispatch_method` argument while extending the + `SimpleJSONRPCDispatcher`, to use a custom dispatcher. + This allows to use this package by Pelix Remote Services. +* It can use thread pools to control the number of threads spawned to handle + notification requests and clients connections. +* The modifications added in other forks of this project have been added: + * From [drdaeman/jsonrpclib](<https://github.com/drdaeman/jsonrpclib>): + * Improved JSON-RPC 1.0 support + * Less strict error response handling + * From [tuomassalo/jsonrpclib](<https://github.com/tuomassalo/jsonrpclib>): + * In case of a non-predefined error, raise an AppError and give access + to *error.data* + * From [dejw/jsonrpclib](<https://github.com/dejw/jsonrpclib>): + * Custom headers can be sent with request and associated tests +* Since version 0.4, this package added back the support of Unix sockets. +* This package cannot be installed with the original `jsonrpclib`, as it uses + the same name. + +## Summary + +This library implements the JSON-RPC 2.0 proposed specification in pure Python. +It is designed to be as compatible with the syntax of `xmlrpclib` as possible +(it extends where possible), so that projects using `xmlrpclib` could easily be +modified to use JSON and experiment with the differences. + +It is backwards-compatible with the 1.0 specification, and supports all of the +new proposed features of 2.0, including: + +- Batch submission (via the `MultiCall` class) +- Keyword arguments +- Notifications (both in a batch and 'normal') +- Class translation using the `__jsonclass__` key. + +A `SimpleJSONRPCServer` class has been added. It is intended to emulate the +`SimpleXMLRPCServer` from the default Python distribution. + +## Requirements + +This library supports `ujson`, `cjson` and `simplejson`, and looks for the +parsers in that order (searching first for `ujson`, `cjson`, `simplejson` +and finally for the *built-in* `json`). +One of these must be installed to use this library, although if you have a +standard distribution of 2.7+, you should already have one. +Keep in mind that `ujson` is supposed to be the quickest, I believe, so if you +are going for full-on optimization you may want to pick it up. + +## Installation + +You can install this from PyPI with one of the following commands (`sudo` +might be required): + +``` +# Global installation +pip install jsonrpclib-pelix + +# Local installation +pip install --user jsonrpclib-pelix +``` + +Alternatively, you can download the source from the GitHub repository at +[tcalmant/jsonrpclib](http://github.com/tcalmant/jsonrpclib) and manually +install it with the following commands: + +``` +git clone git://github.com/tcalmant/jsonrpclib.git +cd jsonrpclib +python setup.py install +``` + +## A note on logging + +`jsonrpclib-pelix` uses the `logging` module from the standard Python +library to trace warnings and errors, but doesn't set it up. +As a result, you have to configure the Python logging to print out traces. + +The easiest way to do it is to add those lines at the beginning of your code: +```python +import logging +logging.basiConfig() +``` + +More information can be found in the +[`logging` documentation page](https://docs.python.org/3/library/logging.html). + +## `SimpleJSONRPCServer` + +This is identical in usage (or should be) to the `SimpleXMLRPCServer` in the +Python standard library. +Some of the differences in features are that it obviously supports notification, +batch calls, class translation (if left on), etc. + +**Note:** The import line is slightly different from the regular +`SimpleXMLRPCServer`, since the `SimpleJSONRPCServer` is provided by th +`jsonrpclib` library. + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer + +server = SimpleJSONRPCServer(('localhost', 8080)) +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') +server.serve_forever() +``` + +To start protect the server with SSL, use the following snippet: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +import ssl + +# Setup the SSL socket +server = SimpleJSONRPCServer(('localhost', 8080), bind_and_activate=False) +server.socket = ssl.wrap_socket(server.socket, certfile='server.pem', + server_side=True) +server.server_bind() +server.server_activate() + +# ... register functions +# Start the server +server.serve_forever() +``` + +### Notification Thread Pool + +By default, notification calls are handled in the request handling thread. +It is possible to use a thread pool to handle them, by giving it to the server +using the `set_notification_pool()` method: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +from jsonrpclib.threadpool import ThreadPool + +# Setup the thread pool: between 0 and 10 threads +pool = ThreadPool(max_threads=10, min_threads=0) + +# Don't forget to start it +pool.start() + +# Setup the server +server = SimpleJSONRPCServer(('localhost', 8080)) +server.set_notification_pool(pool) + +# Register methods +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') + +try: + server.serve_forever() +finally: + # Stop the thread pool (let threads finish their current task) + pool.stop() + server.set_notification_pool(None) +``` + +### Threaded server + +It is also possible to use a thread pool to handle clients requests, using the +`PooledJSONRPCServer` class. +By default, this class uses pool of 0 to 30 threads. +A custom pool can be given with the `thread_pool` parameter of the class +constructor. + +The notification pool and the request pool are different: by default, a server +with a request pool doesn't have a notification pool. + +```python +from jsonrpclib.SimpleJSONRPCServer import PooledJSONRPCServer +from jsonrpclib.threadpool import ThreadPool + +# Setup the notification and request pools +nofif_pool = ThreadPool(max_threads=10, min_threads=0) +request_pool = ThreadPool(max_threads=50, min_threads=10) + +# Don't forget to start them +nofif_pool.start() +request_pool.start() + +# Setup the server +server = PooledJSONRPCServer(('localhost', 8080), thread_pool=request_pool) +server.set_notification_pool(nofif_pool) + +# Register methods +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.register_function(lambda x: x, 'ping') + +try: + server.serve_forever() +finally: + # Stop the thread pools (let threads finish their current task) + request_pool.stop() + nofif_pool.stop() + server.set_notification_pool(None) +``` + +### Unix socket + +To start a server listening on a Unix socket, you will have to use the +following snippet: + +```python +from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer +import os +import socket + +# Set the path to the socket file +socket_name = "/tmp/my_socket.socket" + +# Ensure that the file doesn't exist yet (or an error will be raised) +if os.path.exists(socket_name): + os.remove(socket_name) + +try: + # Start the server, indicating the socket family + # The server will force some flags when in Unix socket mode + # (no log request, no reuse address, ...) + srv = SimpleJSONRPCServer(socket_name, address_family=socket.AF_UNIX) + + # ... register methods to the server + # Run the server + srv.serve_forever() +except KeyboardInterrupt: + # Shutdown the server gracefully + srv.shutdown() + srv.server_close() +finally: + # You should clean up after the server stopped + os.remove(socket_name) +``` + +This feature is tested on Linux during Travis-CI builds. It also has +been tested on Windows Subsystem for Linux (WSL) on Windows 10 1809. + +This feature is not available on "pure" Windows, as it doesn't provide +the `AF_UNIX` address family. + +## Client Usage + +This is (obviously) taken from a console session. + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.ServerProxy('http://localhost:8080') +>>> server.add(5,6) +11 +>>> server.add(x=5, y=10) +15 +>>> server._notify.add(5,6) +# No result returned... +>>> batch = jsonrpclib.MultiCall(server) +>>> batch.add(5, 6) +>>> batch.ping({'key':'value'}) +>>> batch._notify.add(4, 30) +>>> results = batch() +>>> for result in results: +>>> ... print(result) +11 +{'key': 'value'} +# Note that there are only two responses -- this is according to spec. + +# Clean up +>>> server('close')() + +# Using client history +>>> history = jsonrpclib.history.History() +>>> server = jsonrpclib.ServerProxy('http://localhost:8080', history=history) +>>> server.add(5,6) +11 +>>> print(history.request) +{"id": "f682b956-c8e1-4506-9db4-29fe8bc9fcaa", "jsonrpc": "2.0", + "method": "add", "params": [5, 6]} +>>> print(history.response) +{"id": "f682b956-c8e1-4506-9db4-29fe8bc9fcaa", "jsonrpc": "2.0", + "result": 11} + +# Clean up +>>> server('close')() +``` + +If you need 1.0 functionality, there are a bunch of places you can pass +that in, although the best is just to give a specific configuration to +`jsonrpclib.ServerProxy`: + +```python +>>> import jsonrpclib +>>> jsonrpclib.config.DEFAULT.version +2.0 +>>> config = jsonrpclib.config.Config(version=1.0) +>>> history = jsonrpclib.history.History() +>>> server = jsonrpclib.ServerProxy('http://localhost:8080', config=config, + history=history) +>>> server.add(7, 10) +17 +>>> print(history.request) +{"id": "827b2923-5b37-49a5-8b36-e73920a16d32", + "method": "add", "params": [7, 10]} +>>> print(history.response) +{"id": "827b2923-5b37-49a5-8b36-e73920a16d32", "error": null, "result": 17} +>>> server('close')() +``` + +The equivalent `loads` and `dumps` functions also exist, although with +minor modifications. +The `dumps` arguments are almost identical, but it adds three arguments: +`rpcid` for the `id` key, `version` to specify the JSON-RPC compatibility, +and `notify` if it's a request that you want to be a notification. + +Additionally, the `loads` method does not return the params and method like +`xmlrpclib`, but instead +a.) parses for errors, raising ProtocolErrors, and +b.) returns the entire structure of the request / response for manual parsing. + +### Unix sockets + +To connect a JSON-RPC server over a Unix socket, you have to use a specific +protocol: `unix+http`. + +When connecting to a Unix socket in the current working directory, you can use +the following syntax: `unix+http://my.socket` + +When you need to give an absolute path you must use the path part of the URL, +the host part will be ignored. For example, you can use this URL to indicate a +Unix socket in `/var/lib/daemon.socket`: `unix+http://./var/lib/daemon.socket` + +**Note:** Currently, only HTTP is supported over a Unix socket. +If you want HTTPS support to be implemented, please create an +[issue on GitHub](https://github.com/tcalmant/jsonrpclib/issues) + +### Additional headers + +If your remote service requires custom headers in request, you can pass them +using the `headers` keyword argument, when creating the `ServerProxy`: + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.ServerProxy("http://localhost:8080", + headers={'X-Test' : 'Test'}) +``` + +You can also put additional request headers only for certain method +invocation: + +```python +>>> import jsonrpclib +>>> server = jsonrpclib.Server("http://localhost:8080") +>>> with server._additional_headers({'X-Test' : 'Test'}) as test_server: +... test_server.ping(42) +... +>>> # X-Test header will be no longer sent in requests +``` + +Of course `_additional_headers` contexts can be nested as well. + +## Class Translation + +The library supports an *"automatic"* class translation process, although it +is turned off by default. +This can be devastatingly slow if improperly used, so the following is just a +short list of things to keep in mind when using it. + +- Keep It (the object) Simple Stupid. (for exceptions, keep reading) +- Do not require init params (for exceptions, keep reading) +- Getter properties without setters could be dangerous (read: not tested) + +If any of the above are issues, use the `_serialize` method (see usage below). +The server and client must **BOTH** have the `use_jsonclass` configuration +item on and they must both have access to the same libraries used by the +objects for this to work. + +If you have excessively nested arguments, it would be better to turn off the +translation and manually invoke it on specific objects using +`jsonrpclib.jsonclass.dump` / `jsonrpclib.jsonclass.load` (since the +default behavior recursively goes through attributes and lists/dicts/tuples). + +* Sample file: `test_obj.py` + +```python +# This object is /very/ simple, and the system will look through the +# attributes and serialize what it can. +class TestObj(object): + foo = 'bar' + +# This object requires __init__ params, so it uses the _serialize method +# and returns a tuple of init params and attribute values (the init params +# can be a dict or a list, but the attribute values must be a dict.) +class TestSerial(object): + foo = 'bar' + def __init__(self, *args): + self.args = args + def _serialize(self): + return (self.args, {'foo':self.foo,}) +``` + +- Sample usage: + +```python +>>> import jsonrpclib +>>> import test_obj + +# History is used only to print the serialized form of beans +>>> history = jsonrpclib.history.History() +>>> testobj1 = test_obj.TestObj() +>>> testobj2 = test_obj.TestSerial() +>>> server = jsonrpclib.Server('http://localhost:8080', history=history) + +# The 'ping' just returns whatever is sent +>>> ping1 = server.ping(testobj1) +>>> ping2 = server.ping(testobj2) + +>>> print(history.request) +{"id": "7805f1f9-9abd-49c6-81dc-dbd47229fe13", "jsonrpc": "2.0", + "method": "ping", "params": [{"__jsonclass__": + ["test_obj.TestSerial", []], "foo": "bar"} + ]} +>>> print(history.response) +{"id": "7805f1f9-9abd-49c6-81dc-dbd47229fe13", "jsonrpc": "2.0", + "result": {"__jsonclass__": ["test_obj.TestSerial", []], "foo": "bar"}} +``` + +This behavior is turned on by default. +To deactivate it, just set the `use_jsonclass` member of a server `Config` to +`False`. +If you want to use a per-class serialization method, set its name in the +`serialize_method` member of a server `Config`. +Finally, if you are using classes that you have defined in the implementation +(as in, not a separate library), you'll need to add those +(on **BOTH** the server and the client) using the `config.classes.add()` method. + +Feedback on this "feature" is very, VERY much appreciated. + +## Tests + +Tests are an almost-verbatim drop from the JSON-RPC specification 2.0 +page. They can be run using *unittest* or *nosetest*: + +``` +python -m unittest discover tests +python3 -m unittest discover tests +nosetests tests +``` + +## Why JSON-RPC? + +In my opinion, there are several reasons to choose JSON over XML for RPC: + +* Much simpler to read (I suppose this is opinion, but I know I'm right. :) +* Size / Bandwidth - Main reason, a JSON object representation is just much + smaller. +* Parsing - JSON should be much quicker to parse than XML. +* Easy class passing with `jsonclass` (when enabled) + +In the interest of being fair, there are also a few reasons to choose XML over +JSON: + +* Your server doesn't do JSON (rather obvious) +* Wider XML-RPC support across APIs (can we change this? :)) +* Libraries are more established, *i.e.* more stable (Let's change this too) + + + + +%prep +%autosetup -n jsonrpclib-pelix-0.4.3.2 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-jsonrpclib-pelix -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Apr 11 2023 Python_Bot <Python_Bot@openeuler.org> - 0.4.3.2-1 +- Package Spec generated |