From c27fd70b5e4c3efe5ad034069108414d36f9bd9e Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Fri, 19 Feb 2021 20:30:41 +0100 Subject: some improvments + license change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- .gitignore | 14 +- LICENSE | 31 +-- Makefile | 159 ++---------- README | 1 - bus.py | 376 ++++++++++++++++++++++++++++ config.mk | 10 + dist/arch/stable/.gitignore | 6 - dist/arch/stable/PKGBUILD | 26 -- native_bus.pyx | 556 ++++++++++++++++++++++++++++++++++++++++++ src/bus.py | 399 ------------------------------ src/native_bus.pyx | 579 -------------------------------------------- 11 files changed, 977 insertions(+), 1180 deletions(-) create mode 100644 bus.py create mode 100644 config.mk delete mode 100644 dist/arch/stable/.gitignore delete mode 100644 dist/arch/stable/PKGBUILD create mode 100644 native_bus.pyx delete mode 100644 src/bus.py delete mode 100644 src/native_bus.pyx diff --git a/.gitignore b/.gitignore index 6cef52e..848c3ea 100644 --- a/.gitignore +++ b/.gitignore @@ -1,19 +1,9 @@ -_/ -obj/ -bin/ -__pycache__/ -\#*\# -.* -!.git* *~ -*.bak -*.swo -*.swp +*\#* +__pycache__/ *.pyc *.pyo *.o *.out *.so -*.gch *.c - diff --git a/LICENSE b/LICENSE index b253b5b..53d4a24 100644 --- a/LICENSE +++ b/LICENSE @@ -1,22 +1,15 @@ -MIT/X Consortium License +ISC License -Copyright © 2015 Mattias Andrée +© 2015, 2017 Mattias Andrée -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the "Software"), -to deal in the Software without restriction, including without limitation -the rights to use, copy, modify, merge, publish, distribute, sublicense, -and/or sell copies of the Software, and to permit persons to whom the -Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/Makefile b/Makefile index bba43f4..46e2a6e 100644 --- a/Makefile +++ b/Makefile @@ -1,152 +1,35 @@ -# The package path prefix, if you want to install to another root, set DESTDIR to that root -PREFIX = /usr -# The library path excluding prefix -LIB = /lib -# The resource path excluding prefix -DATA = /share -# The library path including prefix -LIBDIR = ${PREFIX}${LIB} -# The resource path including prefix -DATADIR = ${PREFIX}${DATA} -# The generic documentation path including prefix -DOCDIR = ${DATADIR}/doc -# The license base path including prefix -LICENSEDIR = ${DATADIR}/licenses +.POSIX: +CONFIGFILE = config.mk +include $(CONFIGFILE) -# The major version number of the current Python installation -PY_MAJOR = $(shell python -V | cut -d ' ' -f 2 | cut -d . -f 1) -# The minor version number of the current Python installation -PY_MINOR = $(shell python -V | cut -d ' ' -f 2 | cut -d . -f 2) -# The version number of the current Python installation without a dot -PY_VER = ${PY_MAJOR}${PY_MINOR} -# The version number of the current Python installation with a dot -PY_VERSION = ${PY_MAJOR}.${PY_MINOR} +PY_MAJOR = $$(python --version 2>&1 | cut -d . -f 1 | cut -d ' ' -f 2) +PY_MINOR = $$(python$(PYTHON_MAJOR) --version 2>&1 | cut -d . -f 2) -# The directory for python modules -PYTHONDIR = ${LIBDIR}/python${PY_VERSION} +all: native_bus.so +native_bus.so: native_bus.o + $(CC) -o $@ native_bus.o -shared $(LDFLAGS) -# The name of the package as it should be installed -PKGNAME = python-bus - - -# The installed pkg-config command -PKGCONFIG ?= pkg-config -# The installed cython command -CYTHON ?= cython -# The installed python command -PYTHON = python${PY_MAJOR} - - -# Libraries to link with using pkg-config -LIBS = python${PY_MAJOR} - - -# The C standard for C code compilation -STD = c99 -# Optimisation settings for C code compilation -OPTIMISE = -O2 - - -# Flags to use when compiling -CC_FLAGS = $$(${PKGCONFIG} --cflags ${LIBS}) -std=${STD} ${OPTIMISE} -fPIC ${CFLAGS} ${CPPFLAGS} - -# Flags to use when linking -LD_FLAGS = $$(${PKGCONFIG} --libs ${LIBS}) -lbus -std=${STD} ${OPTIMISE} -shared ${LDFLAGS} - - -# The suffixless basename of the .py-files -PYTHON_SRC = bus - -# The suffixless basename of the .py-files -CYTHON_SRC = native_bus - - -# Filename extension for -OO optimised python files -ifeq ($(shell test $(PY_VER) -ge 35 ; echo $$?),0) -PY_OPT2_EXT = opt-2.pyc -else -PY_OPT2_EXT = pyo -endif - - - -all: pyc-files pyo-files so-files - -pyc-files: $(foreach M,${PYTHON_SRC},src/__pycache__/${M}.cpython-${PY_VER}.pyc) -pyo-files: $(foreach M,${PYTHON_SRC},src/__pycache__/${M}.cpython-${PY_VER}.$(PY_OPT2_EXT)) -so-files: $(foreach M,${CYTHON_SRC},bin/${M}.so) - -bin/%.so: obj/%.o - @mkdir -p bin - ${CC} ${LD_FLAGS} -o $@ $^ - -obj/%.o: obj/%.c - ${CC} ${CC_FLAGS} -iquote"src" -c -o $@ $< - -obj/%.c: obj/%.pyx - if ! ${CYTHON} -3 -v $< ; then rm $@ ; false ; fi - -obj/%.pyx: src/%.pyx - @mkdir -p obj - cp $< $@ - -src/__pycache__/%.cpython-$(PY_VER).pyc: src/%.py - ${PYTHON} -m compileall $< - -src/__pycache__/%.cpython-$(PY_VER).$(PY_OPT2_EXT): src/%.py - ${PYTHON} -OO -m compileall $< - - - -install: install-base - -install-all: install-base -install-base: install-lib install-copyright -install-lib: install-source install-compiled install-optimised install-native - -install-source: $(foreach M,$(PYTHON_SRC),src/$(M).py) - install -dm755 -- "$(DESTDIR)$(PYTHONDIR)" - install -m644 $^ -- "$(DESTDIR)$(PYTHONDIR)" - -install-compiled: $(foreach M,$(PYTHON_SRC),src/__pycache__/$(M).cpython-$(PY_VER).pyc) - install -dm755 -- "$(DESTDIR)$(PYTHONDIR)/__pycache__" - install -m644 $^ -- "$(DESTDIR)$(PYTHONDIR)/__pycache__" - -install-optimised: $(foreach M,$(PYTHON_SRC),src/__pycache__/$(M).cpython-$(PY_VER).$(PY_OPT2_EXT)) - install -dm755 -- "$(DESTDIR)$(PYTHONDIR)/__pycache__" - install -m644 $^ -- "$(DESTDIR)$(PYTHONDIR)/__pycache__" - -install-native: $(foreach M,$(CYTHON_SRC),bin/$(M).so) - install -dm755 -- "$(DESTDIR)$(PYTHONDIR)" - install -m755 $^ -- "$(DESTDIR)$(PYTHONDIR)" - -install-copyright: install-license - -install-license: LICENSE - install -dm755 -- "$(DESTDIR)$(LICENSEDIR)/$(PKGNAME)" - install -m644 $^ -- "$(DESTDIR)$(LICENSEDIR)/$(PKGNAME)" +.c.o: + $(CC) -fPIC -c -o $@ $< $$(pkg-config --cflags python$(PY_MAJOR)) $(CFLAGS) $(CPPFLAGS) +.pyx.c: + if ! $(CYTHON) -$(PY_MAJOR) -v $< -o $@ ; then rm $@; false; fi +install: native_bus.so + mkdir -p -- "$(DESTDIR)$(PYTHONDIR)/site-packages" + cp -- bus.py native_bus.so "$(DESTDIR)$(PYTHONDIR)/site-packages" uninstall: - -rm -- "${DESTDIR}${LICENSEDIR}/${PKGNAME}/LICENSE" - -rmdir -- "${DESTDIR}${LICENSEDIR}/${PKGNAME}" - -rm -- $(foreach M,${PYTHON_SRC},"${DESTDIR}${PYTHONDIR}/__pycache__/${M}.cpython-${PY_VER}.$(PY_OPT2_EXT)") - -rm -- $(foreach M,${PYTHON_SRC},"${DESTDIR}${PYTHONDIR}/__pycache__/${M}.cpython-${PY_VER}.pyc") - -rm -- $(foreach M,${PYTHON_SRC},"${DESTDIR}${PYTHONDIR}/${M}.py") - -rm -- $(foreach M,${CYTHON_SRC},"${DESTDIR}${PYTHONDIR}/${M}.so") - - + -rm -f -- "$(DESTDIR)$(PYTHONDIR)/site-packages/native_bus.so" + -rm -f -- "$(DESTDIR)$(PYTHONDIR)/site-packages/bus" clean: - -rm -r obj bin src/__pycache__ - - + -rm -rf -- __pycache__ *.pyc *.pyo *.o *.so -.PHONY: all pyc-files pyo-files so-files install install-all install-base \ - install-lib install-source install-compiled install-optimised \ - install-native install-copyright install-license uninstall clean +.SUFFIXES: +.SUFFIXES: .o .c .pyx +.PHONY: all install uninstall clean diff --git a/README b/README index a096068..cacc411 100644 --- a/README +++ b/README @@ -9,4 +9,3 @@ SEE ALSO libbus(7) Full documentation available locally via the command help i python(1). - diff --git a/bus.py b/bus.py new file mode 100644 index 0000000..7025dd8 --- /dev/null +++ b/bus.py @@ -0,0 +1,376 @@ +# -*- python -*- +# See LICENSE file for copyright and license details. + + +class Bus: + ''' + Message broadcasting interprocess communication + ''' + + + RDONLY = 1 + ''' + Open the bus for reading only + ''' + + WRONLY = 0 + ''' + Open the bus for writing only + ''' + + RDWR = 0 + ''' + Open the bus for both reading and writing only + ''' + + EXCL = 2 + ''' + Fail to create bus if its file already exists + ''' + + INTR = 4 + ''' + Fail if interrupted + ''' + + NOWAIT = 1 + ''' + Function shall fail with `os.errno.EAGAIN` + if the it would block and this flag is used + ''' + + + def __init__(self, pathname : str = None): + ''' + Constructor + + @param pathname:str The pathname of the bus, `None` if `create` should select a random pathname + ''' + self.pathname = pathname + self.bus = None + + + def __del__(self): + ''' + Destructor + ''' + self.close() + + + def create(self, flags : int = 0) -> str: + ''' + Create the bus + + @param flags:or_flag `Bus.EXCL` (if the pathname is not `None`) to fail if the file + already exists, otherwise if the file exists, nothing will happen; + `Bus.INTR` to fail if interrupted + @return :str The pathname of the bus + ''' + from native_bus import bus_create_wrapped + (self.pathname, e) = bus_create_wrapped(self.pathname, flags) + if self.pathname is None: + raise self.__oserror(e) + return self.pathname + + + def unlink(self): + ''' + Remove the bus + ''' + from native_bus import bus_unlink_wrapped + (r, e) = bus_unlink_wrapped(self.pathname) + if r == -1: + raise self.__oserror(e) + + + def open(self, flags : int = 0): + ''' + Open an existing bus + + @param flags:int `Bus.RDONLY`, `Bus.WRONLY` or `Bus.RDWR`, the value must not be negative + ''' + from native_bus import bus_close_wrapped, bus_allocate, bus_open_wrapped + if self.bus is not None: + (r, e) = bus_close_wrapped(self.bus) + if r == -1: + raise self.__oserror(e) + else: + (self.bus, e) = bus_allocate() + if self.bus == 0: + raise self.__oserror(e) + (r, e) = bus_open_wrapped(self.bus, self.pathname, flags) + if r == -1: + raise self.__oserror(e) + + + def close(self): + ''' + Close the bus + ''' + try: + from native_bus import bus_close_wrapped, bus_deallocate + except: + return + if self.bus is not None: + (r, e) = bus_close_wrapped(self.bus) + if r == -1: + raise self.__oserror(e) + bus_deallocate(self.bus) + self.bus = None + + + def write(self, message : str, flags : int = 0): + ''' + Broadcast a message a bus + + @param message:str The message to write, may not be longer than 2047 bytes + after UTF-8 encoding + @param flags:int `Bus.NOWAIT` if the function shall fail with `os.errno.EAGAIN` + if there is another process attempting to broadcast on the bus + ''' + from native_bus import bus_write_wrapped + (r, e) = bus_write_wrapped(self.bus, message, flags) + if r == -1: + raise self.__oserror(e) + + + def write_timed(self, message : str, timeout : float, clock_id : int = None): + ''' + Broadcast a message a bus + + @param message:str The message to write, may not be longer than 2047 bytes + after UTF-8 encoding + @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, + if it has not already completed + @param clock_id:int? The clock `timeout` is measured in, it must be a + predictable clock, if `None`, `timeout` is measured in + relative time instead of absolute time + ''' + from native_bus import bus_write_timed_wrapped + if clock_id is None: + import time + clock_id = time.CLOCK_MONOTONIC_RAW + timeout += time.clock_gettime(clock_id) + (r, e) = bus_write_timed_wrapped(self.bus, message, timeout, clock_id) + if r == -1: + raise self.__oserror(e) + + + def read(self, callback : callable, user_data = None): + ''' + Listen (in a loop, forever) for new message on a bus + + @param callback:(message:str?, user_data:¿U?=user_data)→int + Function to call when a message is received, the + input parameters will be the read message and + `user_data` from the function's [`Bus.read`] parameter + with the same name. The message must have been parsed + or copied when `callback` returns as it may be over + overridden after that time. `callback` should + return either of the the values: + 0: stop listening + 1: continue listening + -1: an error has occurred + However, the function [`Bus.read`] will invoke + `callback` with `message` set to `None` one time + directly after it has started listening on the bus. + This is to the the program now it can safely continue + with any action that requires that the programs is + listening on the bus. + NB! The received message will not be decoded from UTF-8 + @param user_data:¿U? See description of `callback` + ''' + from native_bus import bus_read_wrapped + (r, e) = bus_read_wrapped(self.bus, callback, user_data) + if r == -1: + raise self.__oserror(e) + + + def read_timed(self, callback : callable, timeout : float, clock_id : int = None, user_data = None): + ''' + Listen (in a loop, forever) for new message on a bus + + @param callback:(message:str?, user_data:¿U?=user_data)→int + Function to call when a message is received, the + input parameters will be the read message and + `user_data` from the function's [`Bus.read`] parameter + with the same name. The message must have been parsed + or copied when `callback` returns as it may be over + overridden after that time. `callback` should + return either of the the values: + 0: stop listening + 1: continue listening + -1: an error has occurred + However, the function [`Bus.read`] will invoke + `callback` with `message` set to `None` one time + directly after it has started listening on the bus. + This is to the the program now it can safely continue + with any action that requires that the programs is + listening on the bus. + NB! The received message will not be decoded from UTF-8 + @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, + if it has not already completed, note that the callback + function may or may not have been called + @param clock_id:int? The clock `timeout` is measured in, it must be a + predictable clock, if `None`, `timeout` is measured in + relative time instead of absolute time + @param user_data:¿U? See description of `callback` + ''' + from native_bus import bus_read_timed_wrapped + if clock_id is None: + import time + clock_id = time.CLOCK_MONOTONIC_RAW + timeout += time.clock_gettime(clock_id) + (r, e) = bus_read_timed_wrapped(self.bus, callback, user_data, timeout, clock_id) + if r == -1: + raise self.__oserror(e) + + + def poll_start(self): + ''' + Announce that the thread is listening on the bus. + This is required so the will does not miss any + messages due to race conditions. Additionally, + not calling this function will cause the bus the + misbehave, is `Bus.poll` is written to expect + this function to have been called. + ''' + from native_bus import bus_poll_start_wrapped + (r, e) = bus_poll_start_wrapped(self.bus) + if r == -1: + raise self.__oserror(e) + + + def poll_stop(self): + ''' + Announce that the thread has stopped listening on the bus. + This is required so that the thread does not cause others + to wait indefinitely. + ''' + from native_bus import bus_poll_stop_wrapped + (r, e) = bus_poll_stop_wrapped(self.bus) + if r == -1: + raise self.__oserror(e) + + + def poll(self, flags : int = 0) -> bytes: + ''' + Wait for a message to be broadcasted on the bus. + The caller should make a copy of the received message, + without freeing the original copy, and parse it in a + separate thread. When the new thread has started be + started, the caller of this function should then + either call `Bus.poll` again or `Bus.poll_stop`. + + @param flags:int `Bus.NOWAIT` if the bus should fail with `os.errno.EAGAIN` + if there isn't already a message available on the bus + @return :bytes The received message + NB! The received message will not be decoded from UTF-8 + ''' + from native_bus import bus_poll_wrapped + (message, e) = bus_poll_wrapped(self.bus, flags) + if message is None: + raise self.__oserror(e) + return message + + + def poll_timed(self, timeout : float, clock_id : int = None) -> bytes: + ''' + Wait for a message to be broadcasted on the bus. + The caller should make a copy of the received message, + without freeing the original copy, and parse it in a + separate thread. When the new thread has started be + started, the caller of this function should then + either call `Bus.poll_timed` again or `Bus.poll_stop`. + + @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, + if it has not already completed + @param clock_id:int? The clock `timeout` is measured in, it must be a + predictable clock, if `None`, `timeout` is measured in + relative time instead of absolute time + @return :bytes The received message + NB! The received message will not be decoded from UTF-8 + ''' + from native_bus import bus_poll_timed_wrapped + if clock_id is None: + import time + clock_id = time.CLOCK_MONOTONIC_RAW + timeout += time.clock_gettime(clock_id) + (message, e) = bus_poll_timed_wrapped(self.bus, timeout, clock_id) + if message is None: + raise self.__oserror(e) + return message + + + def chown(self, owner = None, group = None): + ''' + Change the ownership of a bus + + `os.stat` can be used of the bus's associated file to get the bus's ownership + + @param owner:int|str? The user ID or username of the bus's new owner, + if `None`, keep current + @param group:int|str|...? The group ID or groupname of the bus's new group, + if `None`, keep current, `...` to use the owner's group + ''' + from native_bus import bus_chown_wrapped + if (owner is None) or (group is None): + from os import stat + attr = stat(self.pathname) + if owner is None: owner = attr.st_uid + if group is None: group = attr.st_gid + if isinstance(owner, str): + import pwd + owner = pwd.getpwnam(owner).pw_uid + if isinstance(group, str): + import grp + group = grp.getgrnam(group).gr_gid + elif group is ...: + import pwd + group = pwd.getpwuid(owner).pw_gid + (r, e) = bus_chown_wrapped(self.pathname, owner, group) + if r == -1: + raise self.__oserror(e) + + + def chmod(self, mode : int, mask : int = None): + ''' + Change the permissions for a bus + + `os.stat` can be used of the bus's associated file to get the bus's permissions + + @param mode:int The permissions of the bus, any permission for a user implies + full permissions for that user, except only the owner may + edit the bus's associated file + @param mask:int? Bits to clear before setting the bits in `mode`, if `None`, + all bits are cleared + ''' + from native_bus import bus_chmod_wrapped + if mask is not None: + from os import stat + current = stat(self.pathname).st_mode + if current & 0o700: current |= 0o700 + if current & 0o70: current |= 0o70 + if current & 0o7: current |= 0o7 + if mask & 0o700: mask |= 0o700 + if mask & 0o70: mask |= 0o70 + if mask & 0o7: mask |= 0o7 + current &= ~mask + mode |= current + (r, e) = bus_chmod_wrapped(self.pathname, mode) + if r == -1: + raise self.__oserror(e) + + + def __oserror(self, err : int): + ''' + Create an OSError + + @param err:int The value of errno + @return :OSError The OS error + ''' + import os + err = OSError(err, os.strerror(err)) + if err.errno == os.errno.ENOENT: + err.filename = self.pathname + return err diff --git a/config.mk b/config.mk new file mode 100644 index 0000000..e45ec85 --- /dev/null +++ b/config.mk @@ -0,0 +1,10 @@ +PREFIX = /usr/local +MANPREFIX = $(PREFIX)/share/man +PYTHONDIR = $(PREFIX)/lib/python$(PY_MAJOR).$(PY_MINOR) + +CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOUCE -D_XOPEN_SOURCE=700 +CFLAGS = -std=c99 -O2 $$(pkg-config --cflags python$(PY_MAJOR)) $(CPPFLAGS) +LDFLAGS = -s $$(pkg-config --libs python$(PY_MAJOR)) -lbus + +CYTHON = cython +PYTHON = python$(PY_MAJOR) diff --git a/dist/arch/stable/.gitignore b/dist/arch/stable/.gitignore deleted file mode 100644 index 1ed1d8e..0000000 --- a/dist/arch/stable/.gitignore +++ /dev/null @@ -1,6 +0,0 @@ -* -!/.git* -*~ -!/PKGBUILD -!/python-bus.install - diff --git a/dist/arch/stable/PKGBUILD b/dist/arch/stable/PKGBUILD deleted file mode 100644 index 2b683ed..0000000 --- a/dist/arch/stable/PKGBUILD +++ /dev/null @@ -1,26 +0,0 @@ -# Maintainer: Mattias Andrée <`base64 -d`(bWFhbmRyZWUK)@member.fsf.org> - -pkgname=python-bus -pkgver=3.1.1 -pkgrel=1 -pkgdesc="Python 3 module for bus" -arch=(i686 x86_64) -url="https://github.com/maandree/python-bus" -license=('MIT') -depends=(bus python) -makedepends=(cython) -source=($url/archive/$pkgver.tar.gz) -sha256sums=(f29d142b25b174831ba678976264c8fa3cb444e3de542491f30f56c889a1fc60) - - -build() { - cd "$srcdir/$pkgname-$pkgver" - make PREFIX=/usr -} - - -package() { - cd "$srcdir/$pkgname-$pkgver" - make PREFIX=/usr install DESTDIR="$pkgdir" -} - diff --git a/native_bus.pyx b/native_bus.pyx new file mode 100644 index 0000000..48504e7 --- /dev/null +++ b/native_bus.pyx @@ -0,0 +1,556 @@ +# -*- python -*- +# See LICENSE file for copyright and license details. + +cimport cython + +from libc.stdlib cimport malloc, free +from libc.errno cimport errno +from posix.types cimport uid_t, gid_t, mode_t, clockid_t, time_t + +cdef struct timespec: + time_t tv_sec + long tv_nsec +ctypedef timespec timespec_t + + +cdef extern int bus_create(const char *, int, char **) +''' +Create a new bus + +@param file The pathname of the bus, `NULL` to create a random one +@param flags `BUS_EXCL` (if `file` is not `NULL`) to fail if the file + already exists, otherwise if the file exists, nothing + will happen; + `BUS_INTR` to fail if interrupted +@param out_file Output parameter for the pathname of the bus +@return 0 on success, -1 on error +''' + +cdef extern int bus_unlink(const char *) +''' +Remove a bus + +@param file The pathname of the bus +@return 0 on success, -1 on error +''' + +cdef extern int bus_open(long, const char *, int) +''' +Open an existing bus + +@param bus Bus information to fill +@param file The filename of the bus +@param flags `BUS_RDONLY`, `BUS_WRONLY` or `BUS_RDWR`, + the value must not be negative +@return 0 on success, -1 on error +''' + +cdef extern int bus_close(long) +''' +Close a bus + +@param bus Bus information +@return 0 on success, -1 on error +''' + +cdef extern int bus_write(long, const char *, int) +''' +Broadcast a message a bus + +@param bus Bus information +@param message The message to write, may not be longer than + `BUS_MEMORY_SIZE` including the NUL-termination +@param flags `BUS_NOWAIT` fail if other process is attempting + to write +@return 0 on success, -1 on error +''' + +cdef extern int bus_write_timed(long, const char *, timespec_t *, clockid_t) +''' +Broadcast a message a bus + +@param bus Bus information +@param message The message to write, may not be longer than + `BUS_MEMORY_SIZE` including the NUL-termination +@param timeout The time the operation shall fail with errno set + to `EAGAIN` if not completed +@param clockid The ID of the clock the `timeout` is measured with, + it most be a predictable clock +@return 0 on success, -1 on error +''' + +cdef extern int bus_read(long, int (*)(const char *, void *), void *) +''' +Listen (in a loop, forever) for new message on a bus + +@param bus Bus information +@param callback Function to call when a message is received, the + input parameters will be the read message and + `user_data` from `bus_read`'s parameter with the + same name. The message must have been parsed or + copied when `callback` returns as it may be over + overridden after that time. `callback` should + return either of the the values: + 0: stop listening + 1: continue listening + -1: an error has occurred +@param user_data Parameter passed to `callback` +@return 0 on success, -1 on error +''' + +cdef extern int bus_read_timed(long, int (*)(const char *, void *), void *, timespec_t *, clockid_t) +''' +Listen (in a loop, forever) for new message on a bus + +@param bus Bus information +@param callback Function to call when a message is received, the + input parameters will be the read message and + `user_data` from `bus_read`'s parameter with the + same name. The message must have been parsed or + copied when `callback` returns as it may be over + overridden after that time. `callback` should + return either of the the values: + 0: stop listening + 1: continue listening + -1: an error has occurred +@param user_data Parameter passed to `callback` +@param timeout The time the operation shall fail with errno set + to `EAGAIN` if not completed, note that the callback + function may or may not have been called +@param clockid The ID of the clock the `timeout` is measured with, + it most be a predictable clock +@return 0 on success, -1 on error +''' + +cdef extern int bus_poll_start(long) +''' +Announce that the thread is listening on the bus. +This is required so the will does not miss any +messages due to race conditions. Additionally, +not calling this function will cause the bus the +misbehave, is `bus_poll` is written to expect +this function to have been called. + +@param bus Bus information +@return 0 on success, -1 on error +''' + +cdef extern int bus_poll_stop(long) +''' +Announce that the thread has stopped listening on the bus. +This is required so that the thread does not cause others +to wait indefinitely. + +@param bus Bus information +@return 0 on success, -1 on error +''' + +cdef extern const char *bus_poll(long, int) +''' +Wait for a message to be broadcasted on the bus. +The caller should make a copy of the received message, +without freeing the original copy, and parse it in a +separate thread. When the new thread has started be +started, the caller of this function should then +either call `bus_poll` again or `bus_poll_stop`. + +@param bus Bus information +@param flags `BUS_NOWAIT` if the bus should fail and set `errno` to + `EAGAIN` if there isn't already a message available on the bus +@return The received message, `NULL` on error +''' + +cdef extern const char *bus_poll_timed(long, timespec_t *, clockid_t) +''' +Wait for a message to be broadcasted on the bus. +The caller should make a copy of the received message, +without freeing the original copy, and parse it in a +separate thread. When the new thread has started be +started, the caller of this function should then +either call `bus_poll_timed` again or `bus_poll_stop`. + +@param bus Bus information +@param timeout The time the operation shall fail with errno set + to `EAGAIN` if not completed +@param clockid The ID of the clock the `timeout` is measured with, + it most be a predictable clock +@return The received message, `NULL` on error +''' + +cdef extern int bus_chown(const char *, uid_t, gid_t) +''' +Change the ownership of a bus + +`stat(2)` can be used of the bus's associated file to get the bus's ownership + +@param file The pathname of the bus +@param owner The user ID of the bus's new owner +@param group The group ID of the bus's new group +@return 0 on success, -1 on error +''' + +cdef extern int bus_chmod(const char *, mode_t) +''' +Change the permissions for a bus + +`stat(2)` can be used of the bus's associated file to get the bus's permissions + +@param file The pathname of the bus +@param mode The permissions of the bus, any permission for a user implies + full permissions for that user, except only the owner may + edit the bus's associated file +@return 0 on success, -1 on error +''' + + + +def bus_allocate() -> tuple: + ''' + Allocate memory for a bus + + @return :int The address of the allocated memory + @return :int The value of `errno` + ''' + n = 2 * sizeof(long long) + sizeof(int) + sizeof(char *) + r = malloc(n) + e = errno + return (r, e) + + +def bus_deallocate(address : int): + ''' + Deallocate memory for a bus + + @param address:int The address of the allocated memory + ''' + free(address) + + +def bus_create_wrapped(file : str, flags : int) -> tuple: + ''' + Create a new bus + + @param file:str The pathname of the bus, `None` to create a random one + @param flags:int `BUS_EXCL` (if `file` is not `None`) to fail if the file + already exists, otherwise if the file exists, nothing + will happen; + `BUS_INTR` to fail if interrupted + @return :str The pathname of the bus, `None` on error; + `file` is returned unless `file` is `None` + @return :int The value of `errno` + ''' + cdef const char* cfile + cdef char* ofile + cdef bytes bs + if file is not None: + bs = file.encode('utf-8') + bytes([0]) + cfile = bs + r = bus_create(cfile, flags, NULL) + e = errno + return (file if r == 0 else None, e) + r = bus_create(NULL, flags, &ofile) + e = errno + if r == 0: + bs = ofile + return (bs.decode('utf-8', 'strict'), e) + return (None, e) + + +def bus_unlink_wrapped(file : str) -> tuple: + ''' + Remove a bus + + @param file:str The pathname of the bus + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + cdef const char* cfile + cdef bytes bs + bs = file.encode('utf-8') + bytes([0]) + cfile = bs + r = bus_unlink(cfile) + e = errno + return (r, e) + + +def bus_open_wrapped(bus : int, file : str, flags : int) -> tuple: + ''' + Open an existing bus + + @param bus:int Bus information to fill + @param file:str The filename of the bus + @param flags:int `BUS_RDONLY`, `BUS_WRONLY` or `BUS_RDWR`, + the value must not be negative + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + cdef const char* cfile + cdef bytes bs + bs = file.encode('utf-8') + bytes([0]) + cfile = bs + r = bus_open(bus, cfile, flags) + e = errno + return (r, e) + + +def bus_close_wrapped(bus : int) -> tuple: + ''' + Close a bus + + @param bus:int Bus information + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + r = bus_close(bus) + e = errno + return (r, e) + + +def bus_write_wrapped(bus : int, message : str, flags : int) -> tuple: + ''' + Broadcast a message a bus + + @param bus:int Bus information + @param message:str The message to write, may not be longer than + `BUS_MEMORY_SIZE` including the NUL-termination + @param flags:int `BUS_NOWAIT` fail with errno set to `os.errno.EAGAIN` + if other process is attempting to write + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + cdef const char* cmessage + cdef bytes bs + bs = message.encode('utf-8') + bytes([0]) + cmessage = bs + r = bus_write(bus, cmessage, flags) + e = errno + return (r, e) + + +def bus_write_timed_wrapped(bus : int, message : str, timeout : float, clock_id : int) -> tuple: + ''' + Broadcast a message a bus + + @param bus:int Bus information + @param message:str The message to write, may not be longer than + `BUS_MEMORY_SIZE` including the NUL-termination + @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, + if it has not already completed + @param clock_id:int The clock `timeout` is measured in, it must be a + predictable clock + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + cdef const char* cmessage + cdef bytes bs + cdef timespec_t timeout_spec + bs = message.encode('utf-8') + bytes([0]) + cmessage = bs + timeout_spec.tv_sec = int(timeout) + timeout_spec.tv_nsec = int((timeout - int(timeout)) * 1000000000) + r = bus_write_timed(bus, cmessage, &timeout_spec, clock_id) + e = errno + return (r, e) + + +cdef int bus_callback_wrapper(const char *message, user_data): + cdef bytes bs + callback, user_data = tuple(user_data) + if message is NULL: + return callback(None, user_data) + else: + bs = message + return callback(bs, user_data) + + +def bus_read_wrapped(bus : int, callback : callable, user_data) -> tuple: + ''' + Listen (in a loop, forever) for new message on a bus + + @param bus:int Bus information + @param callback:(str?, ¿U?)→int Function to call when a message is received, the + input parameters will be the read message and + `user_data` from `bus_read`'s parameter with the + same name. The message must have been parsed or + copied when `callback` returns as it may be over + overridden after that time. `callback` should + return either of the the values: + 0: stop listening + 1: continue listening + -1: an error has occurred + @param user_data:¿U? Parameter passed to `callback` + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + user = (callback, user_data) + r = bus_read(bus, &bus_callback_wrapper, user) + e = errno + return (r, e) + + +def bus_read_timed_wrapped(bus : int, callback : callable, user_data, timeout : float, clock_id : int) -> tuple: + ''' + Listen (in a loop, forever) for new message on a bus + + @param bus:int Bus information + @param callback:(str?, ¿U?)→int Function to call when a message is received, the + input parameters will be the read message and + `user_data` from `bus_read`'s parameter with the + same name. The message must have been parsed or + copied when `callback` returns as it may be over + overridden after that time. `callback` should + return either of the the values: + 0: stop listening + 1: continue listening + -1: an error has occurred + @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, + if it has not already completed, note that the callback + function may or may not have been called + @param clock_id:int The clock `timeout` is measured in, it must be a + predictable clock + @param user_data:¿U? Parameter passed to `callback` + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + cdef timespec_t timeout_spec + user = (callback, user_data) + timeout_spec.tv_sec = int(timeout) + timeout_spec.tv_nsec = int((timeout - int(timeout)) * 1000000000) + r = bus_read_timed(bus, &bus_callback_wrapper, + user, &timeout_spec, clock_id) + e = errno + return (r, e) + + +def bus_poll_start_wrapped(bus : int) -> tuple: + ''' + Announce that the thread is listening on the bus. + This is required so the will does not miss any + messages due to race conditions. Additionally, + not calling this function will cause the bus the + misbehave, is `bus_poll_wrapped` is written to expect + this function to have been called. + + @param bus:int Bus information + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + r = bus_poll_start(bus) + e = errno + return (r, e) + + +def bus_poll_stop_wrapped(bus : int) -> tuple: + ''' + Announce that the thread has stopped listening on the bus. + This is required so that the thread does not cause others + to wait indefinitely. + + @param bus:int Bus information + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + r = bus_poll_stop(bus) + e = errno + return (r, e) + + +def bus_poll_wrapped(bus : int, flags : int) -> tuple: + ''' + Wait for a message to be broadcasted on the bus. + The caller should make a copy of the received message, + without freeing the original copy, and parse it in a + separate thread. When the new thread has started be + started, the caller of this function should then + either call `bus_poll_wrapped` again or + `bus_poll_stop_wrapped`. + + @param bus:int Bus information + @param flags:int `BUS_NOWAIT` if the bus should fail and set `errno` + to `os.errno.EAGAIN` if there isn't already a message + available on the bus + @return :bytes The received message, `None` on error + @return :int The value of `errno` + ''' + cdef const char* msg + cdef bytes bs + msg = bus_poll(bus, flags) + e = errno + if msg is NULL: + return (None, e) + bs = msg + return (bs, e) + + +def bus_poll_timed_wrapped(bus : int, timeout : float, clock_id : int) -> tuple: + ''' + Wait for a message to be broadcasted on the bus. + The caller should make a copy of the received message, + without freeing the original copy, and parse it in a + separate thread. When the new thread has started be + started, the caller of this function should then + either call `bus_poll_timed_wrapped` again or + `bus_poll_stop_wrapped`. + + @param bus:int Bus information + @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, + if it has not already completed + @param clock_id:int The clock `timeout` is measured in, it must be a + predictable clock + @return :bytes The received message, `None` on error + @return :int The value of `errno` + ''' + cdef const char* msg + cdef bytes bs + cdef timespec_t timeout_spec + timeout_spec.tv_sec = int(timeout) + timeout_spec.tv_nsec = int((timeout - int(timeout)) * 1000000000) + msg = bus_poll_timed(bus, &timeout_spec, clock_id) + e = errno + if msg is NULL: + return (None, e) + bs = msg + return (bs, e) + + +def bus_chown_wrapped(file : str, owner : int, group : int) -> tuple: + ''' + Change the ownership of a bus + + `os.stat` can be used of the bus's associated file to get the bus's ownership + + @param file:str The pathname of the bus + @param owner:int The user ID of the bus's new owner + @param group:int The group ID of the bus's new group + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + cdef const char* cfile + cdef bytes bs + bs = file.encode('utf-8') + bytes([0]) + cfile = bs + r = bus_chown(cfile, owner, group) + e = errno + return (r, e) + + +def bus_chmod_wrapped(file : str, mode : int) -> tuple: + ''' + Change the permissions for a bus + + `os.stat` can be used of the bus's associated file to get the bus's permissions + + @param file:str The pathname of the bus + @param mode:int The permissions of the bus, any permission for a user implies + full permissions for that user, except only the owner may + edit the bus's associated file + @return :int 0 on success, -1 on error + @return :int The value of `errno` + ''' + cdef const char* cfile + cdef bytes bs + bs = file.encode('utf-8') + bytes([0]) + cfile = bs + r = bus_chmod(cfile, mode) + e = errno + return (r, e) diff --git a/src/bus.py b/src/bus.py deleted file mode 100644 index 08e8a9b..0000000 --- a/src/bus.py +++ /dev/null @@ -1,399 +0,0 @@ -# -*- python -*- -''' -MIT/X Consortium License - -Copyright © 2015 Mattias Andrée - -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the "Software"), -to deal in the Software without restriction, including without limitation -the rights to use, copy, modify, merge, publish, distribute, sublicense, -and/or sell copies of the Software, and to permit persons to whom the -Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. -''' - - -class Bus: - ''' - Message broadcasting interprocess communication - ''' - - - RDONLY = 1 - ''' - Open the bus for reading only - ''' - - WRONLY = 0 - ''' - Open the bus for writing only - ''' - - RDWR = 0 - ''' - Open the bus for both reading and writing only - ''' - - EXCL = 2 - ''' - Fail to create bus if its file already exists - ''' - - INTR = 4 - ''' - Fail if interrupted - ''' - - NOWAIT = 1 - ''' - Function shall fail with `os.errno.EAGAIN` - if the it would block and this flag is used - ''' - - - def __init__(self, pathname : str = None): - ''' - Constructor - - @param pathname:str The pathname of the bus, `None` if `create` should select a random pathname - ''' - self.pathname = pathname - self.bus = None - - - def __del__(self): - ''' - Destructor - ''' - self.close() - - - def create(self, flags : int = 0) -> str: - ''' - Create the bus - - @param flags:or_flag `Bus.EXCL` (if the pathname is not `None`) to fail if the file - already exists, otherwise if the file exists, nothing will happen; - `Bus.INTR` to fail if interrupted - @return :str The pathname of the bus - ''' - from native_bus import bus_create_wrapped - (self.pathname, e) = bus_create_wrapped(self.pathname, flags) - if self.pathname is None: - raise self.__oserror(e) - return self.pathname - - - def unlink(self): - ''' - Remove the bus - ''' - from native_bus import bus_unlink_wrapped - (r, e) = bus_unlink_wrapped(self.pathname) - if r == -1: - raise self.__oserror(e) - - - def open(self, flags : int = 0): - ''' - Open an existing bus - - @param flags:int `Bus.RDONLY`, `Bus.WRONLY` or `Bus.RDWR`, the value must not be negative - ''' - from native_bus import bus_close_wrapped, bus_allocate, bus_open_wrapped - if self.bus is not None: - (r, e) = bus_close_wrapped(self.bus) - if r == -1: - raise self.__oserror(e) - else: - (self.bus, e) = bus_allocate() - if self.bus == 0: - raise self.__oserror(e) - (r, e) = bus_open_wrapped(self.bus, self.pathname, flags) - if r == -1: - raise self.__oserror(e) - - - def close(self): - ''' - Close the bus - ''' - try: - from native_bus import bus_close_wrapped, bus_deallocate - except: - return - if self.bus is not None: - (r, e) = bus_close_wrapped(self.bus) - if r == -1: - raise self.__oserror(e) - bus_deallocate(self.bus) - self.bus = None - - - def write(self, message : str, flags : int = 0): - ''' - Broadcast a message a bus - - @param message:str The message to write, may not be longer than 2047 bytes - after UTF-8 encoding - @param flags:int `Bus.NOWAIT` if the function shall fail with `os.errno.EAGAIN` - if there is another process attempting to broadcast on the bus - ''' - from native_bus import bus_write_wrapped - (r, e) = bus_write_wrapped(self.bus, message, flags) - if r == -1: - raise self.__oserror(e) - - - def write_timed(self, message : str, timeout : float, clock_id : int = None): - ''' - Broadcast a message a bus - - @param message:str The message to write, may not be longer than 2047 bytes - after UTF-8 encoding - @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, - if it has not already completed - @param clock_id:int? The clock `timeout` is measured in, it must be a - predictable clock, if `None`, `timeout` is measured in - relative time instead of absolute time - ''' - from native_bus import bus_write_timed_wrapped - if clock_id is None: - import time - clock_id = time.CLOCK_MONOTONIC_RAW - timeout += time.clock_gettime(clock_id) - (r, e) = bus_write_timed_wrapped(self.bus, message, timeout, clock_id) - if r == -1: - raise self.__oserror(e) - - - def read(self, callback : callable, user_data = None): - ''' - Listen (in a loop, forever) for new message on a bus - - @param callback:(message:str?, user_data:¿U?=user_data)→int - Function to call when a message is received, the - input parameters will be the read message and - `user_data` from the function's [`Bus.read`] parameter - with the same name. The message must have been parsed - or copied when `callback` returns as it may be over - overridden after that time. `callback` should - return either of the the values: - 0: stop listening - 1: continue listening - -1: an error has occurred - However, the function [`Bus.read`] will invoke - `callback` with `message` set to `None` one time - directly after it has started listening on the bus. - This is to the the program now it can safely continue - with any action that requires that the programs is - listening on the bus. - NB! The received message will not be decoded from UTF-8 - @param user_data:¿U? See description of `callback` - ''' - from native_bus import bus_read_wrapped - (r, e) = bus_read_wrapped(self.bus, callback, user_data) - if r == -1: - raise self.__oserror(e) - - - def read_timed(self, callback : callable, timeout : float, clock_id : int = None, user_data = None): - ''' - Listen (in a loop, forever) for new message on a bus - - @param callback:(message:str?, user_data:¿U?=user_data)→int - Function to call when a message is received, the - input parameters will be the read message and - `user_data` from the function's [`Bus.read`] parameter - with the same name. The message must have been parsed - or copied when `callback` returns as it may be over - overridden after that time. `callback` should - return either of the the values: - 0: stop listening - 1: continue listening - -1: an error has occurred - However, the function [`Bus.read`] will invoke - `callback` with `message` set to `None` one time - directly after it has started listening on the bus. - This is to the the program now it can safely continue - with any action that requires that the programs is - listening on the bus. - NB! The received message will not be decoded from UTF-8 - @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, - if it has not already completed, note that the callback - function may or may not have been called - @param clock_id:int? The clock `timeout` is measured in, it must be a - predictable clock, if `None`, `timeout` is measured in - relative time instead of absolute time - @param user_data:¿U? See description of `callback` - ''' - from native_bus import bus_read_timed_wrapped - if clock_id is None: - import time - clock_id = time.CLOCK_MONOTONIC_RAW - timeout += time.clock_gettime(clock_id) - (r, e) = bus_read_timed_wrapped(self.bus, callback, user_data, timeout, clock_id) - if r == -1: - raise self.__oserror(e) - - - def poll_start(self): - ''' - Announce that the thread is listening on the bus. - This is required so the will does not miss any - messages due to race conditions. Additionally, - not calling this function will cause the bus the - misbehave, is `Bus.poll` is written to expect - this function to have been called. - ''' - from native_bus import bus_poll_start_wrapped - (r, e) = bus_poll_start_wrapped(self.bus) - if r == -1: - raise self.__oserror(e) - - - def poll_stop(self): - ''' - Announce that the thread has stopped listening on the bus. - This is required so that the thread does not cause others - to wait indefinitely. - ''' - from native_bus import bus_poll_stop_wrapped - (r, e) = bus_poll_stop_wrapped(self.bus) - if r == -1: - raise self.__oserror(e) - - - def poll(self, flags : int = 0) -> bytes: - ''' - Wait for a message to be broadcasted on the bus. - The caller should make a copy of the received message, - without freeing the original copy, and parse it in a - separate thread. When the new thread has started be - started, the caller of this function should then - either call `Bus.poll` again or `Bus.poll_stop`. - - @param flags:int `Bus.NOWAIT` if the bus should fail with `os.errno.EAGAIN` - if there isn't already a message available on the bus - @return :bytes The received message - NB! The received message will not be decoded from UTF-8 - ''' - from native_bus import bus_poll_wrapped - (message, e) = bus_poll_wrapped(self.bus, flags) - if message is None: - raise self.__oserror(e) - return message - - - def poll_timed(self, timeout : float, clock_id : int = None) -> bytes: - ''' - Wait for a message to be broadcasted on the bus. - The caller should make a copy of the received message, - without freeing the original copy, and parse it in a - separate thread. When the new thread has started be - started, the caller of this function should then - either call `Bus.poll_timed` again or `Bus.poll_stop`. - - @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, - if it has not already completed - @param clock_id:int? The clock `timeout` is measured in, it must be a - predictable clock, if `None`, `timeout` is measured in - relative time instead of absolute time - @return :bytes The received message - NB! The received message will not be decoded from UTF-8 - ''' - from native_bus import bus_poll_timed_wrapped - if clock_id is None: - import time - clock_id = time.CLOCK_MONOTONIC_RAW - timeout += time.clock_gettime(clock_id) - (message, e) = bus_poll_timed_wrapped(self.bus, timeout, clock_id) - if message is None: - raise self.__oserror(e) - return message - - - def chown(self, owner = None, group = None): - ''' - Change the ownership of a bus - - `os.stat` can be used of the bus's associated file to get the bus's ownership - - @param owner:int|str? The user ID or username of the bus's new owner, - if `None`, keep current - @param group:int|str|...? The group ID or groupname of the bus's new group, - if `None`, keep current, `...` to use the owner's group - ''' - from native_bus import bus_chown_wrapped - if (owner is None) or (group is None): - from os import stat - attr = stat(self.pathname) - if owner is None: owner = attr.st_uid - if group is None: group = attr.st_gid - if isinstance(owner, str): - import pwd - owner = pwd.getpwnam(owner).pw_uid - if isinstance(group, str): - import grp - group = grp.getgrnam(group).gr_gid - elif group is ...: - import pwd - group = pwd.getpwuid(owner).pw_gid - (r, e) = bus_chown_wrapped(self.pathname, owner, group) - if r == -1: - raise self.__oserror(e) - - - def chmod(self, mode : int, mask : int = None): - ''' - Change the permissions for a bus - - `os.stat` can be used of the bus's associated file to get the bus's permissions - - @param mode:int The permissions of the bus, any permission for a user implies - full permissions for that user, except only the owner may - edit the bus's associated file - @param mask:int? Bits to clear before setting the bits in `mode`, if `None`, - all bits are cleared - ''' - from native_bus import bus_chmod_wrapped - if mask is not None: - from os import stat - current = stat(self.pathname).st_mode - if current & 0o700: current |= 0o700 - if current & 0o70: current |= 0o70 - if current & 0o7: current |= 0o7 - if mask & 0o700: mask |= 0o700 - if mask & 0o70: mask |= 0o70 - if mask & 0o7: mask |= 0o7 - current &= ~mask - mode |= current - (r, e) = bus_chmod_wrapped(self.pathname, mode) - if r == -1: - raise self.__oserror(e) - - - def __oserror(self, err : int): - ''' - Create an OSError - - @param err:int The value of errno - @return :OSError The OS error - ''' - import os - err = OSError(err, os.strerror(err)) - if err.errno == os.errno.ENOENT: - err.filename = self.pathname - return err - diff --git a/src/native_bus.pyx b/src/native_bus.pyx deleted file mode 100644 index 861c16f..0000000 --- a/src/native_bus.pyx +++ /dev/null @@ -1,579 +0,0 @@ -# -*- python -*- -''' -MIT/X Consortium License - -Copyright © 2015 Mattias Andrée - -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the "Software"), -to deal in the Software without restriction, including without limitation -the rights to use, copy, modify, merge, publish, distribute, sublicense, -and/or sell copies of the Software, and to permit persons to whom the -Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. -''' - -cimport cython - -from libc.stdlib cimport malloc, free -from libc.errno cimport errno -from posix.types cimport uid_t, gid_t, mode_t, clockid_t, time_t - -cdef struct timespec: - time_t tv_sec - long tv_nsec -ctypedef timespec timespec_t - - -cdef extern int bus_create(const char *, int, char **) -''' -Create a new bus - -@param file The pathname of the bus, `NULL` to create a random one -@param flags `BUS_EXCL` (if `file` is not `NULL`) to fail if the file - already exists, otherwise if the file exists, nothing - will happen; - `BUS_INTR` to fail if interrupted -@param out_file Output parameter for the pathname of the bus -@return 0 on success, -1 on error -''' - -cdef extern int bus_unlink(const char *) -''' -Remove a bus - -@param file The pathname of the bus -@return 0 on success, -1 on error -''' - -cdef extern int bus_open(long, const char *, int) -''' -Open an existing bus - -@param bus Bus information to fill -@param file The filename of the bus -@param flags `BUS_RDONLY`, `BUS_WRONLY` or `BUS_RDWR`, - the value must not be negative -@return 0 on success, -1 on error -''' - -cdef extern int bus_close(long) -''' -Close a bus - -@param bus Bus information -@return 0 on success, -1 on error -''' - -cdef extern int bus_write(long, const char *, int) -''' -Broadcast a message a bus - -@param bus Bus information -@param message The message to write, may not be longer than - `BUS_MEMORY_SIZE` including the NUL-termination -@param flags `BUS_NOWAIT` fail if other process is attempting - to write -@return 0 on success, -1 on error -''' - -cdef extern int bus_write_timed(long, const char *, timespec_t *, clockid_t) -''' -Broadcast a message a bus - -@param bus Bus information -@param message The message to write, may not be longer than - `BUS_MEMORY_SIZE` including the NUL-termination -@param timeout The time the operation shall fail with errno set - to `EAGAIN` if not completed -@param clockid The ID of the clock the `timeout` is measured with, - it most be a predictable clock -@return 0 on success, -1 on error -''' - -cdef extern int bus_read(long, int (*)(const char *, void *), void *) -''' -Listen (in a loop, forever) for new message on a bus - -@param bus Bus information -@param callback Function to call when a message is received, the - input parameters will be the read message and - `user_data` from `bus_read`'s parameter with the - same name. The message must have been parsed or - copied when `callback` returns as it may be over - overridden after that time. `callback` should - return either of the the values: - 0: stop listening - 1: continue listening - -1: an error has occurred -@param user_data Parameter passed to `callback` -@return 0 on success, -1 on error -''' - -cdef extern int bus_read_timed(long, int (*)(const char *, void *), void *, timespec_t *, clockid_t) -''' -Listen (in a loop, forever) for new message on a bus - -@param bus Bus information -@param callback Function to call when a message is received, the - input parameters will be the read message and - `user_data` from `bus_read`'s parameter with the - same name. The message must have been parsed or - copied when `callback` returns as it may be over - overridden after that time. `callback` should - return either of the the values: - 0: stop listening - 1: continue listening - -1: an error has occurred -@param user_data Parameter passed to `callback` -@param timeout The time the operation shall fail with errno set - to `EAGAIN` if not completed, note that the callback - function may or may not have been called -@param clockid The ID of the clock the `timeout` is measured with, - it most be a predictable clock -@return 0 on success, -1 on error -''' - -cdef extern int bus_poll_start(long) -''' -Announce that the thread is listening on the bus. -This is required so the will does not miss any -messages due to race conditions. Additionally, -not calling this function will cause the bus the -misbehave, is `bus_poll` is written to expect -this function to have been called. - -@param bus Bus information -@return 0 on success, -1 on error -''' - -cdef extern int bus_poll_stop(long) -''' -Announce that the thread has stopped listening on the bus. -This is required so that the thread does not cause others -to wait indefinitely. - -@param bus Bus information -@return 0 on success, -1 on error -''' - -cdef extern const char *bus_poll(long, int) -''' -Wait for a message to be broadcasted on the bus. -The caller should make a copy of the received message, -without freeing the original copy, and parse it in a -separate thread. When the new thread has started be -started, the caller of this function should then -either call `bus_poll` again or `bus_poll_stop`. - -@param bus Bus information -@param flags `BUS_NOWAIT` if the bus should fail and set `errno` to - `EAGAIN` if there isn't already a message available on the bus -@return The received message, `NULL` on error -''' - -cdef extern const char *bus_poll_timed(long, timespec_t *, clockid_t) -''' -Wait for a message to be broadcasted on the bus. -The caller should make a copy of the received message, -without freeing the original copy, and parse it in a -separate thread. When the new thread has started be -started, the caller of this function should then -either call `bus_poll_timed` again or `bus_poll_stop`. - -@param bus Bus information -@param timeout The time the operation shall fail with errno set - to `EAGAIN` if not completed -@param clockid The ID of the clock the `timeout` is measured with, - it most be a predictable clock -@return The received message, `NULL` on error -''' - -cdef extern int bus_chown(const char *, uid_t, gid_t) -''' -Change the ownership of a bus - -`stat(2)` can be used of the bus's associated file to get the bus's ownership - -@param file The pathname of the bus -@param owner The user ID of the bus's new owner -@param group The group ID of the bus's new group -@return 0 on success, -1 on error -''' - -cdef extern int bus_chmod(const char *, mode_t) -''' -Change the permissions for a bus - -`stat(2)` can be used of the bus's associated file to get the bus's permissions - -@param file The pathname of the bus -@param mode The permissions of the bus, any permission for a user implies - full permissions for that user, except only the owner may - edit the bus's associated file -@return 0 on success, -1 on error -''' - - - -def bus_allocate() -> tuple: - ''' - Allocate memory for a bus - - @return :int The address of the allocated memory - @return :int The value of `errno` - ''' - n = 2 * sizeof(long long) + sizeof(int) + sizeof(char *) - r = malloc(n) - e = errno - return (r, e) - - -def bus_deallocate(address : int): - ''' - Deallocate memory for a bus - - @param address:int The address of the allocated memory - ''' - free(address) - - -def bus_create_wrapped(file : str, flags : int) -> tuple: - ''' - Create a new bus - - @param file:str The pathname of the bus, `None` to create a random one - @param flags:int `BUS_EXCL` (if `file` is not `None`) to fail if the file - already exists, otherwise if the file exists, nothing - will happen; - `BUS_INTR` to fail if interrupted - @return :str The pathname of the bus, `None` on error; - `file` is returned unless `file` is `None` - @return :int The value of `errno` - ''' - cdef const char* cfile - cdef char* ofile - cdef bytes bs - if file is not None: - bs = file.encode('utf-8') + bytes([0]) - cfile = bs - r = bus_create(cfile, flags, NULL) - e = errno - return (file if r == 0 else None, e) - r = bus_create(NULL, flags, &ofile) - e = errno - if r == 0: - bs = ofile - return (bs.decode('utf-8', 'strict'), e) - return (None, e) - - -def bus_unlink_wrapped(file : str) -> tuple: - ''' - Remove a bus - - @param file:str The pathname of the bus - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - cdef const char* cfile - cdef bytes bs - bs = file.encode('utf-8') + bytes([0]) - cfile = bs - r = bus_unlink(cfile) - e = errno - return (r, e) - - -def bus_open_wrapped(bus : int, file : str, flags : int) -> tuple: - ''' - Open an existing bus - - @param bus:int Bus information to fill - @param file:str The filename of the bus - @param flags:int `BUS_RDONLY`, `BUS_WRONLY` or `BUS_RDWR`, - the value must not be negative - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - cdef const char* cfile - cdef bytes bs - bs = file.encode('utf-8') + bytes([0]) - cfile = bs - r = bus_open(bus, cfile, flags) - e = errno - return (r, e) - - -def bus_close_wrapped(bus : int) -> tuple: - ''' - Close a bus - - @param bus:int Bus information - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - r = bus_close(bus) - e = errno - return (r, e) - - -def bus_write_wrapped(bus : int, message : str, flags : int) -> tuple: - ''' - Broadcast a message a bus - - @param bus:int Bus information - @param message:str The message to write, may not be longer than - `BUS_MEMORY_SIZE` including the NUL-termination - @param flags:int `BUS_NOWAIT` fail with errno set to `os.errno.EAGAIN` - if other process is attempting to write - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - cdef const char* cmessage - cdef bytes bs - bs = message.encode('utf-8') + bytes([0]) - cmessage = bs - r = bus_write(bus, cmessage, flags) - e = errno - return (r, e) - - -def bus_write_timed_wrapped(bus : int, message : str, timeout : float, clock_id : int) -> tuple: - ''' - Broadcast a message a bus - - @param bus:int Bus information - @param message:str The message to write, may not be longer than - `BUS_MEMORY_SIZE` including the NUL-termination - @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, - if it has not already completed - @param clock_id:int The clock `timeout` is measured in, it must be a - predictable clock - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - cdef const char* cmessage - cdef bytes bs - cdef timespec_t timeout_spec - bs = message.encode('utf-8') + bytes([0]) - cmessage = bs - timeout_spec.tv_sec = int(timeout) - timeout_spec.tv_nsec = int((timeout - int(timeout)) * 1000000000) - r = bus_write_timed(bus, cmessage, &timeout_spec, clock_id) - e = errno - return (r, e) - - -cdef int bus_callback_wrapper(const char *message, user_data): - cdef bytes bs - callback, user_data = tuple(user_data) - if message is NULL: - return callback(None, user_data) - else: - bs = message - return callback(bs, user_data) - - -def bus_read_wrapped(bus : int, callback : callable, user_data) -> tuple: - ''' - Listen (in a loop, forever) for new message on a bus - - @param bus:int Bus information - @param callback:(str?, ¿U?)→int Function to call when a message is received, the - input parameters will be the read message and - `user_data` from `bus_read`'s parameter with the - same name. The message must have been parsed or - copied when `callback` returns as it may be over - overridden after that time. `callback` should - return either of the the values: - 0: stop listening - 1: continue listening - -1: an error has occurred - @param user_data:¿U? Parameter passed to `callback` - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - user = (callback, user_data) - r = bus_read(bus, &bus_callback_wrapper, user) - e = errno - return (r, e) - - -def bus_read_timed_wrapped(bus : int, callback : callable, user_data, timeout : float, clock_id : int) -> tuple: - ''' - Listen (in a loop, forever) for new message on a bus - - @param bus:int Bus information - @param callback:(str?, ¿U?)→int Function to call when a message is received, the - input parameters will be the read message and - `user_data` from `bus_read`'s parameter with the - same name. The message must have been parsed or - copied when `callback` returns as it may be over - overridden after that time. `callback` should - return either of the the values: - 0: stop listening - 1: continue listening - -1: an error has occurred - @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, - if it has not already completed, note that the callback - function may or may not have been called - @param clock_id:int The clock `timeout` is measured in, it must be a - predictable clock - @param user_data:¿U? Parameter passed to `callback` - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - cdef timespec_t timeout_spec - user = (callback, user_data) - timeout_spec.tv_sec = int(timeout) - timeout_spec.tv_nsec = int((timeout - int(timeout)) * 1000000000) - r = bus_read_timed(bus, &bus_callback_wrapper, - user, &timeout_spec, clock_id) - e = errno - return (r, e) - - -def bus_poll_start_wrapped(bus : int) -> tuple: - ''' - Announce that the thread is listening on the bus. - This is required so the will does not miss any - messages due to race conditions. Additionally, - not calling this function will cause the bus the - misbehave, is `bus_poll_wrapped` is written to expect - this function to have been called. - - @param bus:int Bus information - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - r = bus_poll_start(bus) - e = errno - return (r, e) - - -def bus_poll_stop_wrapped(bus : int) -> tuple: - ''' - Announce that the thread has stopped listening on the bus. - This is required so that the thread does not cause others - to wait indefinitely. - - @param bus:int Bus information - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - r = bus_poll_stop(bus) - e = errno - return (r, e) - - -def bus_poll_wrapped(bus : int, flags : int) -> tuple: - ''' - Wait for a message to be broadcasted on the bus. - The caller should make a copy of the received message, - without freeing the original copy, and parse it in a - separate thread. When the new thread has started be - started, the caller of this function should then - either call `bus_poll_wrapped` again or - `bus_poll_stop_wrapped`. - - @param bus:int Bus information - @param flags:int `BUS_NOWAIT` if the bus should fail and set `errno` - to `os.errno.EAGAIN` if there isn't already a message - available on the bus - @return :bytes The received message, `None` on error - @return :int The value of `errno` - ''' - cdef const char* msg - cdef bytes bs - msg = bus_poll(bus, flags) - e = errno - if msg is NULL: - return (None, e) - bs = msg - return (bs, e) - - -def bus_poll_timed_wrapped(bus : int, timeout : float, clock_id : int) -> tuple: - ''' - Wait for a message to be broadcasted on the bus. - The caller should make a copy of the received message, - without freeing the original copy, and parse it in a - separate thread. When the new thread has started be - started, the caller of this function should then - either call `bus_poll_timed_wrapped` again or - `bus_poll_stop_wrapped`. - - @param bus:int Bus information - @param timeout:float The time the function shall fail with `os.errno.EAGAIN`, - if it has not already completed - @param clock_id:int The clock `timeout` is measured in, it must be a - predictable clock - @return :bytes The received message, `None` on error - @return :int The value of `errno` - ''' - cdef const char* msg - cdef bytes bs - cdef timespec_t timeout_spec - timeout_spec.tv_sec = int(timeout) - timeout_spec.tv_nsec = int((timeout - int(timeout)) * 1000000000) - msg = bus_poll_timed(bus, &timeout_spec, clock_id) - e = errno - if msg is NULL: - return (None, e) - bs = msg - return (bs, e) - - -def bus_chown_wrapped(file : str, owner : int, group : int) -> tuple: - ''' - Change the ownership of a bus - - `os.stat` can be used of the bus's associated file to get the bus's ownership - - @param file:str The pathname of the bus - @param owner:int The user ID of the bus's new owner - @param group:int The group ID of the bus's new group - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - cdef const char* cfile - cdef bytes bs - bs = file.encode('utf-8') + bytes([0]) - cfile = bs - r = bus_chown(cfile, owner, group) - e = errno - return (r, e) - - -def bus_chmod_wrapped(file : str, mode : int) -> tuple: - ''' - Change the permissions for a bus - - `os.stat` can be used of the bus's associated file to get the bus's permissions - - @param file:str The pathname of the bus - @param mode:int The permissions of the bus, any permission for a user implies - full permissions for that user, except only the owner may - edit the bus's associated file - @return :int 0 on success, -1 on error - @return :int The value of `errno` - ''' - cdef const char* cfile - cdef bytes bs - bs = file.encode('utf-8') + bytes([0]) - cfile = bs - r = bus_chmod(cfile, mode) - e = errno - return (r, e) - -- cgit v1.2.3-70-g09d2