- bare functions (sync or async)
- static methods (sync or async)
- class-level methods (Python
@classmethod; in TypeScript, class-level handlers arestaticmethods) - instance methods (sync or async)
- Python
- TypeScript
- Rust
- Go
import asyncio
from abxbus import EventBus, BaseEvent
class WorkEvent(BaseEvent[str]):
task_id: str
def bare_sync(event: WorkEvent) -> str:
return f'bare-sync:{event.task_id}'
async def bare_async(event: WorkEvent) -> str:
await asyncio.sleep(0.01)
return f'bare-async:{event.task_id}'
class HandlerSet:
def __init__(self, prefix: str) -> None:
self.prefix = prefix
@staticmethod
def static_sync(event: WorkEvent) -> str:
return f'static-sync:{event.task_id}'
@staticmethod
async def static_async(event: WorkEvent) -> str:
await asyncio.sleep(0.01)
return f'static-async:{event.task_id}'
@classmethod
def class_sync(cls, event: WorkEvent) -> str:
return f'{cls.__name__}-class-sync:{event.task_id}'
@classmethod
async def class_async(cls, event: WorkEvent) -> str:
await asyncio.sleep(0.01)
return f'{cls.__name__}-class-async:{event.task_id}'
def instance_sync(self, event: WorkEvent) -> str:
return f'{self.prefix}-instance-sync:{event.task_id}'
async def instance_async(self, event: WorkEvent) -> str:
await asyncio.sleep(0.01)
return f'{self.prefix}-instance-async:{event.task_id}'
bus = EventBus('AppBus')
handlers = HandlerSet(prefix='svc')
bus.on(WorkEvent, bare_sync)
bus.on(WorkEvent, bare_async)
bus.on(WorkEvent, HandlerSet.static_sync)
bus.on(WorkEvent, HandlerSet.static_async)
bus.on(WorkEvent, HandlerSet.class_sync)
bus.on(WorkEvent, HandlerSet.class_async)
bus.on(WorkEvent, handlers.instance_sync)
bus.on(WorkEvent, handlers.instance_async)
import { BaseEvent, EventBus } from 'abxbus'
import { z } from 'zod'
const WorkEvent = BaseEvent.extend('WorkEvent', {
task_id: z.string(),
})
const bus = new EventBus('AppBus')
const bareSync = (event: InstanceType<typeof WorkEvent>) => `bare-sync:${event.task_id}`
const bareAsync = async (event: InstanceType<typeof WorkEvent>) => {
await new Promise((resolve) => setTimeout(resolve, 10))
return `bare-async:${event.task_id}`
}
class HandlerSet {
constructor(private prefix: string) {}
static staticSync(event: InstanceType<typeof WorkEvent>) {
return `static-sync:${event.task_id}`
}
static async staticAsync(event: InstanceType<typeof WorkEvent>) {
await new Promise((resolve) => setTimeout(resolve, 10))
return `static-async:${event.task_id}`
}
instanceSync(event: InstanceType<typeof WorkEvent>) {
return `${this.prefix}-instance-sync:${event.task_id}`
}
async instanceAsync(event: InstanceType<typeof WorkEvent>) {
await new Promise((resolve) => setTimeout(resolve, 10))
return `${this.prefix}-instance-async:${event.task_id}`
}
}
const handlers = new HandlerSet('svc')
bus.on(WorkEvent, bareSync)
bus.on(WorkEvent, bareAsync)
bus.on(WorkEvent, HandlerSet.staticSync)
bus.on(WorkEvent, HandlerSet.staticAsync)
bus.on(WorkEvent, handlers.instanceSync.bind(handlers))
bus.on(WorkEvent, handlers.instanceAsync.bind(handlers))
use abxbus::{
event,
event_bus::EventBus,
BaseEvent,
};
use futures_timer::Delay;
use std::time::Duration;
event! {
struct WorkEvent {
task_id: String,
event_result_type: String,
}
}
let bus = EventBus::new(Some("AppBus".to_string()));
bus.on(WorkEvent, |event: WorkEvent| async move {
Ok(format!("bare-sync:{}", event.task_id))
});
bus.on(WorkEvent, |event: WorkEvent| async move {
Delay::new(Duration::from_millis(10)).await;
Ok(format!("bare-async:{}", event.task_id))
});
struct HandlerSet {
prefix: String,
}
let handlers = HandlerSet {
prefix: "svc".to_string(),
};
bus.on(WorkEvent, move |event: WorkEvent| async move {
Ok(format!("{}-instance:{}", handlers.prefix, event.task_id))
});
package main
import (
"fmt"
"time"
abxbus "github.com/ArchiveBox/abxbus/abxbus-go"
)
func bareHandler(event *abxbus.BaseEvent) (any, error) {
return fmt.Sprintf("bare:%s", event.Payload["task_id"]), nil
}
type HandlerSet struct {
Prefix string
}
func StaticStyleHandler(event *abxbus.BaseEvent) (any, error) {
time.Sleep(10 * time.Millisecond)
return fmt.Sprintf("static:%s", event.Payload["task_id"]), nil
}
func (h *HandlerSet) InstanceHandler(event *abxbus.BaseEvent) (any, error) {
return fmt.Sprintf("%s-instance:%s", h.Prefix, event.Payload["task_id"]), nil
}
func main() {
bus := abxbus.NewEventBus("AppBus", nil)
handlers := &HandlerSet{Prefix: "svc"}
bus.On("WorkEvent", "bare_handler", bareHandler, nil)
bus.On("WorkEvent", "static_style_handler", StaticStyleHandler, nil)
bus.On("WorkEvent", "instance_handler", handlers.InstanceHandler, nil)
}