https://github.com/PsychoLlama/wardens
A tiny framework for managing resources
https://github.com/PsychoLlama/wardens
framework hierarchy lifetimes managment resource
Last synced: 4 months ago
JSON representation
A tiny framework for managing resources
- Host: GitHub
- URL: https://github.com/PsychoLlama/wardens
- Owner: PsychoLlama
- License: mit
- Created: 2022-05-21T05:21:51.000Z (about 3 years ago)
- Default Branch: main
- Last Pushed: 2024-10-23T09:54:53.000Z (8 months ago)
- Last Synced: 2024-10-24T01:18:09.626Z (8 months ago)
- Topics: framework, hierarchy, lifetimes, managment, resource
- Language: TypeScript
- Homepage:
- Size: 1.25 MB
- Stars: 5
- Watchers: 3
- Forks: 2
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
Wardens
A tiny framework for managing resources.
## Overview
This library is designed for applications that dynamically provision and deallocate hierarchical resources over time.
Here's an example: let's say you've got a thread pool, one per CPU. Each thread gets a `Resource`, a small wrapper that hooks into setup and teardown controls.
```typescript
async function Worker() {
const thread = await spawn();
return {
// The value returned after initialization completes
value: thread,
// Called when the resource is destroyed
destroy: () => thread.close(),
};
}
```
Now define a pool that creates and manages workers:
```typescript
async function WorkerPool(
{ create }: ResourceScope,
config: { poolSize: number },
) {
const promises = Array(config.poolSize).fill(Worker).map(create);
const threads = await Promise.all(promises);
return {
// ... External API goes here ...
value: {
doSomeWork() {},
doSomethingElse() {},
},
};
}
```
Finally, create the pool:
```typescript
const pool = await create(WorkerPool, {
poolSize: cpus().length,
});
// Provisioned and ready to go!
pool.doSomeWork();
pool.doSomethingElse();
```
The magic of this framework is that resources never outlive their owners. If you tear down the pool, it will deallocate everything beneath it first:
```typescript
await destroy(pool);
// [info] closing worker
// [info] closing worker
// [info] closing worker
// [info] closing worker
// [info] closing pool
```
No more forgotten resources.
## Summary
The framework can be used to manage small pieces of stateful logic in your application, or it can scale to manage your entire server. Use the paradigm as much or as little as you like.
I built this for my own projects. Documentation is a bit sparse, but enough GitHub stars could change that. This is a bribe.