How segurad/atlasmc works
Main “layers” or modules
• Atlas Common Modules – “atlas-common-api” and “atlas-common-core”
– These provide a basic API and core implementations used across the whole system. They include facilities for caching, chat, command parsing, event handling, registry management, scheduler functionality, configuration, and utilities.
• Master (Controller) Modules – “atlas-master-api” and “atlas-master-core”
– These modules manage the overall cluster. Components like AtlasMaster, Proxy/Server management, permission and profile handling, and node management reside here. The master node is responsible for coordinating and resource-handling across the network.
• Network Modules – “atlas-network-api”, “atlas-network-core-common”, “atlas-network-core-master”, and “atlas-network-core-minion”
– They encapsulate the communication protocols and network management. They define APIs and core classes to establish connectivity between Atlas nodes, deal with handshakes, and route packets (including protocol-specific message classes).
• Node Modules – “atlas-node-api”, “atlas-node-bootstrap”, and “atlas-node-core”
– These govern the individual server node’s behavior. In a cluster, each Atlas-Node runs internal “servers” (threads sharing one JVM) and is responsible for node-specific initialization, connection to the master node, and running the local instance of the game server.
• Other modules – such as atlas-packaging, atlas-shade-plugin, and atlas-test, which are used for building, shading (code transformation), and testing respectively.
• Documentation and Test Resources – “doc” and “testresources” directories hold configuration examples (for blocks, protocols, registries) and guidance.
Relationships and interactions
• The Common layer sits at the core. Both Master modules and Node modules depend on the common API/core libraries.
• The Master modules use the Network modules to communicate with the nodes. Also, Master modules provide the API layer (in atlas-master-api) that abstracts node management, server start/stop, and configuration distribution.
• The Network modules act as the intermediary for all network communications between master and node. They encapsulate protocol details (handshake, login, play, status) using Netty under the hood.
• The Node modules leverage the Network API and the common API to “bootstrap” servers, load plugins/contentpacks, and to report status and receive commands from the master.
• The design is modular and relies on dependency inversion where higher-level modules (like the master) depend on interfaces defined in the API modules that are implemented in their *-core counterparts.
• The layered separation means that external systems (e.g., plugins, configuration contentpacks) plug into the defined API and are managed by infrastructure modules such as the plugin manager and channel/command system (found in the common and core modules).
Important architectural patterns and design principles
• Layered Design: Common APIs at the core, with the Master and Node layers built atop them, and the Network layer encapsulating communications.
• Extension & Plugin Support: The architecture is designed for administrative and development flexibility allowing plugins (or “contentpacks”) and configurable behavior.
• Event-Driven & Protocol-Oriented Patterns: There is extensive event handling (see “event” packages) and protocol handling with dedicated packages for handshake, login, play, and status.
Final checklist
• Annotations or callouts for design principles such as “event-driven”, “extensibility”, “protocol integration”.