Leiningen Repositories

This section provides comprehensive documentation for configuring and using Leiningen with CloudRepo Maven repositories.

Overview

Leiningen is the traditional and most widely-adopted build automation tool for Clojure projects. Created in 2009, it remains the preferred choice for many Clojure developers and teams, offering a comprehensive solution for project management, dependency resolution, and build automation.

What is Leiningen?

Leiningen is a build automation and dependency management tool that:

Manages Dependencies: Fetches and manages JVM libraries from Maven repositories
Builds Projects: Compiles Clojure code and creates JAR artifacts
Runs Tasks: Executes tests, starts REPLs, and runs custom tasks
Generates Projects: Provides templates for creating new projects
Handles Deployment: Publishes libraries to Maven repositories

Leiningen uses a project.clj file written in Clojure syntax to define project configuration, making it familiar and intuitive for Clojure developers.

Leiningen vs deps.edn

Choosing Between Leiningen and deps.edn
Aspect	Leiningen	deps.edn / tools.deps
Use Case	Full-featured builds, traditional projects	Minimal tooling, modern CLI approach
Configuration	project.clj (Clojure syntax)	deps.edn (EDN data)
Build Features	Comprehensive built-in tasks	Requires additional tools
Plugin Ecosystem	Extensive plugin system	Tool-based extensions
Learning Curve	Steeper but more features	Minimal, focused on dependencies
JAR Creation	Built-in uberjar support	Requires tools.build
Templates	Rich template system	Limited templates

Note

Many teams use both tools: Leiningen for established projects and complex builds, deps.edn for new projects and library development. CloudRepo supports both approaches seamlessly.

Why Private Maven Repositories?

Teams using Leiningen need private Maven repositories to:

Share Internal Libraries: Distribute proprietary Clojure libraries within the organization
Control Dependencies: Ensure consistent, reliable access to third-party libraries
Maintain Privacy: Keep sensitive code and algorithms secure
Version Management: Control library versions across teams and projects
Reduce External Dependencies: Cache external libraries for reliability
Comply with Regulations: Meet data residency and security requirements

Prerequisites

Before configuring Leiningen with CloudRepo, ensure you have:

A CloudRepo Maven Repository

Create a Maven repository in the CloudRepo Admin Portal:
- Navigate to Repositories → Create Repository
- Select Maven as the repository type
- Note your repository URL: https://[organization-id].mycloudrepo.io/repositories/[repository-id]
See Creating a Repository for detailed instructions.
A Repository User

Create a dedicated user for repository access:
- Navigate to Users → Create User
- Assign appropriate permissions (read/write)
- Save the credentials securely
See Creating Users for detailed instructions.

Warning

For security reasons, the admin user cannot access repositories directly. Always create dedicated repository users.

Leiningen Installed

Install Leiningen following the official instructions:
Verify Leiningen Installation
```
lein --version
# Output: Leiningen 2.11.2 on Java 17.0.8 OpenJDK 64-Bit Server VM
```

Configuring project.clj

Repository Configuration

Configure CloudRepo repositories in your project.clj file for both fetching and deploying artifacts.

Basic Repository Setup

project.clj - Basic CloudRepo Configuration

(defproject com.example/my-library "0.1.0-SNAPSHOT"
  :description "A private Clojure library"
  :url "https://github.com/example/my-library"
  :license {:name "Proprietary"
            :url ""}

  :dependencies [[org.clojure/clojure "1.11.1"]
                 [com.example/internal-lib "1.2.3"]]

  ;; Repository for fetching dependencies
  :repositories [["cloudrepo" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                               :username :env/cloudrepo_username
                               :password :env/cloudrepo_password}]
                 ["central" {:url "https://repo1.maven.org/maven2/"
                            :snapshots false}]
                 ["clojars" {:url "https://clojars.org/repo/"}]]

  ;; Repository for deploying artifacts
  :deploy-repositories [["releases" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                                     :username :env/cloudrepo_username
                                     :password :env/cloudrepo_password
                                     :sign-releases false}]
                       ["snapshots" {:url "https://mycompany.mycloudrepo.io/repositories/maven-snapshots"
                                    :username :env/cloudrepo_username
                                    :password :env/cloudrepo_password
                                    :sign-releases false}]])

Advanced Repository Configuration

project.clj - Advanced Repository Features

(defproject com.example/advanced-library "2.0.0"
  :description "Advanced Leiningen configuration example"

  ;; Repository configuration with mirrors and policies
  :repositories [["cloudrepo" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                               :username :env/cloudrepo_username
                               :password :env/cloudrepo_password
                               :update :always  ; :daily, :always, or :never
                               :checksum :fail  ; :fail, :warn, or :ignore
                               :releases {:enabled true
                                         :update :daily}
                               :snapshots {:enabled false}}]

                 ;; Mirror configuration for Maven Central
                 ["cloudrepo-central" {:url "https://mycompany.mycloudrepo.io/repositories/maven-central-proxy"
                                      :username :env/cloudrepo_username
                                      :password :env/cloudrepo_password
                                      :mirror-of "central"
                                      :mirror-exclude "clojars"}]]

  ;; Separate repositories for different artifact types
  :deploy-repositories [["releases" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                                     :username :env/cloudrepo_username
                                     :password :env/cloudrepo_password}]
                       ["snapshots" {:url "https://mycompany.mycloudrepo.io/repositories/maven-snapshots"
                                    :username :env/cloudrepo_username
                                    :password :env/cloudrepo_password}]]

  ;; Repository authentication via GPG
  :signing {:gpg-key "your-gpg-key@example.com"})

Authentication Setup

Leiningen supports multiple authentication methods. Choose the most appropriate for your security requirements.

Environment Variables (Recommended)

The most secure approach uses environment variables to store credentials:

Setting Environment Variables - Linux/macOS

# Add to ~/.bashrc, ~/.zshrc, or equivalent
export CLOUDREPO_USERNAME="your-repository-user@example.com"
export CLOUDREPO_PASSWORD="your-secure-password"

# For temporary use
CLOUDREPO_USERNAME="user@example.com" CLOUDREPO_PASSWORD="pass" lein deploy

Setting Environment Variables - Windows PowerShell

# Set permanently (requires admin privileges)
[Environment]::SetEnvironmentVariable("CLOUDREPO_USERNAME", "your-repository-user@example.com", "User")
[Environment]::SetEnvironmentVariable("CLOUDREPO_PASSWORD", "your-secure-password", "User")

# Set for current session
$env:CLOUDREPO_USERNAME = "your-repository-user@example.com"
$env:CLOUDREPO_PASSWORD = "your-secure-password"

Profiles Configuration (~/.lein/profiles.clj)

Store credentials in your Leiningen profiles for user-specific configuration:

~/.lein/profiles.clj - User Authentication

{:auth {:repository-auth {#"https://mycompany\.mycloudrepo\.io/.*"
                          {:username "your-repository-user@example.com"
                           :password "your-secure-password"}}}}

;; Alternative: Separate profiles for different environments
{:dev {:repository-auth {#"https://mycompany\.mycloudrepo\.io/.*"
                        {:username "dev-user@example.com"
                         :password "dev-password"}}}

 :prod {:repository-auth {#"https://mycompany\.mycloudrepo\.io/.*"
                         {:username "prod-user@example.com"
                          :password "prod-password"}}}}

Warning

The profiles.clj file contains plaintext passwords. Ensure proper file permissions: chmod 600 ~/.lein/profiles.clj

GPG Encrypted Credentials

For enhanced security, use GPG to encrypt credentials:

~/.lein/profiles.clj - GPG Encrypted Credentials

{:auth {:repository-auth {#"https://mycompany\.mycloudrepo\.io/.*"
                          {:username "your-repository-user@example.com"
                           :password [:gpg :env/cloudrepo_password_gpg]}}}}

Creating GPG Encrypted Password

# Encrypt password
echo -n "your-password" | gpg --armor --encrypt -r your-gpg-key@example.com > password.gpg

# Set as environment variable
export CLOUDREPO_PASSWORD_GPG=$(cat password.gpg)

Publishing Clojure Libraries

Basic Deployment

Deploy your Clojure library to CloudRepo using Leiningen’s deploy command:

Basic Library Deployment

# Deploy a release version
lein deploy releases

# Deploy a snapshot version
lein deploy snapshots

# Deploy to default repository (based on version)
lein deploy

Version Management

Leiningen automatically determines the target repository based on version:

project.clj - Version-based Deployment

;; SNAPSHOT version - deploys to snapshots repository
(defproject com.example/my-lib "1.0.0-SNAPSHOT"
  ;; ... configuration ...
  )

;; Release version - deploys to releases repository
(defproject com.example/my-lib "1.0.0"
  ;; ... configuration ...
  )

Artifact Generation

Leiningen generates multiple artifacts during deployment:

Generated Artifacts

# Standard JAR with compiled Clojure code
my-library-1.0.0.jar

# POM file with project metadata
my-library-1.0.0.pom

# Sources JAR (optional)
my-library-1.0.0-sources.jar

# Javadoc JAR (optional)
my-library-1.0.0-javadoc.jar

Configure additional artifacts in project.clj:

project.clj - Artifact Configuration

(defproject com.example/my-library "1.0.0"
  ;; Include source files
  :source-paths ["src"]
  :java-source-paths ["java-src"]

  ;; Generate additional artifacts
  :classifiers {:sources {:source-paths ["src"]
                         :resource-paths []}
                :javadoc {:source-paths []
                         :resource-paths []
                         :javadoc-opts {:package-names ["com.example"]
                                      :output-dir "target/javadoc"}}}

  ;; Include resources
  :resource-paths ["resources"]

  ;; AOT compilation for better performance
  :aot [com.example.my-library.core]

  ;; Metadata for POM
  :pom-addition [:developers [:developer
                              [:id "developer1"]
                              [:name "Jane Developer"]
                              [:email "jane@example.com"]]])

Deployment Workflow

Follow this workflow for reliable deployments:

Complete Deployment Workflow

# 1. Clean previous builds
lein clean

# 2. Run tests
lein test

# 3. Check for reflection warnings (Clojure best practice)
lein check

# 4. Generate JAR locally for verification
lein jar

# 5. Deploy to CloudRepo
lein deploy

# Alternative: All-in-one command
lein do clean, test, check, deploy

Consuming Dependencies

Adding Private Dependencies

Include CloudRepo-hosted libraries in your project:

project.clj - Using Private Dependencies

(defproject com.example/my-application "0.1.0"
  :dependencies [[org.clojure/clojure "1.11.1"]
                 ;; Public dependencies from Clojars/Maven Central
                 [ring/ring-core "1.10.0"]
                 [compojure "1.7.0"]

                 ;; Private dependencies from CloudRepo
                 [com.mycompany/auth-library "2.3.1"]
                 [com.mycompany/data-processor "1.5.0-SNAPSHOT"]
                 [com.mycompany/utils "3.0.0" :classifier "sources"]]

  :repositories [["cloudrepo" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                               :username :env/cloudrepo_username
                               :password :env/cloudrepo_password}]
                 ["cloudrepo-snapshots" {:url "https://mycompany.mycloudrepo.io/repositories/maven-snapshots"
                                        :username :env/cloudrepo_username
                                        :password :env/cloudrepo_password}]])

Dependency Resolution Order

Control how Leiningen resolves dependencies:

project.clj - Repository Priority

(defproject com.example/my-app "1.0.0"
  ;; Repositories are checked in order
  :repositories [;; 1. Check CloudRepo first for internal libraries
                 ["cloudrepo" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                              :username :env/cloudrepo_username
                              :password :env/cloudrepo_password}]

                 ;; 2. Then check Clojars for Clojure libraries
                 ["clojars" {:url "https://clojars.org/repo/"}]

                 ;; 3. Finally check Maven Central
                 ["central" {:url "https://repo1.maven.org/maven2/"
                            :snapshots false}]]

  ;; Disable automatic repository inclusion
  :omit-default-repositories true)

Repository Mirrors

Use CloudRepo as a proxy/mirror for external repositories:

project.clj - Repository Mirroring

(defproject com.example/my-app "1.0.0"
  :repositories [;; CloudRepo proxy for Maven Central
                 ["cloudrepo-central" {:url "https://mycompany.mycloudrepo.io/repositories/maven-central-proxy"
                                      :username :env/cloudrepo_username
                                      :password :env/cloudrepo_password
                                      :mirror-of "central"}]

                 ;; CloudRepo proxy for Clojars
                 ["cloudrepo-clojars" {:url "https://mycompany.mycloudrepo.io/repositories/clojars-proxy"
                                      :username :env/cloudrepo_username
                                      :password :env/cloudrepo_password
                                      :mirror-of "clojars"}]

                 ;; Direct CloudRepo repository
                 ["cloudrepo" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                              :username :env/cloudrepo_username
                              :password :env/cloudrepo_password}]])

Dependency Management

Advanced dependency management techniques:

project.clj - Dependency Management

(defproject com.example/my-app "1.0.0"
  :dependencies [[org.clojure/clojure "1.11.1"]

                 ;; Exclude transitive dependencies
                 [com.mycompany/lib-with-deps "1.0.0"
                  :exclusions [commons-logging
                              log4j]]

                 ;; Override transitive dependency versions
                 [com.mycompany/another-lib "2.0.0"]
                 [org.slf4j/slf4j-api "2.0.9"]] ; Override version

  ;; Global exclusions
  :exclusions [commons-logging
               commons-codec]

  ;; Dependency version management
  :managed-dependencies [[org.slf4j/slf4j-api "2.0.9"]
                        [org.clojure/data.json "2.4.0"]]

  ;; Pedantic mode for version conflicts
  :pedantic? :abort) ; :abort, :warn, or false

Advanced Leiningen Features

Profiles for Different Environments

Use profiles to manage environment-specific configurations:

project.clj - Environment Profiles

(defproject com.example/my-app "1.0.0"
  :description "Application with environment profiles"

  ;; Base configuration
  :dependencies [[org.clojure/clojure "1.11.1"]]

  :profiles {:dev {:dependencies [[ring/ring-mock "0.4.0"]
                                 [criterium "0.4.6"]]
                  :repositories [["cloudrepo-dev"
                                 {:url "https://mycompany.mycloudrepo.io/repositories/maven-dev"
                                  :username :env/cloudrepo_dev_username
                                  :password :env/cloudrepo_dev_password}]]
                  :resource-paths ["dev-resources"]
                  :jvm-opts ["-Dconf=dev-config.edn"]}

            :test {:dependencies [[test-runner "1.0.0"]]
                  :resource-paths ["test-resources"]}

            :staging {:repositories [["cloudrepo-staging"
                                     {:url "https://mycompany.mycloudrepo.io/repositories/maven-staging"
                                      :username :env/cloudrepo_staging_username
                                      :password :env/cloudrepo_staging_password}]]
                     :jvm-opts ["-Dconf=staging-config.edn"]}

            :production {:repositories [["cloudrepo-prod"
                                        {:url "https://mycompany.mycloudrepo.io/repositories/maven-prod"
                                         :username :env/cloudrepo_prod_username
                                         :password :env/cloudrepo_prod_password}]]
                        :jvm-opts ["-Dconf=prod-config.edn"
                                  "-Xmx2g"]
                        :aot :all}

            ;; Composite profile
            :dev-all [:dev :test]})

Using Profiles

# Activate dev profile
lein with-profile dev repl

# Run tests with test profile
lein with-profile test test

# Deploy with production profile
lein with-profile production deploy

# Combine profiles
lein with-profile dev,test deps

Plugins and Middleware

Extend Leiningen with plugins:

project.clj - Plugins Configuration

(defproject com.example/my-app "1.0.0"
  ;; Global plugins
  :plugins [[lein-ancient "1.0.0-RC3"]      ; Check for outdated dependencies
            [lein-cloverage "1.2.4"]         ; Code coverage
            [lein-kibit "0.1.8"]             ; Static code analysis
            [lein-bikeshed "0.5.2"]          ; Code style checking
            [lein-release "1.0.9"]]          ; Release automation

  ;; Plugin repositories (if needed)
  :plugin-repositories [["cloudrepo-plugins"
                        {:url "https://mycompany.mycloudrepo.io/repositories/maven-plugins"
                         :username :env/cloudrepo_username
                         :password :env/cloudrepo_password}]]

  ;; Plugin-specific configuration
  :cloverage {:output "target/coverage"
             :codecov? true
             :html? true}

  :release-tasks [["vcs" "assert-committed"]
                 ["change" "version" "leiningen.release/bump-version" "release"]
                 ["vcs" "commit"]
                 ["vcs" "tag" "--no-sign"]
                 ["deploy"]
                 ["change" "version" "leiningen.release/bump-version"]
                 ["vcs" "commit"]
                 ["vcs" "push"]])

Multi-Module Projects

Manage multi-module projects with lein-modules:

Parent project.clj - Multi-Module Configuration

(defproject com.example/parent-project "1.0.0"
  :description "Parent project for multi-module application"
  :plugins [[lein-modules "0.3.11"]]

  :modules {:versions {org.clojure/clojure "1.11.1"
                      com.example/shared-lib :version}

            :dirs ["modules/core"
                  "modules/api"
                  "modules/web"
                  "modules/shared"]

            :inherited {:repositories [["cloudrepo"
                                       {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                                        :username :env/cloudrepo_username
                                        :password :env/cloudrepo_password}]]

                       :deploy-repositories [["releases"
                                             {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                                              :username :env/cloudrepo_username
                                              :password :env/cloudrepo_password}]]

                       :license {:name "Proprietary"
                                :url ""}

                       :organization {:name "Example Corp"
                                    :url "https://example.com"}}

            :subprocess nil})

modules/core/project.clj - Child Module

(defproject com.example/core-module "1.0.0"
  :description "Core module"
  :dependencies [[org.clojure/clojure "_"]  ; Version from parent
                 [com.example/shared-lib "_"]])

Multi-Module Commands

# Install all modules
lein modules install

# Deploy all modules
lein modules deploy

# Run tests in all modules
lein modules test

# Run command in specific module
lein modules :dirs "modules/core" test

Uberjar Deployment

Deploy standalone executable JARs:

project.clj - Uberjar Configuration

(defproject com.example/standalone-app "1.0.0"
  :description "Standalone application"
  :dependencies [[org.clojure/clojure "1.11.1"]
                 [com.mycompany/internal-lib "2.0.0"]]

  :repositories [["cloudrepo" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                               :username :env/cloudrepo_username
                               :password :env/cloudrepo_password}]]

  :main com.example.standalone-app.core

  ;; Uberjar configuration
  :profiles {:uberjar {:aot :all
                      :jvm-opts ["-Dclojure.compiler.direct-linking=true"]
                      :uberjar-name "standalone-app.jar"
                      :omit-source true}}

  ;; Deploy uberjar to CloudRepo
  :deploy-repositories [["releases" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                                     :username :env/cloudrepo_username
                                     :password :env/cloudrepo_password}]]

  ;; Custom deployment for uberjar
  :classifiers {:standalone {:jar-name "standalone-app.jar"
                             :uberjar true}})

Building and Deploying Uberjars

# Build uberjar
lein uberjar

# Deploy regular JAR and uberjar
lein deploy releases

# Deploy only uberjar with classifier
lein deploy releases com.example/standalone-app "1.0.0" target/standalone-app.jar :classifier "standalone"

ClojureScript Projects

Configure Leiningen for ClojureScript projects:

project.clj - ClojureScript Configuration

(defproject com.example/cljs-app "1.0.0"
  :description "ClojureScript application"
  :dependencies [[org.clojure/clojure "1.11.1"]
                 [org.clojure/clojurescript "1.11.132"]
                 ;; Private ClojureScript libraries from CloudRepo
                 [com.mycompany/cljs-components "1.2.0"]]

  :repositories [["cloudrepo" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                               :username :env/cloudrepo_username
                               :password :env/cloudrepo_password}]]

  :plugins [[lein-cljsbuild "1.1.8"]
            [lein-figwheel "0.5.20"]]

  :cljsbuild {:builds [{:id "dev"
                       :source-paths ["src"]
                       :figwheel {:on-jsload "com.example.app/reload"}
                       :compiler {:main com.example.app
                                :asset-path "js/compiled/out"
                                :output-to "resources/public/js/compiled/app.js"
                                :output-dir "resources/public/js/compiled/out"
                                :source-map-timestamp true}}

                      {:id "prod"
                       :source-paths ["src"]
                       :compiler {:main com.example.app
                                :output-to "resources/public/js/compiled/app.js"
                                :optimizations :advanced
                                :pretty-print false}}]}

  ;; Deploy compiled JavaScript to CloudRepo Raw repository
  :deploy-repositories [["js-releases" {:url "https://mycompany.mycloudrepo.io/repositories/raw-releases"
                                        :username :env/cloudrepo_username
                                        :password :env/cloudrepo_password}]])

CI/CD Integration

GitHub Actions

Configure GitHub Actions for automated deployments:

.github/workflows/deploy.yml - GitHub Actions Configuration

name: Deploy to CloudRepo

on:
  push:
    branches: [ main ]
    tags: [ 'v*' ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Cache Leiningen dependencies
        uses: actions/cache@v3
        with:
          path: ~/.m2
          key: ${{ runner.os }}-m2-${{ hashFiles('**/project.clj') }}
          restore-keys: |
            ${{ runner.os }}-m2-

      - name: Install Leiningen
        run: |
          curl -O https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein
          chmod +x lein
          sudo mv lein /usr/local/bin/
          lein version

      - name: Run tests
        run: lein test

      - name: Check code quality
        run: |
          lein kibit
          lein bikeshed

  deploy:
    needs: test
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Install Leiningen
        run: |
          curl -O https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein
          chmod +x lein
          sudo mv lein /usr/local/bin/

      - name: Deploy to CloudRepo
        env:
          CLOUDREPO_USERNAME: ${{ secrets.CLOUDREPO_USERNAME }}
          CLOUDREPO_PASSWORD: ${{ secrets.CLOUDREPO_PASSWORD }}
        run: |
          lein deploy releases

GitLab CI

Configure GitLab CI for continuous deployment:

.gitlab-ci.yml - GitLab CI Configuration

image: clojure:temurin-17-lein-2.11.2

variables:
  MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository"

cache:
  paths:
    - .m2/repository/

stages:
  - test
  - deploy

test:
  stage: test
  script:
    - lein test
    - lein cloverage
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: target/coverage/cobertura.xml

deploy-snapshot:
  stage: deploy
  script:
    - lein deploy snapshots
  environment:
    name: development
  only:
    - develop
  variables:
    CLOUDREPO_USERNAME: ${CI_CLOUDREPO_USERNAME}
    CLOUDREPO_PASSWORD: ${CI_CLOUDREPO_PASSWORD}

deploy-release:
  stage: deploy
  script:
    - lein deploy releases
  environment:
    name: production
  only:
    - tags
  variables:
    CLOUDREPO_USERNAME: ${CI_CLOUDREPO_PROD_USERNAME}
    CLOUDREPO_PASSWORD: ${CI_CLOUDREPO_PROD_PASSWORD}

Jenkins Pipeline

Configure Jenkins for Leiningen deployments:

Jenkinsfile - Jenkins Pipeline Configuration

pipeline {
    agent any

    tools {
        jdk 'JDK-17'
    }

    environment {
        CLOUDREPO_USERNAME = credentials('cloudrepo-username')
        CLOUDREPO_PASSWORD = credentials('cloudrepo-password')
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Setup Leiningen') {
            steps {
                sh '''
                    if ! command -v lein &> /dev/null; then
                        curl -O https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein
                        chmod +x lein
                        sudo mv lein /usr/local/bin/
                    fi
                    lein version
                '''
            }
        }

        stage('Test') {
            steps {
                sh 'lein test'
                junit 'target/test-results/**/*.xml'
            }
        }

        stage('Code Quality') {
            parallel {
                stage('Coverage') {
                    steps {
                        sh 'lein cloverage'
                        publishHTML(target: [
                            reportDir: 'target/coverage',
                            reportFiles: 'index.html',
                            reportName: 'Coverage Report'
                        ])
                    }
                }
                stage('Static Analysis') {
                    steps {
                        sh 'lein kibit'
                        sh 'lein bikeshed'
                    }
                }
            }
        }

        stage('Deploy') {
            when {
                anyOf {
                    branch 'main'
                    tag pattern: "v\\d+\\.\\d+\\.\\d+", comparator: "REGEXP"
                }
            }
            steps {
                script {
                    if (env.TAG_NAME) {
                        sh 'lein deploy releases'
                    } else {
                        sh 'lein deploy snapshots'
                    }
                }
            }
        }
    }

    post {
        always {
            cleanWs()
        }
    }
}

CircleCI

Configure CircleCI for automated deployments:

.circleci/config.yml - CircleCI Configuration

version: 2.1

executors:
  clojure:
    docker:
      - image: cimg/clojure:1.11.1-openjdk-17.0
    environment:
      JVM_OPTS: -Xmx3200m

jobs:
  test:
    executor: clojure
    steps:
      - checkout
      - restore_cache:
          keys:
            - v1-dependencies-{{ checksum "project.clj" }}
            - v1-dependencies-

      - run:
          name: Install dependencies
          command: lein deps

      - save_cache:
          paths:
            - ~/.m2
          key: v1-dependencies-{{ checksum "project.clj" }}

      - run:
          name: Run tests
          command: lein test

      - store_test_results:
          path: target/test-results

  deploy:
    executor: clojure
    steps:
      - checkout
      - restore_cache:
          keys:
            - v1-dependencies-{{ checksum "project.clj" }}

      - run:
          name: Deploy to CloudRepo
          command: |
            if [ "${CIRCLE_TAG}" ]; then
              lein deploy releases
            else
              lein deploy snapshots
            fi

workflows:
  test-and-deploy:
    jobs:
      - test:
          filters:
            tags:
              only: /.*/
      - deploy:
          requires:
            - test
          filters:
            branches:
              only: main
            tags:
              only: /^v.*/
          context:
            - cloudrepo-credentials

Secure Credential Management

Best practices for managing CloudRepo credentials in CI/CD:

Use Secret Management Services

AWS Secrets Manager Example

# Retrieve credentials in CI/CD pipeline
export CLOUDREPO_USERNAME=$(aws secretsmanager get-secret-value \
  --secret-id cloudrepo/username \
  --query SecretString --output text)

export CLOUDREPO_PASSWORD=$(aws secretsmanager get-secret-value \
  --secret-id cloudrepo/password \
  --query SecretString --output text)

Rotate Credentials Regularly

project.clj - Multiple Credential Sets

(defproject com.example/my-app "1.0.0"
  :deploy-repositories [["releases"
                        {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                         :username :env/cloudrepo_username_v2
                         :password :env/cloudrepo_password_v2}]])

Use Service Accounts

Create dedicated CI/CD users with minimal permissions in CloudRepo Admin Portal.
Audit Access

Regularly review CloudRepo access logs and repository user permissions.

Troubleshooting

Common Issues and Solutions

Authentication Failures

Problem: 401 Unauthorized or 403 Forbidden errors

Debugging Authentication

# Verify environment variables
echo $CLOUDREPO_USERNAME
echo $CLOUDREPO_PASSWORD | wc -c  # Check password is set (don't echo it)

# Test with explicit credentials
lein deploy releases com.example/test "0.0.1" \
  target/test-0.0.1.jar \
  pom.xml \
  :repository [["test" {:url "https://mycompany.mycloudrepo.io/repositories/maven-releases"
                       :username "user@example.com"
                       :password "password"}]]

# Check profiles.clj
cat ~/.lein/profiles.clj

Solutions:

Verify credentials in CloudRepo Admin Portal
Ensure repository user has appropriate permissions
Check for typos in repository URLs
Confirm environment variables are exported correctly

Dependency Resolution Issues

Problem: Could not find artifact errors

Debugging Dependencies

;; Add verbose output to project.clj
(defproject com.example/debug "1.0.0"
  :dependencies [[com.mycompany/missing-lib "1.0.0"]]
  :repositories [["cloudrepo" {:url "..."
                               :update :always}]]  ; Force update
  ;; Enable debug output
  :jvm-opts ["-Dclojure.debug=true"])

Debug Commands

# Show dependency tree
lein deps :tree

# Force re-download
lein deps :force

# Check specific artifact
lein deps :why com.mycompany/missing-lib

# Clear local cache
rm -rf ~/.m2/repository/com/mycompany/missing-lib

SSL/TLS Certificate Issues

Problem: SSLHandshakeException or certificate errors

SSL Troubleshooting

# Test SSL connection
openssl s_client -connect mycompany.mycloudrepo.io:443 -showcerts

# Import CloudRepo certificate (if using self-signed)
keytool -import -trustcacerts \
  -keystore $JAVA_HOME/lib/security/cacerts \
  -storepass changeit \
  -alias cloudrepo \
  -file cloudrepo.crt

# Disable SSL verification (development only!)
export JVM_OPTS="-Dmaven.wagon.http.ssl.insecure=true -Dmaven.wagon.http.ssl.allowall=true"

Deployment Failures

Problem: Artifacts don’t appear in CloudRepo after deployment

Deployment Debugging

# Enable verbose logging
DEBUG=1 lein deploy releases

# Check local artifact generation
lein jar
ls -la target/

# Verify POM generation
lein pom
cat pom.xml

# Manual deployment test
mvn deploy:deploy-file \
  -DgroupId=com.example \
  -DartifactId=test \
  -Dversion=1.0.0 \
  -Dpackaging=jar \
  -Dfile=target/test-1.0.0.jar \
  -DrepositoryId=cloudrepo \
  -Durl=https://mycompany.mycloudrepo.io/repositories/maven-releases

Performance Optimization

Improve Leiningen performance with CloudRepo:

project.clj - Performance Optimizations

(defproject com.example/optimized "1.0.0"
  ;; Parallel dependency downloads
  :jvm-opts ["-Dmaven.artifact.threads=10"]

  ;; Local repository caching
  :local-repo ".m2"

  ;; Minimize repository checks
  :repositories [["cloudrepo" {:url "..."
                               :update :daily  ; Not :always
                               :checksum :warn}]]  ; Not :fail

  ;; Offline mode for CI builds
  :offline? false  ; Set to true when possible

  ;; Repository caching proxy
  :mirrors {#".*" {:name "cloudrepo-mirror"
                  :url "https://mycompany.mycloudrepo.io/repositories/all-proxy"}})

Best Practices

Version Management
- Use semantic versioning (MAJOR.MINOR.PATCH)
- Deploy SNAPSHOT versions during development
- Tag releases in version control
Security
- Never commit credentials to version control
- Use environment variables or encrypted storage
- Rotate credentials regularly
- Use separate credentials for different environments
Repository Organization
- Separate repositories for releases and snapshots
- Use repository groups for simplified configuration
- Implement retention policies for snapshots
Build Hygiene
- Always run tests before deployment
- Use lein clean to ensure fresh builds
- Version control your project.clj carefully
Documentation
- Document repository URLs and access requirements
- Maintain README files with setup instructions
- Include license and contributor information

Summary

This guide has covered comprehensive Leiningen integration with CloudRepo, including:

Basic Setup: Repository configuration and authentication
Publishing: Deploying Clojure libraries and applications
Consumption: Using private dependencies effectively
Advanced Features: Profiles, plugins, and multi-module projects
CI/CD: Automated deployments across major platforms
Troubleshooting: Common issues and solutions

Leiningen’s mature ecosystem and comprehensive feature set make it an excellent choice for teams building production Clojure applications. CloudRepo provides the secure, reliable Maven repository infrastructure needed to share and manage your Clojure artifacts effectively.

For teams also using the newer deps.edn tooling, see our Clojure deps.edn Repositories guide. Many organizations successfully use both tools, leveraging each for their respective strengths.