leo-project/leofs

LeoFS is a distributed object storage system composed of three core components: a manager for cluster coordination, a gateway for S3 and HTTP/NFS access, and storage nodes for data persistence. The system supports multi-datacenter replication, rack awareness, and various storage backends. It provides comprehensive monitoring via SNMP and Prometheus metrics, and includes extensive testing infrastructure for integration, benchmarking, and reliability verification.

14 changes.

This period focused on standardizing the build and release infrastructure for LeoFS components, migrating configuration to Cuttlefish/INI formats, and creating packaging scripts for SmartOS and Windows. The work established a consistent release structure, including service definitions, startup scripts, and benchmarking tools for the manager, storage, and gateway nodes.

29 changes.

This period focused on standardizing the deployment and operational tooling for LeoFS components, introducing shell scripts and systemd units for reliable service management. It also established comprehensive monitoring capabilities via SNMP and Prometheus-compatible metrics, alongside extensive test coverage for core storage and gateway functionalities.

8 changes.

This period focused on establishing automated build and release pipelines for LeoFS across multiple Linux distributions, including Ubuntu 14.04, 16.04, 18.04, and CentOS 6 and 7. Additionally, the team introduced Docker-based environments to support comprehensive integration testing, covering rack awareness, client SDKs, and NFS functionality.

A new Dockerfile and associated shell scripts have been added to automate the building, installation, and release of LeoFS RPM packages for CentOS 7. The Dockerfile configures the build environment with necessary dependencies, Erlang, and GitHub's \hub\ CLI. The \run\_container\_for\_packaging.sh\ script orchestrates the Docker container to execute \run\_packaging.sh\, which builds the RPM, installs it, starts the LeoFS services via systemd, and uploads the resulting package as a GitHub release asset.

Dockerfiles/leofs-package-centos7 · high confidence

This change introduces the core configuration and service files for the LeoFS Manager, specifically tailored for SmartOS packaging. It adds \leo\_manager.conf.master\ and \leo\_manager.conf.slave\ to define settings for master and slave manager modes, including logging paths, Mnesia directories, RPC ports, and cluster IDs. It also includes \leo\_manager.xml\ for the SmartOS service manifest, \leo\_manager\_snmp.config\ for SNMP agent settings, and a \start\ script to launch the Erlang emulator. These files provide the necessary defaults and service definitions to run the manager component on SmartOS.

_pkg/leo\manager/files · high confidence

A new Dockerfile and supporting scripts have been added to build the Leofs project and its test suite (leofs\_test2) within a single container. The build process clones the Leofs repository, compiles it, and installs s3cmd for integration testing. The container exposes ports 22, 8080, 10010-10021 and runs the Leofs integration tests, providing a self-contained environment for testing Leofs functionality.

Dockerfiles/leofs-all-in-one · high confidence

The LeoManager now exposes system health metrics via SNMP for Prometheus scraping. New configuration files (\leo\_manager\_snmp.yml\) define OIDs and metric mappings for node name, process counts, and memory usage (1m and 5m means). This enables external monitoring tools to collect performance data from the manager node.

_apps/leo\manager/priv · high confidence

Added SNMP MIB files and agent configuration files for the Leo Gateway and Leo Manager components. The new files define the LEO-GATEWAY and LEO-MANAGER MIBs, exposing metrics such as node name, process counts, memory usage, and request statistics. Configuration files for the SNMP agent are also included to enable monitoring via SNMPv1 and SNMPv2 protocols.

_apps/leo\_gateway/snmp, apps/leo\manager/snmp · high confidence

New files have been added to automate the building and packaging of LeoFS for Ubuntu 16.04. The Dockerfile sets up a build environment with Erlang 19.3 and required dependencies, while shell scripts handle the packaging process, including installing the generated .deb package, starting LeoFS services via systemd, and uploading the release asset to GitHub.

Dockerfiles/leofs-package-ubuntu16.04 · high confidence

The storage component now ships with a default configuration file (leo\_storage.conf) and a test configuration (leo\_storage.conf.test) that define settings for SASL logging, manager nodes, object containers, and watchdogs. Additionally, an SNMP configuration file (leo\_storage\_snmp.yml) is added to expose storage metrics for Prometheus monitoring.

_apps/leo\storage/priv · high confidence

The Leo Manager and TCP Server components now include new header files (\leo\_manager.hrl\ and \tcp\_server.hrl\) that define constants, command mappings, and record structures. This introduces support for new management commands such as \import-user\, \reset-delete-bucket-stats\, and \recover-disk\, while also establishing default timeout and interval settings for the manager and TCP server listeners.

_apps/leo\manager/include · high confidence

New systemd unit files are provided for the Erlang Port Mapper Daemon (epmd), gateway, master and slave management nodes, and storage nodes. The epmd service now uses socket activation via a dedicated socket unit, and each component is configured to start after the network is online, ensuring reliable boot ordering and automatic restart on failure.

rel/service · high confidence

A new Dockerfile and packaging script have been added to automate the build and release process for LeoFS on CentOS 6. The Dockerfile installs build dependencies, Erlang 19.3, and GitHub's 'hub' CLI tool. The accompanying shell script automates the RPM build, installs the resulting package, starts the LeoFS services (manager, storage, gateway), and uploads the generated RPM as a GitHub release asset.

Dockerfiles/leofs-package-centos6 · high confidence

The LeoFS storage nodes now expose SNMP metrics for monitoring. Each storage node (0-4) is configured with a unique UDP port (4010-4014) and exposes a MIB (LEO-STORAGE) containing object store metrics (active/total objects), request counts (reads/writes/deletes over 1 and 5 minute intervals), and Erlang VM statistics (process count, memory usage). This enables external monitoring systems to collect storage health and performance data via SNMP.

_apps/leo\storage/snmp · high confidence

Introduced new configuration and service files for the LeoFS Gateway on SmartOS. This includes a comprehensive \leo\_gateway.conf\ with default settings for HTTP/HTTPS, caching, and watchdogs; a Solaris service manifest (\leo\_gateway.xml\) defining start, stop, and restart methods; SNMP configuration files for two gateway instances; and a startup script (\start\) to launch the Erlang emulator. These files enable the Gateway to be installed and managed as a native service on SmartOS.

_pkg/leo\_gateway/files, pkg/leo\storage/files · high confidence

A new Dockerfile and packaging script have been added to automate the building and release of LeoFS packages for Ubuntu 14.04. This includes the necessary build dependencies, Erlang 19.3, and a script that handles the full release workflow: building the .deb package, installing it, starting the LeoFS services, and uploading the release asset to GitHub.

Dockerfiles/leofs-package-ubuntu14.04 · high confidence

New files have been added to automate the building and release of LeoFS packages for Ubuntu 18.04. This includes a Dockerfile that sets up the build environment with Erlang 20.3 and necessary dependencies, along with shell scripts to run the container, execute the packaging process, and upload the resulting .deb file as a GitHub release asset.

Dockerfiles/leofs-package-ubuntu18.04 · high confidence

The release package now includes Windows-specific startup and service management scripts (erl, leo\_gateway.cmd, start\_erl.cmd) to support running the LeoFS Gateway as a Windows service. The entry also adds a default SASL logging configuration (sys.config) and Erlang VM arguments (vm.args) that define process limits and network settings for the gateway.

_rel/leo\gateway/files · high confidence

The LeoFS Gateway now ships with a default configuration file (leo\_gateway.conf) that defines settings for SASL logging, manager nodes, HTTP/NFS protocols, caching, and large object handling. A corresponding schema file (leo\_gateway.schema) is added to validate these configuration parameters. Additionally, an SNMP exporter configuration (leo\_gateway\_snmp.yml) is introduced to expose gateway metrics for Prometheus monitoring, and test configuration files for Nginx are added to support integration testing.

_apps/leo\gateway/priv · high confidence

The leo\_gateway service is now deployable via a new shell script at pkg/leo\_gateway/deploy/sbin/leo\_gateway, which handles starting, stopping, restarting, and attaching to the gateway node. A .gitignore file was also added to exclude the leo\_gateway binary from version control.

_pkg/leo\gateway/deploy · high confidence

The leo\_storage package now includes a deployment directory containing a .gitignore file and an executable sbin/leo\_storage script. This script manages the lifecycle of the leo\_storage node, providing start, stop, restart, reboot, ping, attach, and console commands to control the Erlang runtime environment.

_pkg/leo\storage/deploy · high confidence

The leo\_manager package now includes a new deploy directory containing a shell script (sbin/leo\_manager) that handles starting, stopping, restarting, and attaching to the Leo Manager node. The script manages the Erlang runtime, configures node names and cookies, and supports console and clean console modes. A .gitignore file was also added to exclude generated or local files from version control.

_pkg/leo\manager/deploy · high confidence

The leofs-mon utility now supports generating configuration files for monitoring LeoFS nodes (storage, gateway, and manager) using InfluxDB, Telegraf, and Grafana. This includes new template files in the \priv/mon/template\ and \priv/mon/template\_12\ directories, which provide the necessary Grafana dashboard JSON and Telegraf configuration templates. The \leofs-mon\ script has been updated to handle the \-schema12\ flag, allowing users to generate monitoring configurations compatible with the new schema version.

priv/mon · high confidence

The LeoFS gateway is now packaged for installation on SmartOS systems. This change introduces the necessary build and installation scripts (Makefile, install.sh, deinstall.sh) that handle user and group creation, directory setup, and service registration, ensuring the gateway installs and runs correctly on the target platform.

_pkg/leo\gateway · high confidence

New files have been added to the pkg/leo\_manager directory to support packaging and installation of the LeoFS manager. This includes a Makefile for building the package, install and deinstall scripts that handle user/group creation and service registration, and configuration file templates. The install script ensures the 'leofs' user and group exist, creates necessary directories under /var/db/leofs and /var/log/leofs, and imports a Solaris service definition. The Makefile defines the build process, copying components and setting up the package structure.

_pkg/leo\manager · high confidence

New files have been added to the \pkg/leo\_storage\ directory to support building and installing the LeoFS storage component. This includes a Makefile for the build process, shell scripts for installation and deinstallation that handle user and group creation, and metadata files (comment, description, displayfile) that define the package's identity and configuration.

_pkg/leo\storage · high confidence

The LeoFS storage node is now packaged with a complete set of release files, including an Erlang script (erl) and Windows batch scripts (leo\_storage.cmd, start\_erl.cmd) to manage the node as a Windows service, alongside configuration files (app.config, sys.config, vm.args) that define runtime settings, logging, and process limits.

_rel/leo\storage/files · high confidence

The repository is initialized with the core build and release infrastructure, including a Makefile for compiling and packaging the LeoFS components (manager, storage, gateway) using Rebar. A bootstrap script is added to automate the setup of test environments (integration, watchdog, cache, etc.), and a multi-data-center (MDCR) test environment script is included. The release process is supported by a leofs.mk file defining the version (1.4.4) and a comprehensive CHANGELOG.md documenting the 1.4.4 release, which adds support for Erlang/OTP 22.3 and removes the savanna\_agent library. Additionally, the repository includes standard documentation files (LICENSE, CODE\_OF\_CONDUCT, THANKS) and a mkdocs.yml configuration for the project's documentation site.

(repo-wide) · high confidence

Added the complete set of release files for the LeoFS Gateway, including the main runner script (leo\_gateway), the Erlang wrapper (erl), the Windows service script (leo\_gateway.cmd), the node tool (nodetool), SSL certificates, and configuration files (app.config, sys.config, vm.args). These files define how the gateway is built, started, stopped, and managed, supporting both Unix and Windows deployment environments.

_apps/leo\gateway/rel · high confidence

Added release packaging files for the LeoFS Manager, including the reltool configuration, overlay templates, and startup scripts (erl, leo\_manager, nodetool, start\_erl.cmd) to support the new cuttlefish-based configuration system.

_apps/leo\manager/rel · high confidence

The LeoFS storage node is initialized with version 1.4.4, defining constants, records, and API modules for object, directory, and sync handling. The application start-up sequence ensures managers are alive before launching object storage, MQ servers, and directory deletion handlers, addressing slow startup issues. The directory deletion handler manages pending deletion states and caches items for periodic processing. Object handling includes get, put, delete, and head operations with access logging. Sync handler compares and synchronizes metadata between remote clusters. The MQ module manages message queues for replication, rebalancing, and recovery. The cluster monitor checks node status and resource levels.

_apps/leo\storage/src · high confidence

The \leo\_gateway.hrl\ and \leo\_http.hrl\ header files were created to centralize gateway and HTTP-related constants, macros, and type definitions. This includes HTTP method and header definitions, error codes and messages, cache and large object configuration defaults, and protocol handler mappings. This consolidation supports the gateway's HTTP and S3 API handling by providing a single source of truth for these values.

_apps/leo\gateway/include · high confidence

The release structure for the storage node is updated to support configuration via the cuttlefish library, replacing the previous app.config with a new app.config and a leo\_storage.conf schema. This change introduces new shell and Windows batch scripts (erl, leo\_storage, leo\_storage.cmd, start\_erl.cmd) and a nodetool utility to manage the node lifecycle (start, stop, restart, attach, ping) and perform remote procedure calls. The reltool configuration is also updated to include these new files and dependencies, enabling a more flexible, INI-style configuration format for the storage component.

_apps/leo\storage/rel · high confidence

The launch scripts now support loading environment variables and configuration from /etc/leofs/ and additional .environment files, allowing administrators to override default paths, set the RUNNER\_USER, and configure open file limits without modifying the main launch script. This change enables running multiple node instances and improves security by defaulting to the 'leofs' user, while also supporting extra config files in the node's .d directory.

rel/common · high confidence

The Leo Gateway application now supports building against Erlang/OTP versions 19, 20, 21, and 22, as specified in the updated \rebar.config\ and the \replace\_otp\_vsn.sh\ script. This change updates the build system to recognize and compile against these newer Erlang/OTP releases, ensuring compatibility with modern runtime environments.

_apps/leo\gateway · high confidence

The LeoFS Gateway has migrated its configuration system from the previous format to an INI-style configuration managed by Cuttlefish. This change is reflected in the new \rel/leo\_gateway/vars.config\ file, which explicitly notes the move to the Cuttlefish-based configuration, and the \reltool.config.in\ file which sets up the build environment for this new structure, including copying the \leo\_gateway.conf\ and schema files to the release directory.

_rel/leo\gateway · high confidence

The LeoFS Gateway application has been updated to version 1.5.0. This release includes a comprehensive set of bug fixes addressing various issues (such as range request handling, access logging, and error responses) and introduces new capabilities including memory threshold configuration, support for getting and setting object ACLs, and improved compatibility with AWS S3 headers and content-type handling.

_apps/leo\gateway/src · medium confidence

The LeoFS Manager's runtime environment is updated with new startup scripts (erl, leo\_manager.cmd, start\_erl.cmd) and configuration files (app.config, sys.config, vm.args). This introduces support for multi-TCP ports, replication attributes, system-version variables, and an INI-file based configuration approach using basho/cuttlefish, alongside SASL logging adjustments.

_rel/leo\manager/files · medium confidence

The release tooling for the LeoFS Manager has been updated to version 0.16.5. This includes a new reltool configuration that defines the manager's runtime dependencies, overlay files, and startup scripts. The configuration also incorporates SNMP-related files for both manager instances and adds support for Prometheus metrics via a new YAML configuration file.

_rel/leo\manager · medium confidence

The build system for the LeoFS Storage node has been updated to use an INI-style configuration file managed by Cuttlefish, replacing the previous \vars.config\ and \reltool.config.in\ setup. This change simplifies the configuration process by moving to a more standard INI format, which is now handled by the \cuttlefish\ library. Users will find the storage node's configuration files in the \etc/\ directory, with the main configuration file named \leo\_storage.conf\.

_rel/leo\storage · high confidence

The leo\_storage component has been updated to support Erlang/OTP versions 19, 20, 21, and 22. This is achieved by updating the \rebar.config\ to specify the new OTP version range and adjusting the build scripts to facilitate building with these newer Erlang/OTP releases.

_apps/leo\storage · high confidence

The LeoManager application has been updated to version 1.4.4. This release includes 28 bug fixes addressing various issues within the manager component, such as fixing the delete-bucket functionality, resolving multi-datacenter replication problems, and correcting output formatting for status commands.

_apps/leo\manager/src · high confidence

Add Docker-based test environments for CI; Add S3 authentication and integrity testing to the Leofs benchmark driver; Added EUnit tests for LeoFS storage components; Added MDCR test configuration files for LeoFS components; Added benchmarking configuration files and S3 auth header definitions for testing; Added configuration files for the HTTP cache test suite; Added configuration files for the rack-awareness integration test; Added integration tests for bucket deletion scenarios; Added leofs-ls-bench test tool; Added unit and integration tests for Leo Gateway; Added unit tests for Leo Manager Mnesia storage.

The Leo Manager application has been updated with new versions of its core dependencies, including leo\_object\_storage 1.3.41, leo\_redundant\_manager 1.9.67, leo\_logger 1.3.9, leo\_commons 1.2.2, leo\_statistics 1.1.25, and leo\_s3\_libs 1.2.23. Additionally, the build system now supports Erlang/OTP versions 19, 20, 21, and 22, and includes a new conditional build with the sd\_notify library.

_apps/leo\manager · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 41 → 39 (-2.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 90 → 89 (-1.4)
• Architecture 100 → 100 (+0.0)
• Maturity 51 → 68 (+16.4)
• Readiness 25 → 39 (+13.9)
• Security 49 → 23 (-25.9)
• Event-Driven 79 → 79 (+0.0)
• Event Sourcing 49 → 49 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High IaC: DS-0015 (Dockerfiles/leofs-package-centos7/Dockerfile)
• High IaC: DS-0029 (Dockerfiles/leofs-package-ubuntu18.04/Dockerfile)
• Low IaC: DS-0005 (Dockerfiles/leofs-all-in-one/Dockerfile)
• Medium IaC: CKV2_DOCKER_1 (Dockerfiles/leofs-build-deps/Dockerfile)
• Medium IaC: CKV2_DOCKER_1 (Dockerfiles/leofs-package-centos6/Dockerfile)
• Medium IaC: CKV2_DOCKER_1 (Dockerfiles/leofs-package-centos7/Dockerfile)
• Medium IaC: CKV_DOCKER_1 (Dockerfiles/leofs-all-in-one/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-all-in-one/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-build-deps/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-package-centos6/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-package-centos7/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-package-ubuntu14.04/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-package-ubuntu16.04/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-package-ubuntu18.04/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (Dockerfiles/leofs-release/Dockerfile)
• Medium IaC: CKV_DOCKER_4 (Dockerfiles/leofs-all-in-one/Dockerfile)
• Medium IaC: CKV_DOCKER_4 (Dockerfiles/leofs-all-in-one/Dockerfile)
• Medium IaC: CKV_DOCKER_4 (Dockerfiles/leofs-package-centos6/Dockerfile)
• …and 14 more

• Coverage not measured — no coverage collector is wired up
• Dependency hygiene PARTLY measured — rebar3 pinning read, dependency currency not (no rebar.lock-pinned Hex declaration to grade)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (apps/leo_manager/src/leo_manager_formatter_json.erl)
• Duplicated block (10 lines × 2) (apps/leo_manager/src/leo_manager_formatter_text.erl)
• Duplicated block (10–14 lines × 2) (apps/leo_manager/src/leo_manager_mq_client.erl)
• Duplicated block (11 lines × 2) (apps/leo_manager/src/leo_manager_formatter_text.erl)
• Duplicated block (12–13 lines × 2) (apps/leo_manager/src/leo_manager_formatter_json.erl)
• Duplicated block (14–16 lines × 2) (apps/leo_manager/src/leo_manager_formatter_json.erl)
• Duplicated block (15–16 lines × 2) (apps/leo_gateway/src/leo_gateway_app.erl)
• Duplicated block (16 lines × 2) (apps/leo_manager/src/leo_manager_formatter_json.erl)
• Duplicated block (17 lines × 2) (apps/leo_manager/src/leo_manager_mnesia.erl)
• Duplicated block (5 lines × 2) (apps/leo_gateway/src/leo_gateway_s3_api.erl)
• Duplicated block (5 lines × 2) (apps/leo_manager/src/leo_manager_formatter_text.erl)
• Duplicated block (5 lines × 2) (apps/leo_manager/src/leo_manager_formatter_text.erl)
• Duplicated block (5 lines × 3) (apps/leo_gateway/src/leo_gateway_app.erl)
• Duplicated block (6 lines × 3) (apps/leo_manager/src/leo_manager_formatter_text.erl)
• Duplicated block (6–7 lines × 2) (apps/leo_manager/src/leo_manager_formatter_json.erl)
• Duplicated block (7 lines × 2) (apps/leo_gateway/src/leo_gateway_s3_api.erl)
• …and 105 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

leo-project/leofs was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.