diff options
Diffstat (limited to 'python-atlas-engine-client.spec')
| -rw-r--r-- | python-atlas-engine-client.spec | 665 |
1 files changed, 665 insertions, 0 deletions
diff --git a/python-atlas-engine-client.spec b/python-atlas-engine-client.spec new file mode 100644 index 0000000..18f5458 --- /dev/null +++ b/python-atlas-engine-client.spec @@ -0,0 +1,665 @@ +%global _empty_manifest_terminate_build 0 +Name: python-atlas-engine-client +Version: 2.7.0 +Release: 1 +Summary: A Client for the workflow engine of the ProcessCube platform. +License: MIT License +URL: https://github.com/atlas-engine/Client.py +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/fa/4b/a3fc92a1bdf5adda785fb9fe5abc3805fffa0075e1438e1d014ad9f586b2/atlas_engine_client-2.7.0.tar.gz +BuildArch: noarch + +Requires: python3-aiohttp +Requires: python3-asyncio +Requires: python3-nest-asyncio +Requires: python3-dataclasses-json +Requires: python3-requests + +%description +# AtlasEngine mittels Python verwenden + +Wenn es darum geht mit Python Prozess zu starten bzw. zu kontrollieren, *External Task* zu verarbeiten +und Benutzer-Tasks auszuführen, dann ist der `AtlasEngine`-Client richtig. In dieser README +wird die Verwendung der unterschiedliche Aspekte anhand von Beispielen gezeigt: + +- [Vorbereitung der Umgebung](#vorbereitung-der-umgebung) +- [Prozess starten](#prozesss-starten) +- [*External Task* verarbeiten](#external-task-verarbeiten) +- TODO: *User Task* bearbeiten +- TODO: *Event* aus der Prozessengine verarbeiten + +Die Erweiterung der Client wird dagegen in [CONTRIBUTION.MD](CONTRIBUTION.MD) erklärt. + +# Vorbereitung der Umgebung + +## Installation des *BPMN-Studio* + +Die einfachster Version mit der Interaktion von Python und der Engine zu starten, +ist die Installation des *BPMN-Studio*, da es die Entwicklung von BPMN-Prozess unterstützt +und eine vorbereitete Engine mitbringt, die für die ersten Schritte ausreichend ist. + +### Prozess erstellen bzw. Beispiel verwenden + +Um den ersten Prozess nicht erstellen zu müssen, ist der Prozess *[Hello World](samples/bpmn_models/hello_world.bpmn)* +vorhanden, dieser muss in das *BPMN-Studio* geladen werden. + + + +### Prozess auf die Engine veröffentlichen + +Um den Prozess verwenden zu können, ist es notwendig, dass +dieser auf doe Engine veröffentlicht worden ist. Dazu ist es notwendig, den Prozess zu öffenen (1) und anschließend auf die Engine zu veröffentlichen (2). + + + +Nachdem der Prozess veröffenticht würde, kann er mittels Python gestartet werden. + + + +## Prozess starten + +Um einen Prozess zu startet ist die Prozess-Id (hier: `hello_world`) und die URL (hier: `http://localhost:56000`) unter der die Engine zu erreichen ist, notwendig. Nachdem die Informationen bekannt sind, kann der Prozess mit dem entsprechenden angepassten Script mit Hilfe von Python gestartet werden. + +### Beispiel mit nicht blockierendem Client + +```python +import logging + +from atlas_engine_client.process_model import ProcessModelClient + +logger = logging.getLogger(__name__) + +def main(engine_url): + client = ProcessModelClient(engine_url) + result = client.start_process_instance('hello_world') + + logger.info(f"Started process instance with result {result}") + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +### Beispiel mit blockierendem Client + +```python +import logging + +from atlas_engine_client.process_model import ProcessModelClient, StartCallbackType + +logger = logging.getLogger(__name__) + +def main(engine_url): + client = ProcessModelClient(engine_url) + result = client.start_process_instance('hello_world', + 'the_start_event', + 'the_end_event', + start_callback=StartCallbackType.ON_ENDEVENT_REACHED + ) + + logger.info(f"Started process instance with result {result}") + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +## *External Task* verarbeiten + +Im Beispiel-Prozess ist bereit eine ServiceTask als *External Task* konfiguriert. + +Für die Verwendung des *External Task* muss ein Topic (hier: `SampleExternalTask`) festgelegt werden und die URL der Engine (hier: `http://localhost:56000`) bekannt sein. +Nachdem die Informationen bekannt sind, kann der *External Task* mit dem angepassten Script abgearbeitet werden. + +Optionen für das Abonnieren von Aufträgen: +- max_tasks: Anzahl der Aufträge (task), die gleichzeitig verarbeitet werden sollen +- long_polling_timeout_in_ms: Timeout für das Abonnieren +- lock_duration_in_ms: Wir lange soll der Auftrag reseviert werden, bis er für weitere Worker zur Verfügung steht + +### Beispiel mit einem Parameter für den Handler *_handler* + +```python +import logging + +from atlas_engine_client.external_task import ExternalTaskClient + +logger = logging.getLogger(__name__) + +def _handler(payload): + logger.debug("so some work") + logger.debug(payload) + logger.debug("some worker done.") + + return {'some': 'result'} + +def main(engine_url): + client = ExternalTaskClient(engine_url) + + client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler, max_tasks=5) + + client.start() + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.INFO #logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +### Beispiel mit einem weiteren Parameter für den Handler *_handler* + +```python +import logging + +from atlas_engine_client.external_task import ExternalTaskClient + +logger = logging.getLogger(__name__) + +def _handler(payload, task): + logger.debug("so some work") + logger.info(f"payload: {payload} for task {task}") + logger.debug("some worker done.") + + return {'some': 'result'} + +def main(engine_url): + client = ExternalTaskClient(engine_url) + + client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler) + + client.start() + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.INFO #logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +## Mitmachen + +### Deployment auf pypi + +Abhängigkeiten installieren +```sh +python -m pip install twine +``` + +Quellenpaket erstellen +```sh +python setup.py sdist +```` + +Upload zu pypi +```sh +twine upload dist/* +```` + +Die Anmeldedaten für den Upload zu pypi stehen in 1Password im Tresor processengine. + + +%package -n python3-atlas-engine-client +Summary: A Client for the workflow engine of the ProcessCube platform. +Provides: python-atlas-engine-client +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-atlas-engine-client +# AtlasEngine mittels Python verwenden + +Wenn es darum geht mit Python Prozess zu starten bzw. zu kontrollieren, *External Task* zu verarbeiten +und Benutzer-Tasks auszuführen, dann ist der `AtlasEngine`-Client richtig. In dieser README +wird die Verwendung der unterschiedliche Aspekte anhand von Beispielen gezeigt: + +- [Vorbereitung der Umgebung](#vorbereitung-der-umgebung) +- [Prozess starten](#prozesss-starten) +- [*External Task* verarbeiten](#external-task-verarbeiten) +- TODO: *User Task* bearbeiten +- TODO: *Event* aus der Prozessengine verarbeiten + +Die Erweiterung der Client wird dagegen in [CONTRIBUTION.MD](CONTRIBUTION.MD) erklärt. + +# Vorbereitung der Umgebung + +## Installation des *BPMN-Studio* + +Die einfachster Version mit der Interaktion von Python und der Engine zu starten, +ist die Installation des *BPMN-Studio*, da es die Entwicklung von BPMN-Prozess unterstützt +und eine vorbereitete Engine mitbringt, die für die ersten Schritte ausreichend ist. + +### Prozess erstellen bzw. Beispiel verwenden + +Um den ersten Prozess nicht erstellen zu müssen, ist der Prozess *[Hello World](samples/bpmn_models/hello_world.bpmn)* +vorhanden, dieser muss in das *BPMN-Studio* geladen werden. + + + +### Prozess auf die Engine veröffentlichen + +Um den Prozess verwenden zu können, ist es notwendig, dass +dieser auf doe Engine veröffentlicht worden ist. Dazu ist es notwendig, den Prozess zu öffenen (1) und anschließend auf die Engine zu veröffentlichen (2). + + + +Nachdem der Prozess veröffenticht würde, kann er mittels Python gestartet werden. + + + +## Prozess starten + +Um einen Prozess zu startet ist die Prozess-Id (hier: `hello_world`) und die URL (hier: `http://localhost:56000`) unter der die Engine zu erreichen ist, notwendig. Nachdem die Informationen bekannt sind, kann der Prozess mit dem entsprechenden angepassten Script mit Hilfe von Python gestartet werden. + +### Beispiel mit nicht blockierendem Client + +```python +import logging + +from atlas_engine_client.process_model import ProcessModelClient + +logger = logging.getLogger(__name__) + +def main(engine_url): + client = ProcessModelClient(engine_url) + result = client.start_process_instance('hello_world') + + logger.info(f"Started process instance with result {result}") + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +### Beispiel mit blockierendem Client + +```python +import logging + +from atlas_engine_client.process_model import ProcessModelClient, StartCallbackType + +logger = logging.getLogger(__name__) + +def main(engine_url): + client = ProcessModelClient(engine_url) + result = client.start_process_instance('hello_world', + 'the_start_event', + 'the_end_event', + start_callback=StartCallbackType.ON_ENDEVENT_REACHED + ) + + logger.info(f"Started process instance with result {result}") + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +## *External Task* verarbeiten + +Im Beispiel-Prozess ist bereit eine ServiceTask als *External Task* konfiguriert. + +Für die Verwendung des *External Task* muss ein Topic (hier: `SampleExternalTask`) festgelegt werden und die URL der Engine (hier: `http://localhost:56000`) bekannt sein. +Nachdem die Informationen bekannt sind, kann der *External Task* mit dem angepassten Script abgearbeitet werden. + +Optionen für das Abonnieren von Aufträgen: +- max_tasks: Anzahl der Aufträge (task), die gleichzeitig verarbeitet werden sollen +- long_polling_timeout_in_ms: Timeout für das Abonnieren +- lock_duration_in_ms: Wir lange soll der Auftrag reseviert werden, bis er für weitere Worker zur Verfügung steht + +### Beispiel mit einem Parameter für den Handler *_handler* + +```python +import logging + +from atlas_engine_client.external_task import ExternalTaskClient + +logger = logging.getLogger(__name__) + +def _handler(payload): + logger.debug("so some work") + logger.debug(payload) + logger.debug("some worker done.") + + return {'some': 'result'} + +def main(engine_url): + client = ExternalTaskClient(engine_url) + + client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler, max_tasks=5) + + client.start() + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.INFO #logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +### Beispiel mit einem weiteren Parameter für den Handler *_handler* + +```python +import logging + +from atlas_engine_client.external_task import ExternalTaskClient + +logger = logging.getLogger(__name__) + +def _handler(payload, task): + logger.debug("so some work") + logger.info(f"payload: {payload} for task {task}") + logger.debug("some worker done.") + + return {'some': 'result'} + +def main(engine_url): + client = ExternalTaskClient(engine_url) + + client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler) + + client.start() + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.INFO #logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +## Mitmachen + +### Deployment auf pypi + +Abhängigkeiten installieren +```sh +python -m pip install twine +``` + +Quellenpaket erstellen +```sh +python setup.py sdist +```` + +Upload zu pypi +```sh +twine upload dist/* +```` + +Die Anmeldedaten für den Upload zu pypi stehen in 1Password im Tresor processengine. + + +%package help +Summary: Development documents and examples for atlas-engine-client +Provides: python3-atlas-engine-client-doc +%description help +# AtlasEngine mittels Python verwenden + +Wenn es darum geht mit Python Prozess zu starten bzw. zu kontrollieren, *External Task* zu verarbeiten +und Benutzer-Tasks auszuführen, dann ist der `AtlasEngine`-Client richtig. In dieser README +wird die Verwendung der unterschiedliche Aspekte anhand von Beispielen gezeigt: + +- [Vorbereitung der Umgebung](#vorbereitung-der-umgebung) +- [Prozess starten](#prozesss-starten) +- [*External Task* verarbeiten](#external-task-verarbeiten) +- TODO: *User Task* bearbeiten +- TODO: *Event* aus der Prozessengine verarbeiten + +Die Erweiterung der Client wird dagegen in [CONTRIBUTION.MD](CONTRIBUTION.MD) erklärt. + +# Vorbereitung der Umgebung + +## Installation des *BPMN-Studio* + +Die einfachster Version mit der Interaktion von Python und der Engine zu starten, +ist die Installation des *BPMN-Studio*, da es die Entwicklung von BPMN-Prozess unterstützt +und eine vorbereitete Engine mitbringt, die für die ersten Schritte ausreichend ist. + +### Prozess erstellen bzw. Beispiel verwenden + +Um den ersten Prozess nicht erstellen zu müssen, ist der Prozess *[Hello World](samples/bpmn_models/hello_world.bpmn)* +vorhanden, dieser muss in das *BPMN-Studio* geladen werden. + + + +### Prozess auf die Engine veröffentlichen + +Um den Prozess verwenden zu können, ist es notwendig, dass +dieser auf doe Engine veröffentlicht worden ist. Dazu ist es notwendig, den Prozess zu öffenen (1) und anschließend auf die Engine zu veröffentlichen (2). + + + +Nachdem der Prozess veröffenticht würde, kann er mittels Python gestartet werden. + + + +## Prozess starten + +Um einen Prozess zu startet ist die Prozess-Id (hier: `hello_world`) und die URL (hier: `http://localhost:56000`) unter der die Engine zu erreichen ist, notwendig. Nachdem die Informationen bekannt sind, kann der Prozess mit dem entsprechenden angepassten Script mit Hilfe von Python gestartet werden. + +### Beispiel mit nicht blockierendem Client + +```python +import logging + +from atlas_engine_client.process_model import ProcessModelClient + +logger = logging.getLogger(__name__) + +def main(engine_url): + client = ProcessModelClient(engine_url) + result = client.start_process_instance('hello_world') + + logger.info(f"Started process instance with result {result}") + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +### Beispiel mit blockierendem Client + +```python +import logging + +from atlas_engine_client.process_model import ProcessModelClient, StartCallbackType + +logger = logging.getLogger(__name__) + +def main(engine_url): + client = ProcessModelClient(engine_url) + result = client.start_process_instance('hello_world', + 'the_start_event', + 'the_end_event', + start_callback=StartCallbackType.ON_ENDEVENT_REACHED + ) + + logger.info(f"Started process instance with result {result}") + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +## *External Task* verarbeiten + +Im Beispiel-Prozess ist bereit eine ServiceTask als *External Task* konfiguriert. + +Für die Verwendung des *External Task* muss ein Topic (hier: `SampleExternalTask`) festgelegt werden und die URL der Engine (hier: `http://localhost:56000`) bekannt sein. +Nachdem die Informationen bekannt sind, kann der *External Task* mit dem angepassten Script abgearbeitet werden. + +Optionen für das Abonnieren von Aufträgen: +- max_tasks: Anzahl der Aufträge (task), die gleichzeitig verarbeitet werden sollen +- long_polling_timeout_in_ms: Timeout für das Abonnieren +- lock_duration_in_ms: Wir lange soll der Auftrag reseviert werden, bis er für weitere Worker zur Verfügung steht + +### Beispiel mit einem Parameter für den Handler *_handler* + +```python +import logging + +from atlas_engine_client.external_task import ExternalTaskClient + +logger = logging.getLogger(__name__) + +def _handler(payload): + logger.debug("so some work") + logger.debug(payload) + logger.debug("some worker done.") + + return {'some': 'result'} + +def main(engine_url): + client = ExternalTaskClient(engine_url) + + client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler, max_tasks=5) + + client.start() + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.INFO #logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +### Beispiel mit einem weiteren Parameter für den Handler *_handler* + +```python +import logging + +from atlas_engine_client.external_task import ExternalTaskClient + +logger = logging.getLogger(__name__) + +def _handler(payload, task): + logger.debug("so some work") + logger.info(f"payload: {payload} for task {task}") + logger.debug("some worker done.") + + return {'some': 'result'} + +def main(engine_url): + client = ExternalTaskClient(engine_url) + + client.subscribe_to_external_task_for_topic("SampleExternalTask", _handler) + + client.start() + +if __name__ == '__main__': + engine_url = 'http://localhost:56000' + + format_template = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' + level = logging.INFO #logging.DEBUG + logging.basicConfig(level=level, format=format_template) + + main(engine_url) +``` + +## Mitmachen + +### Deployment auf pypi + +Abhängigkeiten installieren +```sh +python -m pip install twine +``` + +Quellenpaket erstellen +```sh +python setup.py sdist +```` + +Upload zu pypi +```sh +twine upload dist/* +```` + +Die Anmeldedaten für den Upload zu pypi stehen in 1Password im Tresor processengine. + + +%prep +%autosetup -n atlas-engine-client-2.7.0 + +%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-atlas-engine-client -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 2.7.0-1 +- Package Spec generated |