This architecture proposal places a main server in the center that is responsible for:
Encapsulating data
Users, projects, repos, tickets, etc. are data objects
Handling business logic and user access control
Exposing an internal API
Probably served over Unix sockets
Allows atomic operations to be carried out on data objects
Allows subscribing to events
Connected to this server will be several front-ends:
Git SSH
Git HTTP
Web interface
Email
ActivityPub/Fediforge
RSS/Atom
Front ends will be responsible for doing user authentication in their own unique way, as logging on to a website with a password is fundamentally different from using an SSH key to clone a git repo or commanding mintea to do something over email. The central server will be in charge of denying users the ability to do things that they aren't permitted to do, but it will trust frontends to be honest about what user is performing what action.
For security reasons, all of these daemons should run on the same machine, but in the future we could explore exposing the API just enough to containerize each individual daemon and have them all connect with a secret key or something.
The frontends should probably be able to store arbitrary namespaced key/value information on data objects, or there should otherwise be some similar system. The rationale for this is: users ought to be able to do things like subscribe to emails about a particular thing via the web interface.
This architecture proposal places a main server in the center that is responsible for:
- Encapsulating data
- Users, projects, repos, tickets, etc. are data objects
- Handling business logic and user access control
- Exposing an internal API
- Probably served over Unix sockets
- Allows atomic operations to be carried out on data objects
- Allows subscribing to events
Connected to this server will be several front-ends:
- Git SSH
- Git HTTP
- Web interface
- Email
- ActivityPub/Fediforge
- RSS/Atom
Front ends will be responsible for doing user authentication in their own unique way, as logging on to a website with a password is fundamentally different from using an SSH key to clone a git repo or commanding mintea to do something over email. The central server will be in charge of denying users the ability to do things that they aren't permitted to do, but it will trust frontends to be honest about what user is performing what action.
For security reasons, all of these daemons should run on the same machine, but in the future we could explore exposing the API just enough to containerize each individual daemon and have them all connect with a secret key or something.
The frontends should probably be able to store arbitrary namespaced key/value information on data objects, or there should otherwise be some similar system. The rationale for this is: users ought to be able to do things like subscribe to emails about a particular thing via the web interface.

_Originally posted by @sashakoshka in https://git.tebibyte.media/meta/mintee/issues/4#issue-684_
In order to evaulate the effectiveness of this architecture and to provide a base upon which to fully implement mintee, it may be worthwhile to create a prototype that only edits some very basic data object (like a list of text items).
In order to evaulate the effectiveness of this architecture and to provide a base upon which to fully implement mintee, it may be worthwhile to create a prototype that only edits some very basic data object (like a list of text items).
_Originally posted by @sashakoshka in https://git.tebibyte.media/meta/mintee/issues/4#issuecomment-5047_
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
This architecture proposal places a main server in the center that is responsible for:
Connected to this server will be several front-ends:
Front ends will be responsible for doing user authentication in their own unique way, as logging on to a website with a password is fundamentally different from using an SSH key to clone a git repo or commanding mintea to do something over email. The central server will be in charge of denying users the ability to do things that they aren't permitted to do, but it will trust frontends to be honest about what user is performing what action.
For security reasons, all of these daemons should run on the same machine, but in the future we could explore exposing the API just enough to containerize each individual daemon and have them all connect with a secret key or something.
The frontends should probably be able to store arbitrary namespaced key/value information on data objects, or there should otherwise be some similar system. The rationale for this is: users ought to be able to do things like subscribe to emails about a particular thing via the web interface.
Originally posted by @sashakoshka in #4 (comment)
In order to evaulate the effectiveness of this architecture and to provide a base upon which to fully implement mintee, it may be worthwhile to create a prototype that only edits some very basic data object (like a list of text items).
Originally posted by @sashakoshka in #4 (comment)