Reposilite Documentation

Reposilite provides several basic plugins maintained alongside the core project to extend its functionality. These include:

• example-plugin: A basic template for creating Reposilite plugins using Java and Gradle KTS.
• groovy-plugin: Enables the scripting API in Groovy, useful for rapid prototyping of scripts.
• javadoc-plugin: Serves -javadoc.jar files as Java documentation pages, accessible at /javadoc/<gav>.
• migration-plugin: Facilitates upgrading from Reposilite 2.x by converting the old tokens.dat file into the JSON schema used in Reposilite 3.x.
• swagger-plugin: Exposes a Swagger UI at the /swagger path for the built-in OpenAPI /openapi endpoint.

Shared configuration defines content that is consistent across all Reposilite instances, such as repositories and frontend customization.

By default, Reposilite stores shared configuration in a database and synchronizes state between instances every 10 seconds using an interval-based approach. This supports hot-reloading of properties.

To modify shared configuration via the web interface:

1. Log in to the dashboard with an access token that has management permission.
2. Navigate to the Settings tab.

Reposilite 3.x transitioned from Java (used in 1.x and 2.x) to Kotlin to improve the codebase in several ways:

• Consistency: Main sources, tests, and build scripts are fully written in Kotlin, eliminating the need for Groovy.
• Extensibility: By using Kotlin extension functions instead of static utility methods, the project can extend base objects (like those in the Javalin framework) more cleanly.
• Null Safety: Kotlin's language-level support for nullability allows for replacing Optional types with nullable types, reducing complexity.
• Functional Programming: Kotlin provides better syntax and standard library support for functional programming patterns.
• Modern Language Features: Improved generic type implementation and more robust standard library features compared to older JDK versions.

Each repository can be configured with its own specific backend settings:

• Storage Providers: You can assign different storage backends to different repositories. For example, one repository might use the local filesystem while another uses S3-compatible object storage.
• Mirrors: Reposilite can be configured to mirror (proxy) other external repositories. See the Mirrors Guide for detailed configuration instructions.

Repositories in Reposilite can have different visibility settings that control how they appear in the dashboard and how they are accessed:

• HIDDEN: The repository will not be visible in the Reposilite dashboard. However, artifacts can still be downloaded (e.g., via Gradle). To see a HIDDEN repository in the dashboard, you must use a valid access token.
• PRIVATE: Interaction with the repository (downloading, indexing, or deploying) is restricted. You must use a valid access token to interact with PRIVATE repositories.

Reposilite uses three distinct configuration layers to manage different types of settings:

1. Parameters: Startup configuration passed via program arguments (CLI flags).
2. Local configuration: Immutable, file-based configuration for a specific instance (e.g., hostname, port, database connection). It is stored in CDN format.
3. Settings (Shared configuration): Mutable state stored in a database that is shared across all Reposilite instances and supports hot-reloading.

Note: Reposilite will automatically generate configuration files during the first startup if it has write permissions to the disk.

Instead of using Optional<T> wrappers like in Java, Kotlin uses nullable types marked with a ?.

• Nullable Type: String? can hold a null value.
• Safe Call Operator (?.): Calls a method only if the receiver is not null; otherwise returns null.
• Elvis Operator (?:): Returns a default value if the preceding expression is null.

val value: String? = "text"

// Safe call and default value
val isEmpty = value
  ?.isEmpty() // returns null if value is null
  ?: true     // returns true if previous expression was null

When working with collections like Maps, accessing a missing key returns a nullable type:

val map = mapOf("key1" to "value1")

// handled is String?
val handled: String? = map["key1"]

// value is String (non-nullable) due to Elvis operator
val value: String = map["key2"] ?: "default"

Configuration modes determine how Reposilite handles the local configuration file using the CDN library. This is useful for managing updates when new properties are introduced.