Zenaton is a backend service for implementing and running data and business processes into your software whether it is a background task or a long running workflow. Zenaton makes it easy to integrate external services and APIs into your app - and trigger a sequence of actions in your code based on events - or a lack of response - from APIs and other data sources.
Instead of building and managing infrastructure to watch and manage background scripts and jobs, Zenaton allows you just write the business logic of your processes into your code, install the Zenaton agent on your servers and the Zenaton workflow engine handles the complex calculations and queuing. The agent on your workers will listen to a queuing system hosted for you by Zenaton, and when a task should be executed, the Agent will launch it and collect the output to send back to your Zenaton dashboard.
We provide a sophisticated backend engine to manage the orchestration of tasks by managing the queues and pushing the decisions down to your workers. And it's easy to scale up quickly just by adding more workers.
In addition, the Zenaton dashboard offers real-time monitoring for all of your tasks and workflows.
We provide a sophisticated backend engine to manage the orchestration of tasks by managing the queues and pushing the decisions down to your workers. To scale up quickly, just add more workers.
We built Zenaton to give one developer the power and control of an entire team of software developers to manage sophisticated business and data processes.
Let's be honest. Building and managing infrastructure to manage background jobs is a pain. It includes spinning up a special server to manage the queuing system, managing states in a database, and then writing cron jobs and a lot of logic in your code. All of this infrastructure must be maintained, and there is very little visibility into how things are running. So when something goes wrong you have to read log files and check lots of places to figure out the problem and fix it.
With Zenaton, you can write the business logic for your tasks or workflows directly into your code in an easily readable format so that anyone on the team can understand the logic, troubleshoot and make changes.
We have made it easy to manage all of your background processes without having to worry about... well, everything.
Here is how it works:
When running background processes with Zenaton you can either write a single task or a write a sequence of related tasks within a workflow.
Tasks are the basic building blocks of Zenaton. Tasks are where you code perform your actual work and there is no limitation on what you can do there. Processing of tasks is offloaded onto one of your servers (called a worker then), but usually different from the one from which they were dispatched.
A few examples of tasks:
Using Zenaton library, writing a task is as simple as
from zenaton.abstracts.task import Task from zenaton.traits.zenatonable import Zenatonable class MyTask(Task, Zenatonable): def __init__(self, ...): # initialize properties def handle(self): # Your task implementation
Once Zenaton configured, dispatching a task to be processed on one of your workers is as easy as
Workflows are a set of tasks intended to be processed in a specific order, despite the fact that each of them can have been processed on different machines. Things you can do with a workflow:
Implementing worklows implies dealing with (notoriously difficult) distributed systems, where you have to deal with:
With Zenaton, writing such sequences is very easy. Whatever the complexity of your case, we handle all of the complexity for you:
Using Zenaton library, writing a workflow is as simple as
from zenaton.abstracts.workflow import Workflow from zenaton.traits.zenatonable import Zenatonable class MyWorkflow(Workflow, Zenatonable): def __init__(self, ...): # initialize properties def handle(self): # Your workflow implementation
Once Zenaton configured, dispatching a workflow to be processed on your workers is as easy as
With Zenaton, implementing a workflow is very easy as we use our prefered language. For example:
def handle(self): a = TaskA().execute() if a > 0: b = TaskB(a).execute() else: b = TaskC(a).execute() TaskD(b).execute()