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.
Software is getting more modular and building good software requires passing data and triggering events between internal services and external SaaS services, such as email delivery, communications, payment, delivery, and more.
These SaaS services allow us to build software quickly, prototype, iterate, and reduce our development cycle. Many of these services offer out of the box integrations which in theory allow us to 'plug' them into our product or into each other.
However, integrating multiple services is complicated and there are many hidden limitations - especially when some of them are asynchronous and integration requires many different tasks based on different event triggers. This requires orchestration or building a workflow.
The orchestration of services and business logic is the core of the product we are building. Because this orchestration is so crucial to your product, it is important to have full control over the logic and easily understand and make updates. So…Zenaton has created a new way to orchestrate these tasks that can be done just using code (!)
Zenaton offers a simple syntax that is easy to learn and can be combined to create infinite possibilities. When you consider the dashboard monitoring and error handling capabilities, it is the equivalent of having super powers. 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
require 'zenaton' class MyTask < Zenaton::Interfaces::Task include Zenaton::Traits::Zenatonable def initialize(...) # initialize properties end def handle # task implementation end end
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
require 'zenaton' class MyWorkflow < Zenaton::Interfaces::Workflow include Zenaton::Traits::Zenatonable def initialize(...) # initialize properties end def handle # workflow implementation end end
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:
require './tasks/task_a' require './tasks/task_b' require './tasks/task_c' require './tasks/task_d' # :nodoc: class SequentialWorkflow < Zenaton::Interfaces::Workflow include Zenaton::Traits::Zenatonable def handle a = TaskA.new.execute if a > 0 TaskB.new.execute else TaskC.new.execute end TaskD.new.execute end end