Update dependency sentry-sdk to v2.29.1

Update dependency sentry-sdk to v2.28.0

.dockerignore

@@ -1,4 +1,13 @@
-.github
-.travis.yml
+.git*
+*.md
 build*
-*.env
+docker-compose*
+env
+test-configuration
+.netbox/.git*
+.netbox/.pre-commit-config.yaml
+.netbox/.readthedocs.yaml
+.netbox/.tx
+.netbox/contrib
+.netbox/scripts
+.netbox/upgrade.sh

.editorconfig

@@ -0,0 +1,14 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 2
+
+[*.py]
+indent_size = 4
+
+[VERSION]
+insert_final_newline = false

.editorconfig-checker.json

@@ -0,0 +1,18 @@
+{
+  "Verbose": false,
+  "Debug": false,
+  "IgnoreDefaults": false,
+  "SpacesAfterTabs": false,
+  "NoColor": false,
+  "Exclude": ["LICENSE", "\\.initializers", "\\.vscode"],
+  "AllowedContentTypes": [],
+  "PassedFiles": [],
+  "Disable": {
+    "EndOfLine": false,
+    "Indentation": false,
+    "InsertFinalNewline": false,
+    "TrimTrailingWhitespace": false,
+    "IndentSize": true,
+    "MaxLineLength": false
+  }
+}

.flake8

@@ -0,0 +1,7 @@
+[flake8]
+max-line-length = 100
+extend-ignore = E203, W503
+per-file-ignores =
+  configuration/*:E131,E251,E266,E302,E305,E501,E722
+  startup_scripts/startup_script_utils/__init__.py:F401
+  docker/*:E266,E722

.github/FUNDING.yml

@@ -0,0 +1,14 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+  - cimnine
+  - tobiasge
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,147 @@
+name: Bug report
+description: Create a report about a malfunction of the Docker setup
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Please only raise an issue if you're certain that you've found a bug.
+        Else, see these other means to get help:
+
+        - See our troubleshooting section:
+          https://github.com/netbox-community/netbox-docker/wiki/Troubleshooting
+        - Have a look at the rest of the wiki:
+          https://github.com/netbox-community/netbox-docker/wiki
+        - Check the release notes:
+          https://github.com/netbox-community/netbox-docker/releases
+        - Look through the issues already resolved:
+          https://github.com/netbox-community/netbox-docker/issues?q=is%3Aclosed
+
+        If you did not find what you're looking for,
+        try the help of our community:
+
+        - Post to Github Discussions:
+          https://github.com/netbox-community/netbox-docker/discussions
+        - Join the `#netbox-docker` channel on our Slack:
+          https://join.slack.com/t/netdev-community/shared_invite/zt-mtts8g0n-Sm6Wutn62q_M4OdsaIycrQ
+        - Ask on the NetBox mailing list:
+          https://groups.google.com/d/forum/netbox-discuss
+
+        Please don't open an issue to open a PR.
+        Just submit the PR, that's good enough.
+  - type: textarea
+    id: current-behavior
+    attributes:
+      label: Current Behavior
+      description: Please describe what you did and how you think it misbehaved
+      placeholder: I tried to … by doing …, but it …
+    validations:
+      required: true
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected Behavior
+      description: Please describe what you expected instead
+      placeholder: I expected that … when I do …
+    validations:
+      required: true
+  - type: input
+    id: docker-compose-version
+    attributes:
+      label: Docker Compose Version
+      description: Please paste the output of `docker-compose version` (or `docker compose version`)
+      placeholder: Docker Compose version vX.Y.Z
+    validations:
+      required: true
+  - type: textarea
+    id: docker-version
+    attributes:
+      label: Docker Version
+      description: Please paste the output of `docker version`
+      render: text
+      placeholder: |
+        Client:
+        Cloud integration: 1.0.17
+        Version:           20.10.8
+        API version:       1.41
+        Go version:        go1.16.6
+        Git commit:        3967b7d
+        Built:             Fri Jul 30 19:55:20 2021
+        OS/Arch:           darwin/amd64
+        Context:           default
+        Experimental:      true
+
+        Server: Docker Engine - Community
+        Engine:
+          Version:          20.10.8
+          API version:      1.41 (minimum version 1.12)
+          Go version:       go1.16.6
+          Git commit:       75249d8
+          Built:            Fri Jul 30 19:52:10 2021
+          OS/Arch:          linux/amd64
+          Experimental:     false
+        containerd:
+          Version:          1.4.9
+          GitCommit:        e25210fe30a0a703442421b0f60afac609f950a3
+        runc:
+          Version:          1.0.1
+          GitCommit:        v1.0.1-0-g4144b63
+        docker-init:
+          Version:          0.19.0
+          GitCommit:        de40ad0
+    validations:
+      required: true
+  - type: input
+    id: git-rev
+    attributes:
+      label: The git Revision
+      description: Please paste the output of `git rev-parse HEAD`
+    validations:
+      required: true
+  - type: textarea
+    id: git-status
+    attributes:
+      label: The git Status
+      description: Please paste the output of `git status`
+      render: text
+      placeholder: |
+        On branch main
+        nothing to commit, working tree clean
+    validations:
+      required: true
+  - type: input
+    id: run-command
+    attributes:
+      label: Startup Command
+      description: Please specify the command you used to start the project
+      placeholder: docker compose up
+    validations:
+      required: true
+  - type: textarea
+    id: netbox-logs
+    attributes:
+      label: NetBox Logs
+      description: Please paste the output of `docker-compose logs netbox` (or `docker compose logs netbox`)
+      render: text
+      placeholder: |
+        netbox_1  | ⚙️ Applying database migrations
+        netbox_1  | 🧬 loaded config '/etc/netbox/config/configuration.py'
+        netbox_1  | 🧬 loaded config '/etc/netbox/config/a.py'
+        netbox_1  | 🧬 loaded config '/etc/netbox/config/extra.py'
+        netbox_1  | 🧬 loaded config '/etc/netbox/config/logging.py'
+        netbox_1  | 🧬 loaded config '/etc/netbox/config/plugins.py'
+        ...
+    validations:
+      required: true
+  - type: textarea
+    id: docker-compose-override-yml
+    attributes:
+      label: Content of docker-compose.override.yml
+      description: Please paste the output of `cat docker-compose.override.yml`
+      render: yaml
+      placeholder: |
+        services:
+          netbox:
+            ports:
+              - '8080:8080'
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,15 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Question
+    url: https://github.com/netbox-community/netbox-docker/discussions
+    about: The Github Discussions are the right place to ask questions about how to use or do certain things with NetBox Docker.
+
+  - name: Chat
+    url: https://join.slack.com/t/netdev-community/shared_invite/zt-mtts8g0n-Sm6Wutn62q_M4OdsaIycrQ
+    about: "Usually the quickest way to seek help with small issues is to join our #netbox-docker Slack channel."
+
+  - name: Community Wiki
+    url: https://github.com/netbox-community/netbox-docker/wiki
+    about: |
+      Our wiki contains information for common problems and tips for operating NetBox Docker in production.
+      It's maintained by our excellent community.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,68 @@
+name: Feature or Change Request
+description: Request a new feature or a change of the current behavior
+body:
+  - type: markdown
+    attributes:
+      value: |
+        This issue type is to propose new features for the Docker setup.
+        To just spin an idea, see the Github Discussions section, please.
+
+        Before asking for help, see these links first:
+
+        - See our troubleshooting section:
+          https://github.com/netbox-community/netbox-docker/wiki/Troubleshooting
+        - Have a look at the rest of the wiki:
+          https://github.com/netbox-community/netbox-docker/wiki
+        - Check the release notes:
+          https://github.com/netbox-community/netbox-docker/releases
+        - Look through the issues already resolved:
+          https://github.com/netbox-community/netbox-docker/issues?q=is%3Aclosed
+
+        If you did not find what you're looking for,
+        try the help of our community:
+
+        - Post to Github Discussions:
+          https://github.com/netbox-community/netbox-docker/discussions
+        - Join the `#netbox-docker` channel on our Slack:
+          https://join.slack.com/t/netdev-community/shared_invite/zt-mtts8g0n-Sm6Wutn62q_M4OdsaIycrQ
+        - Ask on the NetBox mailing list:
+          https://groups.google.com/d/forum/netbox-discuss
+
+        Please don't open an issue to open a PR.
+        Just submit the PR, that's good enough.
+  - type: textarea
+    id: desired-behavior
+    attributes:
+      label: Desired Behavior
+      description: Please describe the desired behavior
+      placeholder: To me, it would be useful, if … because …
+    validations:
+      required: true
+  - type: textarea
+    id: contrast-to-current
+    attributes:
+      label: Contrast to Current Behavior
+      description: Please describe how the desired behavior is different from the current behavior
+      placeholder: The current behavior is …, but this lacks …
+    validations:
+      required: true
+  - type: textarea
+    id: required-changes
+    attributes:
+      label: Required Changes
+      description: If you can, please elaborate what changes will be required to implement the desired behavior
+      placeholder: I suggest to change the file …
+    validations:
+      required: false
+  - type: textarea
+    id: discussion
+    attributes:
+      label: "Discussion: Benefits and Drawbacks"
+      description: |
+        Please make your case here:
+        - Why do you think this project and the community will benefit from your suggestion?
+        - What are the drawbacks of this change? Is it backwards-compatible?
+        - Anything else that you think is relevant to the discussion of this feature/change request.
+      placeholder: I suggest to change the file …
+    validations:
+      required: false

.github/issue_template.md

@@ -1,55 +0,0 @@
-<!--
-
-Before raising an issue here, answer the following questions for yourself, please:
-
-* Did you read through the troubleshooting section? (https://github.com/netbox-community/netbox-docker/#troubleshooting)
-* Have you updated to the latest version and tried again? (i.e. `git pull` and `docker-compose pull`)
-* Have you reset the project and tried again? (i.e. `docker-compose down -v`)
-* Are you confident that your problem is related to the Docker or Docker Compose setup this project provides?
-  (Otherwise ask on the Netbox mailing list, please: https://groups.google.com/d/forum/netbox-discuss)
-* Have you looked through the issues already resolved?
-
-Please try this means to get help before opening an issue here:
-
-* On the networktocode Slack in the #netbox-docker channel: http://slack.networktocode.com/
-* On the networktocode Slack in the #netbox channel: http://slack.networktocode.com/
-* On the Netbox mailing list: https://groups.google.com/d/forum/netbox-discuss
-
--->
-
-## Current Behavior
-
-<!-- describe what you did and how it misbehaved -->
-...
-
-## Expected Behavior
-
-<!-- describe what you expected instead -->
-...
-
-## Debug Information
-
-<!-- please fill in the following information that might helps us debug your problem more quickly -->
-The output of `docker-compose version`: `XXXXX`
-The output of `docker version`: `XXXXX`
-The output of `git rev-parse HEAD`: `XXXXX`
-The command you used to start the project: `XXXXX`
-
-The output of `docker-compose logs netbox`:
-<!--
-If your log is very long, create a Gist instead (and post the link to it): https://gist.github.com
--->
-
-```
-LOG LOG LOG
-```
-
-The output of `docker-compose logs nginx`:
-<!--
-Only if you have gotten a 5xx http error, else delete this section.
-If your log is very long, create a Gist instead (and post the link to it): https://gist.github.com
--->
-
-```
-LOG LOG LOG
-```

.github/no-response.yml

@@ -0,0 +1,10 @@
+# Configuration for probot-no-response - https://github.com/probot/no-response
+
+# Number of days of inactivity before an Issue is closed for lack of response
+daysUntilClose: 30
+# Label requiring a response
+responseRequiredLabel: awaiting answer
+# Comment to post when closing an Issue for lack of response. Set to `false` to disable
+closeComment: >
+  This issue has been automatically closed because there has been no response
+  to our request for more information from the original author.

.github/pull_request_template.md

@@ -0,0 +1,85 @@
+<!--
+#########################################################################
+
+Thank you for sharing your work and for opening a PR.
+
+(!) IMPORTANT (!):
+First make sure that you point your PR to the `develop` branch!
+
+Now please read the comments carefully and try to provide information
+on all relevant titles.
+
+#########################################################################
+-->
+
+<!--
+Please don't open an extra issue when submitting a PR.
+
+But if there is already a related issue, please put it's number here.
+
+E.g. #123 or N/A
+-->
+
+Related Issue:
+
+## New Behavior
+
+<!--
+Please describe in a few words the intentions of your PR.
+-->
+
+...
+
+## Contrast to Current Behavior
+
+<!--
+Please describe in a few words how the new behavior is different
+from the current behavior.
+-->
+
+...
+
+## Discussion: Benefits and Drawbacks
+
+<!--
+Please make your case here:
+
+- Why do you think this project and the community will benefit from your
+  proposed change?
+- What are the drawbacks of this change?
+- Is it backwards-compatible?
+- Anything else that you think is relevant to the discussion of this PR.
+
+(No need to write a huge article here. Just a few sentences that give some
+additional context about the motivations for the change.)
+-->
+
+...
+
+## Changes to the Wiki
+
+<!--
+If the README.md must be updated, please include the changes in the PR.
+If the Wiki must be updated, please make a suggestion below.
+-->
+
+...
+
+## Proposed Release Note Entry
+
+<!--
+Please provide a short summary of your PR that we can copy & paste
+into the release notes.
+-->
+
+...
+
+## Double Check
+
+<!--
+Please put an x into the brackets (like `[x]`) if you've completed that task.
+-->
+
+- [ ] I have read the comments and followed the PR template.
+- [ ] I have explained my PR according to the information in the comments.
+- [ ] My PR targets the `develop` branch.

.github/workflows/push.yml

@@ -0,0 +1,100 @@
+---
+name: push
+
+on:
+  push:
+    branches-ignore:
+      - release
+      - renovate/**
+  pull_request:
+    branches-ignore:
+      - release
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-24.04
+    name: Checks syntax of our code
+    permissions:
+      contents: read
+      packages: read
+      statuses: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Full git history is needed to get a proper
+          # list of changed files within `super-linter`
+          fetch-depth: 0
+      - name: Lint Code Base
+        uses: super-linter/super-linter@v7
+        env:
+          DEFAULT_BRANCH: develop
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SUPPRESS_POSSUM: true
+          LINTER_RULES_PATH: /
+          VALIDATE_ALL_CODEBASE: false
+          VALIDATE_CHECKOV: false
+          VALIDATE_DOCKERFILE: false
+          VALIDATE_GITLEAKS: false
+          VALIDATE_JSCPD: false
+          FILTER_REGEX_EXCLUDE: (.*/)?(LICENSE|configuration/.*)
+          EDITORCONFIG_FILE_NAME: .editorconfig-checker.json
+          DOCKERFILE_HADOLINT_FILE_NAME: .hadolint.yaml
+          MARKDOWN_CONFIG_FILE: .markdown-lint.yml
+          PYTHON_BLACK_CONFIG_FILE: pyproject.toml
+          PYTHON_FLAKE8_CONFIG_FILE: .flake8
+          PYTHON_ISORT_CONFIG_FILE: pyproject.toml
+          YAML_CONFIG_FILE: .yamllint.yaml
+  build:
+    continue-on-error: ${{ matrix.build_cmd != './build-latest.sh' }}
+    strategy:
+      matrix:
+        build_cmd:
+          - ./build-latest.sh
+          - PRERELEASE=true ./build-latest.sh
+          - ./build.sh feature
+          - ./build.sh main
+        os:
+          - ubuntu-24.04
+          - ubuntu-24.04-arm
+      fail-fast: false
+    env:
+      GH_ACTION: enable
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      IMAGE_NAMES: docker.io/netboxcommunity/netbox
+    runs-on: ${{ matrix.os }}
+    name: Builds new NetBox Docker Images
+    steps:
+      - id: git-checkout
+        name: Checkout
+        uses: actions/checkout@v4
+      - id: buildx-setup
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - id: arm-install-skopeo
+        name: Install 'skopeo' on ARM64
+        if: matrix.os == 'ubuntu-24.04-arm'
+        run: |
+          sudo apt-get install -y skopeo
+      - id: arm-buildx-platform
+        name: Set BUILDX_PLATFORM to ARM64
+        if: matrix.os == 'ubuntu-24.04-arm'
+        run: |
+          echo "BUILDX_PLATFORM=linux/arm64" >>"${GITHUB_ENV}"
+      - id: docker-build
+        name: Build the image for '${{ matrix.os }}' with '${{ matrix.build_cmd }}'
+        run: ${{ matrix.build_cmd }}
+        env:
+          BUILDX_BUILDER_NAME: ${{ steps.buildx-setup.outputs.name }}
+      - id: arm-time-limit
+        name: Set Netbox container start_period higher on ARM64
+        if: matrix.os == 'ubuntu-24.04-arm'
+        run: |
+          echo "NETBOX_START_PERIOD=240s" >>"${GITHUB_ENV}"
+      - id: docker-test
+        name: Test the image
+        run: IMAGE="${FINAL_DOCKER_TAG}" ./test.sh
+        if: steps.docker-build.outputs.skipped != 'true'

.github/workflows/release.yml

@@ -0,0 +1,88 @@
+---
+name: release
+
+on:
+  release:
+    types:
+      - published
+  schedule:
+    - cron: "45 5 * * *"
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        build:
+          - { "cmd": "./build-latest.sh", "branch": "release" }
+          - { "cmd": "./build.sh main", "branch": "release" }
+          # Build pre release images from our develop branch
+          # This is used to test the latest changes before they are merged into the main branch
+          - { "cmd": "PRERELEASE=true ./build-latest.sh", "branch": "develop" }
+          - { "cmd": "./build.sh feature", "branch": "develop" }
+        platform:
+          - linux/amd64,linux/arm64
+      fail-fast: false
+    runs-on: ubuntu-24.04
+    name: Builds new NetBox Docker Images
+    env:
+      GH_ACTION: enable
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      IMAGE_NAMES: docker.io/netboxcommunity/netbox quay.io/netboxcommunity/netbox ghcr.io/netbox-community/netbox
+    steps:
+      - id: source-checkout
+        name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ matrix.build.branch }}
+      - id: set-netbox-docker-version
+        name: Get Version of NetBox Docker
+        run: echo "version=$(cat VERSION)" >>"$GITHUB_OUTPUT"
+        shell: bash
+      - id: check-build-needed
+        name: Check if the build is needed for '${{ matrix.build.cmd }}'
+        env:
+          CHECK_ONLY: "true"
+        run: ${{ matrix.build.cmd }}
+      # docker.io
+      - id: docker-io-login
+        name: Login to docker.io
+        uses: docker/login-action@v3
+        with:
+          registry: docker.io
+          username: ${{ secrets.dockerhub_username }}
+          password: ${{ secrets.dockerhub_password }}
+        if: steps.check-build-needed.outputs.skipped != 'true'
+      - id: buildx-setup
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          version: "lab:latest"
+          driver: cloud
+          endpoint: "netboxcommunity/netbox-default"
+        if: steps.check-build-needed.outputs.skipped != 'true'
+      # quay.io
+      - id: quay-io-login
+        name: Login to Quay.io
+        uses: docker/login-action@v3
+        with:
+          registry: quay.io
+          username: ${{ secrets.quayio_username }}
+          password: ${{ secrets.quayio_password }}
+        if: steps.check-build-needed.outputs.skipped != 'true'
+      # ghcr.io
+      - id: ghcr-io-login
+        name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+        if: steps.check-build-needed.outputs.skipped != 'true'
+      - id: build-and-push
+        name: Push the image
+        run: ${{ matrix.build.cmd }} --push
+        if: steps.check-build-needed.outputs.skipped != 'true'
+        env:
+          BUILDX_PLATFORM: ${{ matrix.platform }}
+          BUILDX_BUILDER_NAME: ${{ steps.buildx-setup.outputs.name }}

.gitignore

@@ -1 +1,14 @@
 *.sql.gz
+.netbox
+.python-version
+docker-compose.override.yml
+*.pem
+configuration/*
+!configuration/configuration.py
+!configuration/extra.py
+configuration/ldap/*
+!configuration/ldap/extra.py
+!configuration/ldap/ldap_config.py
+!configuration/logging.py
+!configuration/plugins.py
+super-linter.log

.hadolint.yaml

@@ -0,0 +1,4 @@
+ignored:
+- DL3006
+- DL3008
+- DL3003

.markdown-lint.yml

@@ -0,0 +1,2 @@
+MD013: false
+MD041: false

.travis.yml

@@ -1,32 +0,0 @@
-sudo: required
-language: python
-
-env:
-  - BUILD=release
-  - BUILD=prerelease
-  - BUILD=branches
-  - BUILD=special
-
-git:
-  depth: 5
-
-services:
-  - docker
-
-install:
-  - docker-compose pull --parallel
-  - docker-compose build
-
-script:
-  - docker-compose run netbox ./manage.py test
-
-after_script:
-  - docker-compose down
-
-after_success:
-  - docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
-  - ./build-all.sh --push
-
-notifications:
-  slack:
-    secure: F3VsWcvU/XYyjGjU8ZAVGpREe7F1NjKq6LuMRzhQORbXUvanxDQtLzEe0Y5zm/6+gHkx6t8cX/v2PiCI+v46pkapYMUimd+QEOL1WxbUdnw2kQxcgw/R3wX34l2FHXbG3/a+TmH3euqbSCTIrPy9ufju948i+Q0E0u0fyInmozl8qOT23C4joQOpVAq7y+wHxTxsEg46ZzL2Ties+dmqjMsvHocv7mPI2IWzAWA8SJZxS82Amoapww++QjgEmoY+tMimLkdeXCRgeoj41UGHDg54rbEXh/PTaWiuzyzTr1WLmsGRScC57fDRivp3mSM37/MlNxsRj1z+j4zrvWFQgNfJ2yMjBHroc1jOX/uCY4dwbpSPqUCpc4idMGCGZFItgzTQ3lAPYAsom0C6n8C08Xk8EsNKWwXrDSd4ZUhIwptkNPCFK+kXbLFsMzSApnaBYW0T+wba57nZdiWjOPYmvJr49MDm5NHv2KaRBX2gpw7t7ZLhTgwGEWcZvcDebiLneXcXY5hZ7v2NHJkx/2x1yNXo85xZDy0wK1FGoOOHwPhvqOB+pcQZ/pUOSPTKqGw5l/CexoRm1shFsK+19FnSgimqTHjcuCo4lFW3JlEvlFhtfFXIte2Wjp1ALZgTrSq8zSD5rRxYCUKmM7b3EJwdaIgbvKWPdS4sCXlXU1bHx0g=

.yamllint.yaml

@@ -0,0 +1,4 @@
+---
+rules:
+  line-length:
+    max: 160

DOCKER_HUB.md

@@ -1,66 +0,0 @@
-# cloud.docker.com Configuration
-
-The automatic build is configured in cloud.docker.com.
-
-The following build configuration is expected:
-
-```yaml
-Source Repository: github.com/netbox-community/netbox-docker
-Build Location: Build on Docker Hub's infrastructure
-Autotest: Internal and External Pull Requests
-Repository Links: Enable for Base Image
-Build Rules:
-- Source Type: Branch
-  Source: master
-  Docker Tag: branches-main
-  Dockerfile location: Dockerfile
-- Source Type: Branch
-  Source: master
-  Docker Tag: branches-ldap
-  Dockerfile location: Dockerfile.ldap
-- Source Type: Branch
-  Source: master
-  Docker Tag: prerelease-main
-  Dockerfile location: Dockerfile
-- Source Type: Branch
-  Source: master
-  Docker Tag: prerelease-ldap
-  Dockerfile location: Dockerfile.ldap
-- Source Type: Branch
-  Source: master
-  Docker Tag: release-main
-  Dockerfile location: Dockerfile
-- Source Type: Branch
-  Source: master
-  Docker Tag: release-ldap
-  Dockerfile location: Dockerfile.ldap
-Build Environment Variables:
-# Create an app on Github and use it's OATH credentials here
-- Key: GITHUB_OAUTH_CLIENT_ID
-  Value: <secret>
-- Key: GITHUB_OAUTH_CLIENT_SECRET
-  Value: <secret>
-Build Triggers:
-- Name: Cron Trigger
-# Use this trigger in combination with e.g. https://cron-job.org in order to regularly schedule builds
-```
-
-## Background Knowledge
-
-The build system of cloud.docker.com is not made for this kind of project.
-But we found a way to make it work, and this is how:
-
-1. The docker hub build system [allows to overwrite the scripts that get executed
-   for `build`, `test` and `push`](overwrite). See `hooks/*`.
-2. Shared functionality of the scripts `build`, `test` and `push` is extracted to `hooks/common`.
-3. The `build` script runs `run_build()` from `hooks/common`.
-   This triggers either `build-branches.sh`, `build-latest.sh` or directly `build.sh`.
-4. The `test` script just invokes `docker-compose` commands.
-5. The `push` script runs `run_build()` from `hooks/common` with a `--push-only` flag.
-   This causes the `build.sh` script to not re-build the Docker image, but just the just built image.
-
-The _Docker Tag_ configuration setting is misused to select the type (_release_, _prerelease_, _branches_) of the build as well as the variant (_main_, _ldap_).
-
-The _Dockerfile location_ configuration setting is completely ignored by the build scripts.
-
-[overwrite]: https://docs.docker.com/docker-hub/builds/advanced/#override-build-test-or-push-commands

Dockerfile

@@ -1,59 +1,121 @@
-FROM python:3.6-alpine3.9
+ARG FROM
+FROM ${FROM} AS builder
 
-RUN apk add --no-cache \
-      bash \
-      build-base \
+COPY --from=ghcr.io/astral-sh/uv:0.7 /uv /usr/local/bin/
+RUN export DEBIAN_FRONTEND=noninteractive \
+    && apt-get update -qq \
+    && apt-get upgrade \
+      --yes -qq --no-install-recommends \
+    && apt-get install \
+      --yes -qq --no-install-recommends \
+      build-essential \
       ca-certificates \
-      cyrus-sasl-dev \
-      graphviz \
-      jpeg-dev \
-      libffi-dev \
+      libldap-dev \
+      libpq-dev \
+      libsasl2-dev \
+      libssl-dev \
       libxml2-dev \
+      libxmlsec1 \
+      libxmlsec1-dev \
+      libxmlsec1-openssl \
       libxslt-dev \
-      openldap-dev \
-      postgresql-dev \
-      ttf-ubuntu-font-family \
-      wget
+      pkg-config \
+      python3-dev \
+    && /usr/local/bin/uv venv /opt/netbox/venv
 
-RUN pip install \
-# gunicorn is used for launching netbox
-      gunicorn \
-# napalm is used for gathering information from network devices
-      napalm \
-# ruamel is used in startup_scripts
-      ruamel.yaml \
-# pinning django to the version required by netbox
-# adding it here, to install the correct version of
-# django-rq
-      'Django>=2.1.5,<2.2' \
-# django-rq is used for webhooks
-      django-rq
+ARG NETBOX_PATH
+COPY ${NETBOX_PATH}/requirements.txt requirements-container.txt /
+ENV VIRTUAL_ENV=/opt/netbox/venv
+RUN \
+    # Gunicorn is not needed because we use Nginx Unit
+    sed -i -e '/gunicorn/d' /requirements.txt && \
+    # We need 'social-auth-core[all]' in the Docker image. But if we put it in our own requirements-container.txt
+    # we have potential version conflicts and the build will fail.
+    # That's why we just replace it in the original requirements.txt.
+    sed -i -e 's/social-auth-core/social-auth-core\[all\]/g' /requirements.txt && \
+    # The same is true for 'django-storages'
+    sed -i -e 's/django-storages/django-storages\[azure,boto3,dropbox,google,libcloud,sftp\]/g' /requirements.txt && \
+    /usr/local/bin/uv pip install \
+      -r /requirements.txt \
+      -r /requirements-container.txt
 
-WORKDIR /opt
+###
+# Main stage
+###
 
-ARG BRANCH=master
-ARG URL=https://github.com/digitalocean/netbox/archive/$BRANCH.tar.gz
-RUN wget -q -O - "${URL}" | tar xz \
-  && mv netbox* netbox
+ARG FROM
+FROM ${FROM} AS main
 
-WORKDIR /opt/netbox
-RUN pip install -r requirements.txt
+COPY docker/unit.list /etc/apt/sources.list.d/unit.list
+ADD --chmod=444 --chown=0:0 https://unit.nginx.org/keys/nginx-keyring.gpg /usr/share/keyrings/nginx-keyring.gpg
+RUN export DEBIAN_FRONTEND=noninteractive \
+    && apt-get update -qq \
+    && apt-get upgrade \
+      --yes -qq --no-install-recommends \
+    && apt-get install \
+      --yes -qq --no-install-recommends \
+      bzip2 \
+      ca-certificates \
+      curl \
+      libldap-common \
+      libpq5 \
+      libxmlsec1-openssl \
+      openssh-client \
+      openssl \
+      python3 \
+      tini \
+      unit-python3.12=1.34.2-1~noble \
+      unit=1.34.2-1~noble \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the modified 'requirements*.txt' files, to have the files actually used during installation
+COPY --from=builder /requirements.txt /requirements-container.txt /opt/netbox/
+COPY --from=builder /usr/local/bin/uv /usr/local/bin/
+COPY --from=builder /opt/netbox/venv /opt/netbox/venv
+
+ARG NETBOX_PATH
+COPY ${NETBOX_PATH} /opt/netbox
 
 COPY docker/configuration.docker.py /opt/netbox/netbox/netbox/configuration.py
-COPY configuration/gunicorn_config.py /etc/netbox/config/
-COPY docker/nginx.conf /etc/netbox-nginx/nginx.conf
-COPY docker/docker-entrypoint.sh docker-entrypoint.sh
-COPY startup_scripts/ /opt/netbox/startup_scripts/
-COPY initializers/ /opt/netbox/initializers/
-COPY configuration/configuration.py /etc/netbox/config/configuration.py
+COPY docker/ldap_config.docker.py /opt/netbox/netbox/netbox/ldap_config.py
+COPY docker/docker-entrypoint.sh /opt/netbox/docker-entrypoint.sh
+COPY docker/housekeeping.sh /opt/netbox/housekeeping.sh
+COPY docker/launch-netbox.sh /opt/netbox/launch-netbox.sh
+COPY configuration/ /etc/netbox/config/
+COPY docker/nginx-unit.json /etc/unit/
+COPY VERSION /opt/netbox/VERSION
 
 WORKDIR /opt/netbox/netbox
 
-ENTRYPOINT [ "/opt/netbox/docker-entrypoint.sh" ]
+# Must set permissions for '/opt/netbox/netbox/media' directory
+# to g+w so that pictures can be uploaded to netbox.
+RUN mkdir -p static /opt/unit/state/ /opt/unit/tmp/ \
+      && chown -R unit:root /opt/unit/ media reports scripts \
+      && chmod -R g+w /opt/unit/ media reports scripts \
+      && cd /opt/netbox/ && SECRET_KEY="dummyKeyWithMinimumLength-------------------------" /opt/netbox/venv/bin/python -m mkdocs build \
+          --config-file /opt/netbox/mkdocs.yml --site-dir /opt/netbox/netbox/project-static/docs/ \
+      && DEBUG="true" SECRET_KEY="dummyKeyWithMinimumLength-------------------------" /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py collectstatic --no-input \
+      && mkdir /opt/netbox/netbox/local \
+      && echo "build: Docker-$(cat /opt/netbox/VERSION)" > /opt/netbox/netbox/local/release.yaml
 
-CMD ["gunicorn", "-c /etc/netbox/config/gunicorn_config.py", "netbox.wsgi"]
+ENV LANG=C.utf8 PATH=/opt/netbox/venv/bin:$PATH VIRTUAL_ENV=/opt/netbox/venv UV_NO_CACHE=1
+ENTRYPOINT [ "/usr/bin/tini", "--" ]
 
-LABEL SRC_URL="$URL"
+CMD [ "/opt/netbox/docker-entrypoint.sh", "/opt/netbox/launch-netbox.sh" ]
 
-ARG NETBOX_DOCKER_PROJECT_VERSION=snapshot
-LABEL NETBOX_DOCKER_PROJECT_VERSION="$NETBOX_DOCKER_PROJECT_VERSION"
+LABEL netbox.original-tag="" \
+      netbox.git-branch="" \
+      netbox.git-ref="" \
+      netbox.git-url="" \
+# See https://github.com/opencontainers/image-spec/blob/master/annotations.md#pre-defined-annotation-keys
+      org.opencontainers.image.created="" \
+      org.opencontainers.image.title="NetBox Docker" \
+      org.opencontainers.image.description="A container based distribution of NetBox, the free and open IPAM and DCIM solution." \
+      org.opencontainers.image.licenses="Apache-2.0" \
+      org.opencontainers.image.authors="The netbox-docker contributors." \
+      org.opencontainers.image.vendor="The netbox-docker contributors." \
+      org.opencontainers.image.url="https://github.com/netbox-community/netbox-docker" \
+      org.opencontainers.image.documentation="https://github.com/netbox-community/netbox-docker/wiki" \
+      org.opencontainers.image.source="https://github.com/netbox-community/netbox-docker.git" \
+      org.opencontainers.image.revision="" \
+      org.opencontainers.image.version=""

Dockerfile.ldap

@@ -1,9 +0,0 @@
-ARG DOCKER_ORG=netboxcommunity
-ARG DOCKER_REPO=netbox
-ARG FROM_TAG=latest
-FROM $DOCKER_ORG/$DOCKER_REPO:$FROM_TAG
-
-RUN pip install django_auth_ldap
-
-COPY docker/ldap_config.docker.py /opt/netbox/netbox/netbox/ldap_config.py
-COPY configuration/ldap_config.py /etc/netbox/config/ldap_config.py

MAINTAINERS.md

@@ -0,0 +1,19 @@
+# Maintainers of _NetBox Docker_
+
+This file lists all currently recognized maintainers of the _NetBox Docker_ project in alphabetical order:
+
+- @cimnine
+- @tobiasge
+
+## Stepping Down
+
+Every maintainer is a volunteer and may step down as maintainer at any time without providing any reason.
+To make this explicit, the maintainer is asked to update this file.
+
+The last maintainer stepping down is asked to archive the project on GitHub to indicate that the project is no longer maintained.
+
+## Signing up
+
+Everyone is welcome to sign up as maintainer by creating a PR and add their own username to the list.
+The current maintainers shall discuss the application.
+They may turn down an application if they don't feel confident that the new maintainer is a positive addition.

PRINCIPALS.md

@@ -0,0 +1,71 @@
+# Development, Maintenance and Community Principals for _NetBox Docker_
+
+These principals shall guide the development and the maintenance of _NetBox Docker_.
+
+## Basic principals
+
+This project is maintained on voluntary basis.
+Everyone is asked to respect that.
+
+This means, that …
+
+- … sometimes features are not implemented as fast as one might like -- or not at all.
+- … sometimes nobody is looking at bugs, or they are not fixed as fast as one might like -- or not at all.
+- … sometimes PRs are not reviewed for an extended period.
+
+Everyone is welcome to provide improvements and bugfixes to the benefit of everyone else.
+
+## Development Principals
+
+The goal of the _NetBox Docker_ project is to provide a container to run the basic NetBox project.
+The container should feel like a native container -- as if it were provided by NetBox itself:
+
+- Configuration via environment variables where feasible.
+  - Except: Whenever a complex type such as a `dict` is required as value of a configuration setting,
+    then it shall not be provided through an environment variable.
+- Configuration of secrets via secret files.
+- Log output to standard out (STDOUT/`&1`) / standard error (STDERR/`&2`).
+- Volumes for data and cache directories.
+  - Otherwise, no mounts shall be necessary.
+- Runs a non-root user by default.
+- One process / role for each instance.
+
+The container generally does not provide more features than the basic NetBox project itself provides.
+It may provide additional Python dependencies than the upstream project,
+so that all configurable features of NetBox can be used in the container without further modification.
+The container may provide helpers, so that it feels and behaves like a native container.
+
+The container does not bundle any community plugins.
+
+## Maintenance Principals
+
+The main goals of maintaining _NetBox Docker_ are:
+
+- Keeping the project at a high quality level.
+- Keeping the maintenance effort minimal.
+- Coordinating development efforts.
+
+The following guidelines help us to achieve these goals:
+
+- As many maintenance tasks as possible shall be automated or scripted.
+- All manual tasks must be documented.
+- All changes are reviewed by at least one maintainer.
+  - Changes of maintainers are reviewed by at least one other maintainer.
+    (Except if there's only one maintainer left.)
+- The infrastructure beyond what GitHub provides shall be kept to a minimum.
+  - On request, every maintainer shall get access to infrastructure that is beyond GitHub
+    (at the time of writing that's _Docker Hub_ and _Quay_ in particular).
+
+## Community Principals
+
+This project is developed by the NetBox community for the NetBox community.
+We welcome contributions, as long as they are in line with the principals above.
+
+The maintainers of NetBox Docker are not the support team.
+The community is expected to help each other out.
+
+Always remember:
+Behind every screen (or screen-reader) on the other end is a fellow human.
+Be nice and respectful, thankful for help,
+and value ideas and contributions,
+even when they don't fit the goals.

README.md

@@ -1,428 +1,166 @@
 # netbox-docker
 
-[The Github repository](netbox-docker-github) houses the components needed to build Netbox as a Docker container.
-Images are built using this code are released to [Docker Hub][netbox-dockerhub] every night.
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/netbox-community/netbox-docker)][github-release]
+[![GitHub stars](https://img.shields.io/github/stars/netbox-community/netbox-docker)][github-stargazers]
+![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed-raw/netbox-community/netbox-docker)
+![Github release workflow](https://img.shields.io/github/actions/workflow/status/netbox-community/netbox-docker/release.yml?branch=release)
+![Docker Pulls](https://img.shields.io/docker/pulls/netboxcommunity/netbox)
+[![GitHub license](https://img.shields.io/github/license/netbox-community/netbox-docker)][netbox-docker-license]
 
-Questions? Before opening an issue on Github, please join the [Network To Code][ntc-slack] Slack and ask for help in our `#netbox-docker` channel.
+[The GitHub repository][netbox-docker-github] houses the components needed to build NetBox as a container.
+Images are built regularly using the code in that repository
+and are pushed to [Docker Hub][netbox-dockerhub],
+[Quay.io][netbox-quayio] and [GitHub Container Registry][netbox-ghcr].
+_NetBox Docker_ is a project developed and maintained by the _NetBox_ community.
 
-[netbox-dockerhub]: https://hub.docker.com/r/netboxcommunity/netbox/tags/
-[netbox-docker-github]:  https://github.com/netbox-community/netbox-docker/
-[ntc-slack]: http://slack.networktocode.com/
+Do you have any questions?
+Before opening an issue on GitHub,
+please join [our Slack][netbox-docker-slack]
+and ask for help in the [`#netbox-docker`][netbox-docker-slack-channel] channel,
+or start a new [GitHub Discussion][github-discussions].
+
+[github-stargazers]: https://github.com/netbox-community/netbox-docker/stargazers
+[github-release]: https://github.com/netbox-community/netbox-docker/releases
+[netbox-dockerhub]: https://hub.docker.com/r/netboxcommunity/netbox/
+[netbox-quayio]: https://quay.io/repository/netboxcommunity/netbox
+[netbox-ghcr]: https://github.com/netbox-community/netbox-docker/pkgs/container/netbox
+[netbox-docker-github]: https://github.com/netbox-community/netbox-docker/
+[netbox-docker-slack]: https://join.slack.com/t/netdev-community/shared_invite/zt-mtts8g0n-Sm6Wutn62q_M4OdsaIycrQ
+[netbox-docker-slack-channel]: https://netdev-community.slack.com/archives/C01P0GEVBU7
+[netbox-slack-channel]: https://netdev-community.slack.com/archives/C01P0FRSXRV
+[netbox-docker-license]: https://github.com/netbox-community/netbox-docker/blob/release/LICENSE
+[github-discussions]: https://github.com/netbox-community/netbox-docker/discussions
 
 ## Quickstart
 
-To get Netbox up and running:
+To get _NetBox Docker_ up and running run the following commands.
+There is a more complete [_Getting Started_ guide on our wiki][wiki-getting-started] which explains every step.
 
-```
-$ git clone -b master https://github.com/netbox-community/netbox-docker.git
-$ cd netbox-docker
-$ docker-compose pull
-$ docker-compose up -d
+```bash
+git clone -b release https://github.com/netbox-community/netbox-docker.git
+cd netbox-docker
+tee docker-compose.override.yml <<EOF
+services:
+  netbox:
+    ports:
+      - 8000:8080
+EOF
+docker compose pull
+docker compose up
 ```
 
-The application will be available after a few minutes.
-Use `docker-compose port nginx 8080` to find out where to connect to.
+The whole application will be available after a few minutes.
+Open the URL `http://0.0.0.0:8000/` in a web-browser.
+You should see the NetBox homepage.
 
-```
-$ echo "http://$(docker-compose port nginx 8080)/"
-http://0.0.0.0:32768/
+To create the first admin user run this command:
 
-# Open netbox in your default browser on macOS:
-$ open "http://$(docker-compose port nginx 8080)/"
-
-# Open netbox in your default browser on (most) linuxes:
-$ xdg-open "http://$(docker-compose port nginx 8080)/" &>/dev/null &
+```bash
+docker compose exec netbox /opt/netbox/netbox/manage.py createsuperuser
 ```
 
-Alternatively, use something like [Reception][docker-reception] to connect to _docker-compose_ projects.
+If you need to restart Netbox from an empty database often,
+you can also set the `SUPERUSER_*` variables in your `docker-compose.override.yml`.
 
-Default credentials:
+[wiki-getting-started]: https://github.com/netbox-community/netbox-docker/wiki/Getting-Started
 
-* Username: **admin**
-* Password: **admin**
-* API Token: **0123456789abcdef0123456789abcdef01234567**
+## Container Image Tags
 
-[docker-reception]: https://github.com/nxt-engineering/reception
+New container images are built and published automatically every ~24h.
+
+> We recommend to use either the `vX.Y.Z-a.b.c` tags or the `vX.Y-a.b.c` tags in production!
+
+- `vX.Y.Z-a.b.c`, `vX.Y-a.b.c`:
+  These are release builds containing _NetBox version_ `vX.Y.Z`.
+  They contain the support files of _NetBox Docker version_ `a.b.c`.
+  You must use _NetBox Docker version_ `a.b.c` to guarantee the compatibility.
+  These images are automatically built from [the corresponding releases of NetBox][netbox-releases].
+- `latest-a.b.c`:
+  These are release builds, containing the latest stable version of NetBox.
+  They contain the support files of _NetBox Docker version_ `a.b.c`.
+  You must use _NetBox Docker version_ `a.b.c` to guarantee the compatibility.
+- `snapshot-a.b.c`:
+  These are prerelease builds.
+  They contain the support files of _NetBox Docker version_ `a.b.c`.
+  You must use _NetBox Docker version_ `a.b.c` to guarantee the compatibility.
+  These images are automatically built from the [`main` branch of NetBox][netbox-main].
+
+For each of the above tag, there is an extra tag:
+
+- `vX.Y.Z`, `vX.Y`:
+  This is the same version as `vX.Y.Z-a.b.c` (or `vX.Y-a.b.c`, respectively).
+- `latest`
+  This is the same version as `latest-a.b.c`.
+  It always points to the latest version of _NetBox Docker_.
+- `snapshot`
+  This is the same version as `snapshot-a.b.c`.
+  It always points to the latest version of _NetBox Docker_.
+
+[netbox-releases]: https://github.com/netbox-community/netbox/releases
+[netbox-main]: https://github.com/netbox-community/netbox/tree/main
+
+## Documentation
+
+Please refer [to our wiki on GitHub][netbox-docker-wiki] for further information on how to use the NetBox Docker image properly.
+The wiki covers advanced topics such as using files for secrets, configuring TLS, deployment to Kubernetes, monitoring and configuring LDAP.
+
+Our wiki is a community effort.
+Feel free to correct errors, update outdated information or provide additional guides and insights.
+
+[netbox-docker-wiki]: https://github.com/netbox-community/netbox-docker/wiki/
+
+## Getting Help
+
+Feel free to ask questions in our [GitHub Community][netbox-community]
+or [join our Slack][netbox-docker-slack] and ask [in our channel `#netbox-docker`][netbox-docker-slack-channel],
+which is free to use and where there are almost always people online that can help you.
+
+If you need help with using NetBox or developing for it or against it's API
+you may find [the `#netbox` channel][netbox-slack-channel] on the same Slack instance very helpful.
+
+[netbox-community]: https://github.com/netbox-community/netbox-docker/discussions
 
 ## Dependencies
 
-This project relies only on *Docker* and *docker-compose* meeting this requirements:
+This project relies only on _Docker_ and _docker-compose_ meeting these requirements:
 
-* The *Docker version* must be at least `1.13.0`.
-* The *docker-compose version* must be at least `1.10.0`.
+- The _Docker version_ must be at least `20.10.10`.
+- The _containerd version_ must be at least `1.5.6`.
+- The _docker-compose version_ must be at least `1.28.0`.
 
-To ensure this, compare the output of `docker --version` and `docker-compose --version` with the requirements above.
+To check the version installed on your system run `docker --version` and `docker compose version`.
 
-## Configuration
+## Updating
 
-You can configure the app using environment variables.
-These are defined in `netbox.env`.
-Read [Environment Variables in Compose][compose-env] to understand about the various possibilities to overwrite these variables.
-(The easiest solution being simply adjusting that file.)
+Please read [the release notes][releases] carefully when updating to a new image version.
+Note that the version of the NetBox Docker container image must stay in sync with the version of the Git repository.
 
-To find all possible variables, have a look at the [configuration.py][docker-config] and [docker-entrypoint.sh][entrypoint] files.
-Generally, the environment variables are called the same as their respective Netbox configuration variables.
-Variables which are arrays are usually composed by putting all the values into the same environment variables with the values separated by a whitespace ("` `").
-For example defining `ALLOWED_HOSTS=localhost ::1 127.0.0.1` would allows access to Netbox through `http://localhost:8080`, `http://[::1]:8080` and `http://127.0.0.1:8080`.
+If you update for the first time, be sure [to follow our _How To Update NetBox Docker_ guide in the wiki][netbox-docker-wiki-updating].
 
-[compose-env]: https://docs.docker.com/compose/environment-variables/
+[releases]: https://github.com/netbox-community/netbox-docker/releases
+[netbox-docker-wiki-updating]: https://github.com/netbox-community/netbox-docker/wiki/Updating
 
-### Production
+## Rebuilding the Image
 
-The default settings are optimized for (local) development environments.
-You should therefore adjust the configuration for production setups, at least the following variables:
+`./build.sh` can be used to rebuild the container image.
+See `./build.sh --help` for more information or `./build-latest.sh` for an example.
 
-* `ALLOWED_HOSTS`: Add all URLs that lead to your Netbox instance, space separated. E.g. `ALLOWED_HOSTS=netbox.mycorp.com server042.mycorp.com 2a02:123::42 10.0.0.42 localhost ::1 127.0.0.1` (It's good advice to always allow localhost connections for easy debugging, i.e. `localhost ::1 127.0.0.1`.)
-* `DB_*`: Use your own persistent database. Don't use the default passwords!
-* `EMAIL_*`: Use your own mailserver.
-* `MAX_PAGE_SIZE`: Use the recommended default of 1000.
-* `SUPERUSER_*`: Only define those variables during the initial setup, and drop them once the DB is set up. Don't use the default passwords!
-* `REDIS_*`: Use your own persistent redis. Don't use the default passwords!
+For more details on custom builds [consult our wiki][netbox-docker-wiki-build].
 
-### Running on Docker Swarm / Kubernetes / OpenShift
-
-You may run this image in a cluster such as Docker Swarm, Kubernetes or OpenShift, but this is advanced level.
-
-In this case, we encourage you to statically configure Netbox by starting from [Netbox's example config file][default-config], and mounting it into your container in the directory `/etc/netbox/config/` using the mechanism provided by your container platform (i.e. [Docker Swarm configs][swarm-config], [Kubernetes ConfigMap][k8s-config], [OpenShift ConfigMaps][openshift-config]).
-
-But if you rather continue to configure your application through environment variables, you may continue to use [the built-in configuration file][
-
-
-
-
-].
-We discourage storing secrets in environment variables, as environment variable are passed on to all sub-processes and may leak easily into other systems, e.g. error collecting tools that often collect all environment variables whenever an error occurs.
-
-Therefore we *strongly advise* to make use of the secrets mechanism provided by your container platform (i.e. [Docker Swarm secrets][swarm-secrets], [Kubernetes secrets][k8s-secrets], [OpenShift secrets][openshift-secrets]).
-[The configuration file][docker-config] and [the entrypoint script][entrypoint] try to load the following secrets from the respective files.
-If a secret is defined by an environment variable and in the respective file at the same time, then the value from the environment variable is used.
-
-* `SUPERUSER_PASSWORD`: `/run/secrets/superuser_password`
-* `SUPERUSER_API_TOKEN`: `/run/secrets/superuser_api_token`
-* `DB_PASSWORD`: `/run/secrets/db_password`
-* `SECRET_KEY`: `/run/secrets/secret_key`
-* `EMAIL_PASSWORD`: `/run/secrets/email_password`
-* `NAPALM_PASSWORD`: `/run/secrets/napalm_password`
-* `REDIS_PASSWORD`: `/run/secrets/redis_password`
-
-Please also consider [the advice about running Netbox in production](#production) above!
-
-[docker-config]: https://github.com/netbox-community/netbox-docker/blob/master/configuration/configuration.py
-[default-config]: https://github.com/digitalocean/netbox/blob/develop/netbox/netbox/configuration.example.py
-[entrypoint]: https://github.com/netbox-community/netbox-docker/blob/master/docker/docker-entrypoint.sh
-[swarm-config]: https://docs.docker.com/engine/swarm/configs/
-[swarm-secrets]: https://docs.docker.com/engine/swarm/secrets/
-[openshift-config]: https://docs.openshift.org/latest/dev_guide/configmaps.html
-[openshift-secrets]: https://docs.openshift.org/latest/dev_guide/secrets.html
-[k8s-secrets]: https://kubernetes.io/docs/concepts/configuration/secret/
-[k8s-config]: https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/
-
-### NAPALM Configuration
-
-Since v2.1.0 NAPALM has been tightly integrated into Netbox.
-NAPALM allows Netbox to fetch live data from devices and return it to a requester via its REST API.
-To learn more about what NAPALM is and how it works, please see the documentation from the [libary itself][napalm-doc] or the documentation from [Netbox][netbox-napalm-doc] on how it is integrated.
-
-To enable this functionality, simply complete the following lines in `netbox.env` (or appropriate secrets mechanism) :
-
-* `NAPALM_USERNAME`: A common username that can be utilized for connecting to network devices in your environment.
-* `NAPALM_PASSWORD`: The password to use in combintation with the username to connect to network devices.
-* `NAPALM_TIMEOUT`: A value to use for when an attempt to connect to a device will timeout if no response has been recieved.
-
-However, if you don't need this functionality, leave these blank.
-
-[napalm-doc]: http://napalm.readthedocs.io/en/latest/index.html
-[netbox-napalm-doc]: https://netbox.readthedocs.io/en/latest/configuration/optional-settings/#napalm_username
-
-### Customizable Reporting
-
-Netbox includes [customized reporting][netbox-reports-doc] that allows the user to write Python code and determine the validity of the data within Netbox.
-The `REPORTS_ROOT` variable is setup as a mapped directory within this Docker container to `/reports/` and includes the example directly from the documentation for `devices.py`.
-However, it has been renamed to `devices.py.example` which prevents Netbox from recognizing it as a valid report.
-This was done to avoid unnessary issues from being opened when the default does not work for someone's expectations.
-
-To re-enable this default report, simply rename `devices.py.example` to `devices.py` and browse within the WebUI to `/extras/reports/`.
-You can also dynamically add any other report to this same directory and Netbox will be able to see it without restarting the container.
-
-[netbox-reports-doc]: https://netbox.readthedocs.io/en/stable/additional-features/reports/
-
-### Custom Initialization Code (e.g. Automatically Setting Up Custom Fields)
-
-When using `docker-compose`, all the python scripts present in `/opt/netbox/startup_scripts` will automatically be executed after the application boots in the context of `./manage.py`.
-The execution of the startup scripts can be prevented by setting the environment variable `SKIP_STARTUP_SCRIPTS` to `true`, e.g. in the file `env/netbox.env`.
-
-That mechanism can be used for many things, e.g. to create Netbox custom fields:
-
-```python
-# docker/startup_scripts/load_custom_fields.py
-from django.contrib.contenttypes.models import ContentType
-from extras.models import CF_TYPE_TEXT, CustomField
-
-from dcim.models import Device
-from dcim.models import DeviceType
-
-device      = ContentType.objects.get_for_model(Device)
-device_type = ContentType.objects.get_for_model(DeviceType)
-
-my_custom_field, created = CustomField.objects.get_or_create(
-    type=CF_TYPE_TEXT,
-    name='my_custom_field',
-    description='My own custom field'
-)
-
-if created:
-  my_custom_field.obj_type.add(device)
-  my_custom_field.obj_type.add(device_type)
-```
-
-#### Initializers
-
-Initializers are built-in startup scripts for defining Netbox custom fields, groups, users and many other resources.
-All you need to do is to mount you own `initializers` folder ([see `docker-compose.yml`][netbox-docker-compose]).
-Look at the [`initializers` folder][netbox-docker-initializers] to learn how the files must look like.
-
-Here's an example for defining a custom field:
-
-```yaml
-# initializers/custom_fields.yml
-text_field:
-  type: text
-  label: Custom Text
-  description: Enter text in a text field.
-  required: false
-  filter_logic: loose
-  weight: 0
-  on_objects:
-  - dcim.models.Device
-  - dcim.models.Rack
-  - ipam.models.IPAddress
-  - ipam.models.Prefix
-  - tenancy.models.Tenant
-  - virtualization.models.VirtualMachine
-```
-
-[netbox-docker-initializers]: https://github.com/netbox-community/netbox-docker/tree/master/initializers
-[netbox-docker-compose]: https://github.com/netbox-community/netbox-docker/blob/master/docker-compose.yml
-
-##### Available Groups for User/Group initializers
-
-To get an up-to-date list about all the available permissions, run the following command.
-
-```bash
-# Make sure the 'netbox' container is already running! If unsure, run `docker-compose up -d`
-echo "from django.contrib.auth.models import Permission\nfor p in Permission.objects.all():\n  print(p.codename);" | docker-compose exec -T netbox ./manage.py shell
-```
-
-#### Custom Docker Image
-
-You can also build your own Netbox Docker image containing your own startup scripts, custom fields, users and groups
-like this:
-
-```
-ARG VERSION=latest
-FROM netboxcommunity/netbox:$VERSION
-
-COPY startup_scripts/ /opt/netbox/startup_scripts/
-COPY initializers/ /opt/netbox/initializers/
-```
-
-## Netbox Version
-
-The `docker-compose.yml` file is prepared to run a specific version of Netbox.
-To use this feature, set the environment-variable `VERSION` before launching `docker-compose`, as shown below.
-`VERSION` may be set to the name of
-[any tag of the `netboxcommunity/netbox` Docker image on Docker Hub][netbox-dockerhub].
-
-```
-$ export VERSION=v2.2.6
-$ docker-compose pull netbox
-$ docker-compose up -d
-```
-
-You can also build a specific version of the Netbox image. This time, `VERSION` indicates any valid
-[Git Reference][git-ref] declared on [the 'digitalocean/netbox' Github repository][netbox-github].
-Most commonly you will specify a tag or branch name.
-
-```
-$ export VERSION=develop
-$ docker-compose build --no-cache netbox
-$ docker-compose up -d
-```
-
-Hint: If you're building a specific version by tag name, the `--no-cache` argument is not strictly necessary.
-This can increase the build speed if you're just adjusting the config, for example.
-
-[git-ref]: https://git-scm.com/book/en/v2/Git-Internals-Git-References
-[netbox-github]: https://github.com/digitalocean/netbox/releases
-
-### LDAP enabled variant
-
-The images tagged with "-ldap" contain anything necessary to authenticate against an LDAP or Active Directory server.
-The default configuration `ldap_config.py` is prepared for use with an Active Directory server.
-Custom values can be injected using environment variables, similar to the main configuration mechanisms.
-
-## Troubleshooting
-
-This section is a collection of some common issues and how to resolve them.
-If your issue is not here, look through [the existing issues][issues] and eventually create a new issue.
-
-[issues]: (https://github.com/netbox-community/netbox-docker/issues)
-
-### Docker Compose basics
-
-* You can see all running containers belonging to this project using `docker-compose ps`.
-* You can see the logs by running `docker-compose logs -f`.
-  Running `docker-compose logs -f netbox` will just show the logs for netbox.
-* You can stop everything using `docker-compose stop`.
-* You can clean up everything using `docker-compose down -v --remove-orphans`. **This will also remove any related data.**
-* You can enter the shell of the running Netbox container using `docker-compose exec netbox /bin/bash`. Now you have access to `./manage.py`, e.g. to reset a password.
-* To access the database run `docker-compose exec postgres sh -c 'psql -U $POSTGRES_USER $POSTGRES_DB'`
-* To create a database backup run `docker-compose exec postgres sh -c 'pg_dump -cU $POSTGRES_USER $POSTGRES_DB' | gzip > db_dump.sql.gz`
-* To restore that database backup run `gunzip -c db_dump.sql.gz | docker exec -i $(docker-compose ps -q postgres) sh -c 'psql -U $POSTGRES_USER $POSTGRES_DB'`.
-
-### Nginx doesn't start
-
-As a first step, stop your docker-compose setup.
-Then locate the `netbox-nginx-config` volume and remove it:
-
-```bash
-# Stop your local netbox-docker installation
-$ docker-compose down
-
-# Find the volume
-$ docker volume ls | grep netbox-nginx-config
-local               netbox-docker_netbox-nginx-config
-
-# Remove the volume
-$ docker volume rm netbox-docker_netbox-nginx-config
-netbox-docker_netbox-nginx-config
-```
-
-Now start everything up again.
-
-If this didn't help, try to see if there's anything in the logs indicating why nginx doesn't start:
-
-```bash
-$ docker-compose logs -f nginx
-```
-
-### Getting a "Bad Request (400)"
-
-> When connecting to the Netbox instance, I get a "Bad Request (400)" error.
-
-This usually happens when the `ALLOWED_HOSTS` variable is not set correctly.
-
-### How to upgrade
-
-> How do I update to a newer version of netbox?
-
-It should be sufficient to pull the latest image from Docker Hub, stopping the container and starting it up again:
-
-```bash
-docker-compose pull netbox
-docker-compose stop netbox netbox-worker
-docker-compose rm -f netbox netbox-worker
-docker-compose up -d netbox netbox-worker
-```
-
-### Webhooks don't work
-
-First make sure that the webhooks feature is enabled in your Netbox configuration and that a redis host is defined.
-Check `netbox.env` if the following variables are defined:
-
-```
-WEBHOOKS_ENABLED=true
-REDIS_HOST=redis
-```
-
-Then make sure that the `redis` container and at least one `netbox-worker` are running.
-
-```
-# check the container status
-$ docker-compose ps
-
-Name                           Command               State                Ports
---------------------------------------------------------------------------------------------------------
-netbox-docker_netbox-worker_1   /opt/netbox/docker-entrypo ...   Up
-netbox-docker_netbox_1          /opt/netbox/docker-entrypo ...   Up
-netbox-docker_nginx_1           nginx -c /etc/netbox-nginx ...   Up      80/tcp, 0.0.0.0:32776->8080/tcp
-netbox-docker_postgres_1        docker-entrypoint.sh postgres    Up      5432/tcp
-netbox-docker_redis_1           docker-entrypoint.sh redis ...   Up      6379/tcp
-
-# connect to redis and send PING command:
-$ docker-compose run --rm -T redis sh -c 'redis-cli -h redis -a $REDIS_PASSWORD ping'
-Warning: Using a password with '-a' option on the command line interface may not be safe.
-PONG
-```
-
-If `redis` and the `netbox-worker` are not available, make sure you have updated your `docker-compose.yml` file!
-
-Everything's up and running? Then check the log of `netbox-worker` and/or `redis`:
-
-```bash
-docker-compose logs -f netbox-worker
-docker-compose logs -f redis
-```
-
-Still no clue? You can connect to the `redis` container and have it report any command that is currently executed on the server:
-
-```bash
-docker-compose run --rm -T redis sh -c 'redis-cli -h redis -a $REDIS_PASSWORD monitor'
-
-# Hit CTRL-C a few times to leave
-```
-
-If you don't see anything happening after you triggered a webhook, double-check the configuration of the `netbox` and the `netbox-worker` containers and also check the configuration of your webhook in the admin interface of Netbox.
-
-## Breaking Changes
-
-From time to time it might become necessary to re-engineer the structure of this setup.
-Things like the `docker-compose.yml` file or your Kubernetes or OpenShift configurations have to be adjusted as a consequence.
-Since April 2018 each image built from this repo contains a `NETBOX_DOCKER_PROJECT_VERSION` label.
-You can check the label of your local image by running `docker inspect netboxcommunity/netbox:v2.3.1 --format "{{json .ContainerConfig.Labels}}"`.
-Compare the version with the list below to check whether a breaking change was introduced with that version.
-
-The following is a list of breaking changes of the `netbox-docker` project:
-
-* 0.12.0: A new flag `REDIS_SSL=false` was added to the `env/netbox.env` file. [#129][129]
-* 0.11.0: The docker-compose file now marks volumes as shared (`:z`). This should prevent SELinux problems [#131][131]
-* 0.9.0: Upgrade to at least 2.1.5
-* 0.8.0: Alpine linux was upgraded to 3.9 [#126][126]
-* 0.7.0: The value of the `MAX_PAGE_SIZE` environment variable was changed to `1000`, which is the default of Netbox.
-* 0.6.0: The naming of the default startup_scripts were changed.
-  If you overwrite them, you may need to adjust these scripts.
-* 0.5.0: Alpine was updated to 3.8, `*.env` moved to `/env` folder
-* 0.4.0: In order to use Netbox webhooks you need to add Redis and a netbox-worker to your docker-compose.yml.
-* 0.3.0: Field `filterable: <boolean` was replaced with field `filter_logic: loose/exact/disabled`. It will default to `CF_FILTER_LOOSE=loose` when not defined.
-* 0.2.0: Re-organized paths: `/etc/netbox -> /etc/netbox/config` and `/etc/reports -> /etc/netbox/reports`. Fixes [#54][54].
-* 0.1.0: Introduction of the `NETBOX_DOCKER_PROJECT_VERSION`. (Not a breaking change per se.)
-
-[54]: https://github.com/netbox-community/netbox-docker/issues/54
-[126]: https://github.com/netbox-community/netbox-docker/pull/126
-[131]: https://github.com/netbox-community/netbox-docker/pull/131
-[129]: https://github.com/netbox-community/netbox-docker/pull/129
-
-## Rebuilding & Publishing images
-
-`./build.sh` can be used to rebuild the Docker image. See `./build.sh --help` for more information.
-
-### Publishing Docker Images
-
-New Docker images are built and published every 24h on the [Docker Build Infrastructure][docker-build-infra].
-`DOCKER_HUB.md` contains more information about the build infrastructure.
-
-[docker-build-infra]: https://hub.docker.com/r/netboxcommunity/netbox/builds/
+[netbox-docker-wiki-build]: https://github.com/netbox-community/netbox-docker/wiki/Build
 
 ## Tests
 
-To run the tests coming with Netbox, use the `docker-compose.yml` file as such:
+We have a test script.
+It runs NetBox's own unit tests and ensures that NetBox starts:
 
-```
-$ docker-compose run netbox ./manage.py test
+```bash
+IMAGE=docker.io/netboxcommunity/netbox:latest ./test.sh
 ```
 
-## About
+## Support
 
-This repository is currently maintained and funded by [nxt][nxt].
+This repository is currently maintained by the community.
+The community is expected to help each other.
 
-[nxt]: https://nxt.engineering/en/
+Please consider sponsoring the maintainers of this project.

VERSION

@@ -1 +1 @@
-0.12.0
+3.3.0

actionlint.yml

@@ -0,0 +1,5 @@
+---
+paths:
+  .github/workflows/**/*.{yml,yaml}:
+    ignore:
+      - ".*ubuntu-24.04-arm.*"

build-all.sh

@@ -1,84 +0,0 @@
-#!/bin/bash
-# Builds all Docker images this project provides
-# Arguments:
-#   BUILD:     The release to build.
-#              Allowed: release, prerelease, branches, special
-#              Default: undefined
-
-echo "▶️ $0 $*"
-
-ALL_BUILDS=("release" "prerelease" "branches" "special")
-BUILDS=("${BUILD:-"${ALL_BUILDS[@]}"}")
-
-echo "⚙️ Configured builds: ${BUILDS[*]}"
-
-VARIANTS=("main" "ldap")
-
-if [ -n "${DEBUG}" ]; then
-  export DEBUG
-fi
-
-ERROR=0
-
-# Don't build if not on `master` and don't build if on a pull request,
-# but build when DEBUG is not empty
-for VARIANT in "${VARIANTS[@]}"; do
-  export VARIANT
-
-  # Checking which VARIANT to build
-  if [ "${VARIANT}" == "main" ]; then
-    DOCKERFILE="${DOCKERFILE_PATH-Dockerfile}"
-  else
-    DOCKERFILE="${DOCKERFILE_PATH-Dockerfile}.${VARIANT}"
-
-    # Fail fast
-    if [ ! -f "${DOCKERFILE}" ]; then
-      echo "🚨 The Dockerfile '${DOCKERFILE}' for variant '${VARIANT}' doesn't exist."
-      ERROR=1
-
-      if [ -z "$DEBUG" ]; then
-        continue
-      else
-        echo "⚠️ Would skip this, but DEBUG is enabled."
-      fi
-    fi
-  fi
-
-  for BUILD in "${BUILDS[@]}"; do
-    echo "🛠 Building '$BUILD' from '$DOCKERFILE'"
-    case $BUILD in
-      release)
-        # build the latest release
-        # shellcheck disable=SC2068
-        ./build-latest.sh $@ || ERROR=1
-        ;;
-      prerelease)
-        # build the latest pre-release
-        # shellcheck disable=SC2068
-        PRERELEASE=true ./build-latest.sh $@ || ERROR=1
-        ;;
-      branches)
-        # build all branches
-        # shellcheck disable=SC2068
-        ./build-branches.sh $@ || ERROR=1
-        ;;
-      special)
-        # special build
-        # shellcheck disable=SC2068
-        #SRC_ORG=lampwins TAG=webhooks-backend ./build.sh "feature/webhooks-backend" $@ || ERROR=1
-        echo "✅ No special builds today."
-        ;;
-      *)
-        echo "🚨 Unrecognized build '$BUILD'."
-
-        if [ -z "$DEBUG" ]; then
-          exit 1
-        else
-          echo "⚠️ Would exit here with code '1', but DEBUG is enabled."
-        fi
-        ;;
-    esac
-  done
-done
-
-exit $ERROR

build-branches.sh

@@ -1,28 +0,0 @@
-#!/bin/bash
-# Builds develop, develop-* and master branches
-
-echo "▶️ $0 $*"
-
-if [ -n "${GITHUB_OAUTH_CLIENT_ID}" ] && [ -n "${GITHUB_OAUTH_CLIENT_SECRET}" ]; then
-  echo "🗝 Performing authenticated Github API calls."
-  GITHUB_OAUTH_PARAMS="client_id=${GITHUB_OAUTH_CLIENT_ID}&client_secret=${GITHUB_OAUTH_CLIENT_SECRET}"
-else
-  echo "🕶 Performing unauthenticated Github API calls. This might result in lower Github rate limits!"
-  GITHUB_OAUTH_PARAMS=""
-fi
-
-ORIGINAL_GITHUB_REPO="${SRC_ORG-digitalocean}/${SRC_REPO-netbox}"
-GITHUB_REPO="${GITHUB_REPO-$ORIGINAL_GITHUB_REPO}"
-URL_RELEASES="https://api.github.com/repos/${GITHUB_REPO}/branches?${GITHUB_OAUTH_PARAMS}"
-
-CURL="curl -sS"
-
-BRANCHES=$($CURL "${URL_RELEASES}" | jq -r 'map(.name) | .[] | scan("^[^v].+") | match("^(master|develop).*") | .string')
-
-ERROR=0
-
-for BRANCH in $BRANCHES; do
-  # shellcheck disable=SC2068
-  ./build.sh "${BRANCH}" $@ || ERROR=1
-done
-exit $ERROR

build-functions/check-commands.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+NEEDED_COMMANDS="curl jq docker skopeo"
+for c in $NEEDED_COMMANDS; do
+  if ! command -v "$c" &>/dev/null; then
+    echo "⚠️  '$c' is not installed. Can't proceed with build."
+    exit 1
+  fi
+done

build-functions/get-public-image-config.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+check_if_tags_exists() {
+  local image=$1
+  local tag=$2
+  skopeo list-tags "docker://$image" | jq -r ".Tags | contains([\"$tag\"])"
+}
+
+get_image_label() {
+  local label=$1
+  local image=$2
+  skopeo inspect "docker://$image" | jq -r ".Labels[\"$label\"]"
+}
+
+get_image_last_layer() {
+  local image=$1
+  skopeo inspect "docker://$image" | jq -r ".Layers | last"
+}

build-functions/gh-functions.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+###
+# A regular echo, that only prints if ${GH_ACTION} is defined.
+###
+gh_echo() {
+  if [ -n "${GH_ACTION}" ]; then
+    echo "${@}"
+  fi
+}
+
+###
+# Prints the output to the file defined in ${GITHUB_ENV}.
+# Only executes if ${GH_ACTION} is defined.
+# Example Usage: gh_env "FOO_VAR=bar_value"
+###
+gh_env() {
+  if [ -n "${GH_ACTION}" ]; then
+    echo "${@}" >>"${GITHUB_ENV}"
+  fi
+}
+
+###
+# Prints the output to the file defined in ${GITHUB_OUTPUT}.
+# Only executes if ${GH_ACTION} is defined.
+# Example Usage: gh_env "FOO_VAR=bar_value"
+###
+gh_out() {
+  if [ -n "${GH_ACTION}" ]; then
+    echo "${@}" >>"$GITHUB_OUTPUT"
+  fi
+}

build-latest.sh

@@ -1,44 +1,78 @@
 #!/bin/bash
 # Builds the latest released version
 
+# Check if we have everything needed for the build
+source ./build-functions/check-commands.sh
+
+source ./build-functions/gh-functions.sh
+
 echo "▶️ $0 $*"
 
-if [ -n "${GITHUB_OAUTH_CLIENT_ID}" ] && [ -n "${GITHUB_OAUTH_CLIENT_SECRET}" ]; then
+CURL_ARGS=(
+  --silent
+)
+
+###
+# Checking for the presence of GITHUB_TOKEN
+###
+if [ -n "${GITHUB_TOKEN}" ]; then
   echo "🗝 Performing authenticated Github API calls."
-  GITHUB_OAUTH_PARAMS="client_id=${GITHUB_OAUTH_CLIENT_ID}&client_secret=${GITHUB_OAUTH_CLIENT_SECRET}"
+  CURL_ARGS+=(
+    --header "Authorization: Bearer ${GITHUB_TOKEN}"
+  )
 else
   echo "🕶 Performing unauthenticated Github API calls. This might result in lower Github rate limits!"
-  GITHUB_OAUTH_PARAMS=""
 fi
 
-ORIGINAL_GITHUB_REPO="digitalocean/netbox"
-GITHUB_REPO="${GITHUB_REPO-$ORIGINAL_GITHUB_REPO}"
-URL_RELEASES="https://api.github.com/repos/${GITHUB_REPO}/releases?${GITHUB_OAUTH_PARAMS}"
+###
+# Checking if PRERELEASE is either unset, 'true' or 'false'
+###
+if [ -n "${PRERELEASE}" ] &&
+  { [ "${PRERELEASE}" != "true" ] && [ "${PRERELEASE}" != "false" ]; }; then
 
+  if [ -z "${DEBUG}" ]; then
+    echo "⚠️ PRERELEASE must be either unset, 'true' or 'false', but was '${PRERELEASE}'!"
+    exit 1
+  else
+    echo "⚠️ Would exit here with code '1', but DEBUG is enabled."
+  fi
+fi
+
+###
+# Calling Github to get the latest version
+###
+ORIGINAL_GITHUB_REPO="netbox-community/netbox"
+GITHUB_REPO="${GITHUB_REPO-$ORIGINAL_GITHUB_REPO}"
+URL_RELEASES="https://api.github.com/repos/${GITHUB_REPO}/releases"
+
+# Composing the JQ commans to extract the most recent version number
 JQ_LATEST="group_by(.prerelease) | .[] | sort_by(.published_at) | reverse | .[0] | select(.prerelease==${PRERELEASE-false}) | .tag_name"
 
-CURL="curl -sS"
+CURL="curl"
 
-VERSION=$($CURL "${URL_RELEASES}" | jq -r "${JQ_LATEST}")
+# Querying the Github API to fetch the most recent version number
+VERSION=$($CURL "${CURL_ARGS[@]}" "${URL_RELEASES}" | jq -r "${JQ_LATEST}" 2>/dev/null)
 
+###
 # Check if the prerelease version is actually higher than stable version
+###
 if [ "${PRERELEASE}" == "true" ]; then
   JQ_STABLE="group_by(.prerelease) | .[] | sort_by(.published_at) | reverse | .[0] | select(.prerelease==false) | .tag_name"
-  STABLE_VERSION=$($CURL "${URL_RELEASES}" | jq -r "${JQ_STABLE}")
+  STABLE_VERSION=$($CURL "${CURL_ARGS[@]}" "${URL_RELEASES}" | jq -r "${JQ_STABLE}" 2>/dev/null)
 
-  # shellcheck disable=SC2003
-  MAJOR_STABLE=$(expr match "${STABLE_VERSION}" 'v\([0-9]\+\)')
-  # shellcheck disable=SC2003
-  MINOR_STABLE=$(expr match "${STABLE_VERSION}" 'v[0-9]\+\.\([0-9]\+\)')
-  # shellcheck disable=SC2003
-  MAJOR_UNSTABLE=$(expr match "${VERSION}" 'v\([0-9]\+\)')
-  # shellcheck disable=SC2003
-  MINOR_UNSTABLE=$(expr match "${VERSION}" 'v[0-9]\+\.\([0-9]\+\)')
+  MAJOR_STABLE=$(expr "${STABLE_VERSION}" : 'v\([0-9]\+\)')
+  MINOR_STABLE=$(expr "${STABLE_VERSION}" : 'v[0-9]\+\.\([0-9]\+\)')
+  MAJOR_UNSTABLE=$(expr "${VERSION}" : 'v\([0-9]\+\)')
+  MINOR_UNSTABLE=$(expr "${VERSION}" : 'v[0-9]\+\.\([0-9]\+\)')
 
-  if ( [ "$MAJOR_STABLE" -eq "$MAJOR_UNSTABLE" ] && [ "$MINOR_STABLE" -ge "$MINOR_UNSTABLE" ] ) \
-     || [ "$MAJOR_STABLE" -gt "$MAJOR_UNSTABLE" ]; then
-    echo "❎ Latest unstable version ('$VERSION') is not higher than the latest stable version ('$STABLE_VERSION')."
+  if {
+    [ "${MAJOR_STABLE}" -eq "${MAJOR_UNSTABLE}" ] &&
+      [ "${MINOR_STABLE}" -ge "${MINOR_UNSTABLE}" ]
+  } || [ "${MAJOR_STABLE}" -gt "${MAJOR_UNSTABLE}" ]; then
+
+    echo "❎ Latest unstable version '${VERSION}' is not higher than the latest stable version '$STABLE_VERSION'."
     if [ -z "$DEBUG" ]; then
+      gh_out "skipped=true"
       exit 0
     else
       echo "⚠️ Would exit here with code '0', but DEBUG is enabled."
@@ -46,32 +80,6 @@ if [ "${PRERELEASE}" == "true" ]; then
   fi
 fi
 
-# Check if that version is not already available on docker hub:
-ORIGINAL_DOCKERHUB_REPO="${DOCKER_ORG-netboxcommunity}/${DOCKER_REPO-netbox}"
-DOCKERHUB_REPO="${DOCKERHUB_REPO-$ORIGINAL_DOCKERHUB_REPO}"
-URL_DOCKERHUB_TOKEN="https://auth.docker.io/token?service=registry.docker.io&scope=repository:${DOCKERHUB_REPO}:pull"
-BEARER_TOKEN="$($CURL "${URL_DOCKERHUB_TOKEN}" | jq -r .token)"
-
-URL_DOCKERHUB_TAG="https://registry.hub.docker.com/v2/${DOCKERHUB_REPO}/tags/list"
-AUTHORIZATION_HEADER="Authorization: Bearer ${BEARER_TOKEN}"
-
-if [ -z "$VARIANT" ] || [ "$VARIANT" == "main" ]; then
-  DOCKER_TAG="${VERSION}"
-else
-  DOCKER_TAG="${VERSION}-${VARIANT}"
-fi
-
-ALREADY_BUILT="$($CURL -H "${AUTHORIZATION_HEADER}" "${URL_DOCKERHUB_TAG}" | jq -e ".tags | any(.==\"${DOCKER_TAG}\")")"
-
-if [ -n "$DEBUG" ] || [ "$ALREADY_BUILT" == "false" ]; then
-  if [ -n "$DEBUG" ]; then
-    echo "⚠️ Would not build, because ${DOCKER_TAG} already exists on https://hub.docker.com/r/${DOCKERHUB_REPO}, but DEBUG is enabled."
-  fi
-  
-  # shellcheck disable=SC2068
-  ./build.sh "${VERSION}" $@
-  exit $?
-else
-  echo "✅ ${DOCKER_TAG} already exists on https://hub.docker.com/r/${DOCKERHUB_REPO}"
-  exit 0
-fi
+# shellcheck disable=SC2068
+./build.sh "${VERSION}" $@
+exit $?

build.sh

@@ -1,73 +1,132 @@
 #!/bin/bash
-# Builds the Dockerfile[.variant] and injects tgz'ed Netbox code from Github
+# Clones the NetBox repository with git from Github and builds the Dockerfile
 
 echo "▶️ $0 $*"
 
 set -e
 
 if [ "${1}x" == "x" ] || [ "${1}" == "--help" ] || [ "${1}" == "-h" ]; then
-  echo "Usage: ${0} <branch> [--push|--push-only]"
-  echo "  branch       The branch or tag to build. Required."
-  echo "  --push       Pushes built the Docker image to the registry."
-  echo "  --push-only  Does not build. Only pushes the Docker image to the registry."
-  echo ""
-  echo "You can use the following ENV variables to customize the build:"
-  echo "  DEBUG    If defined, the script does not stop when certain checks are unsatisfied."
-  echo "  DRY_RUN  Prints all build statements instead of running them."
-  echo "  DOCKER_OPTS Add parameters to Docker."
-  echo "           Default:"
-  echo "             When <TAG> starts with 'v':  \"\""
-  echo "             Else:                        \"--no-cache\""
-  echo "  BRANCH   The branch to build."
-  echo "           Also used for tagging the image."
-  echo "  TAG      The version part of the docker tag."
-  echo "           Default:"
-  echo "             When <BRANCH>=master:  latest"
-  echo "             When <BRANCH>=develop: snapshot"
-  echo "             Else:          same as <BRANCH>"
-  echo "  DOCKER_ORG The Docker registry (i.e. hub.docker.com/r/<DOCKER_ORG>/<DOCKER_REPO>) "
-  echo "           Also used for tagging the image."
-  echo "           Default: netboxcommunity"
-  echo "  DOCKER_REPO The Docker registry (i.e. hub.docker.com/r/<DOCKER_ORG>/<DOCKER_REPO>) "
-  echo "           Also used for tagging the image."
-  echo "           Default: netbox"
-  echo "  DOCKER_TAG The name of the tag which is applied to the image."
-  echo "           Useful for pushing into another registry than hub.docker.com."
-  echo "           Default: <DOCKER_ORG>/<DOCKER_REPO>:<BRANCH>"
-  echo "  DOCKER_SHORT_TAG The name of the short tag which is applied to the image."
-  echo "           This is used to tag all patch releases to their containing version e.g. v2.5.1 -> v2.5"
-  echo "           Default: <DOCKER_ORG>/<DOCKER_REPO>:\$MAJOR.\$MINOR"
-  echo "  SRC_ORG  Which fork of netbox to use (i.e. github.com/<SRC_ORG>/<SRC_REPO>)."
-  echo "           Default: digitalocean"
-  echo "  SRC_REPO The name of the netbox for to use (i.e. github.com/<SRC_ORG>/<SRC_REPO>)."
-  echo "           Default: netbox"
-  echo "  URL      Where to fetch the package from."
-  echo "           Must be a tar.gz file of the source code."
-  echo "           Default: https://github.com/<SRC_ORG>/<SRC_REPO>/archive/\$BRANCH.tar.gz"
-  echo "  VARIANT  The variant to build."
-  echo "           The value will be used as a suffix to the \$TAG and for the Dockerfile"
-  echo "           selection. The TAG being build must exist for the base variant and"
-  echo "           corresponding Dockerfile must start with the following lines:"
-  echo "             ARG DOCKER_ORG=netboxcommunity"
-  echo "             ARG DOCKER_REPO=netbox"
-  echo "             ARG FROM_TAG=latest"
-  echo "             FROM \$DOCKER_ORG/\$DOCKER_REPO:\$FROM_TAG"
-  echo "           Example: VARIANT=ldap will result in the tag 'latest-ldap' and the"
-  echo "           Dockerfile './Dockerfile.ldap' being used."
-  echo "           Exception: VARIANT=main will use the './Dockerfile' Dockerfile"
-  echo "           Default: main"
-  echo "  HTTP_PROXY The proxy to use for http requests."
-  echo "           Example: http://proxy.domain.tld:3128"
-  echo "           Default: empty"
-  echo "  HTTPS_PROXY The proxy to use for https requests."
-  echo "           Example: http://proxy.domain.tld:3128"
-  echo "           Default: empty"
-  echo "  FTP_PROXY The proxy to use for ftp requests."
-  echo "           Example: http://proxy.domain.tld:3128"
-  echo "           Default: empty"
-  echo "  NO_PROXY Comma-separated list of domain extensions proxy should not be used for."
-  echo "           Example: .domain1.tld,.domain2.tld"
-  echo "           Default: empty"
+  _BOLD=$(tput bold)
+  _GREEN=$(tput setaf 2)
+  _CYAN=$(tput setaf 6)
+  _CLEAR=$(tput sgr0)
+
+  cat <<END_OF_HELP
+${_BOLD}Usage:${_CLEAR} ${0} <branch> [--push]
+
+branch       The branch or tag to build. Required.
+--push       Pushes the built container image to the registry.
+
+${_BOLD}You can use the following ENV variables to customize the build:${_CLEAR}
+
+SRC_ORG     Which fork of netbox to use (i.e. github.com/\${SRC_ORG}/\${SRC_REPO}).
+            ${_GREEN}Default:${_CLEAR} netbox-community
+            
+SRC_REPO    The name of the repository to use (i.e. github.com/\${SRC_ORG}/\${SRC_REPO}).
+            ${_GREEN}Default:${_CLEAR} netbox
+            
+URL         Where to fetch the code from.
+            Must be a git repository. Can be private.
+            ${_GREEN}Default:${_CLEAR} https://github.com/\${SRC_ORG}/\${SRC_REPO}.git
+
+NETBOX_PATH The path where netbox will be checkout out.
+            Must not be outside of the netbox-docker repository (because of Docker)!
+            ${_GREEN}Default:${_CLEAR} .netbox
+
+SKIP_GIT    If defined, git is not invoked and \${NETBOX_PATH} will not be altered.
+            This may be useful, if you are manually managing the NETBOX_PATH.
+            ${_GREEN}Default:${_CLEAR} undefined
+
+TAG         The version part of the image tag.
+            ${_GREEN}Default:${_CLEAR}
+              When <branch>=main: snapshot
+              Else:               same as <branch>
+
+IMAGE_NAMES The names used for the image including the registry
+            Used for tagging the image.
+            ${_GREEN}Default:${_CLEAR} docker.io/netboxcommunity/netbox
+            ${_CYAN}Example:${_CLEAR} 'docker.io/netboxcommunity/netbox quay.io/netboxcommunity/netbox'
+
+DOCKER_TAG  The name of the tag which is applied to the image.
+            Useful for pushing into another registry than hub.docker.com.
+            ${_GREEN}Default:${_CLEAR} \${DOCKER_REGISTRY}/\${DOCKER_ORG}/\${DOCKER_REPO}:\${TAG}
+
+DOCKER_SHORT_TAG The name of the short tag which is applied to the
+            image. This is used to tag all patch releases to their
+            containing version e.g. v2.5.1 -> v2.5
+            ${_GREEN}Default:${_CLEAR} \${DOCKER_REGISTRY}/\${DOCKER_ORG}/\${DOCKER_REPO}:<MAJOR>.<MINOR>
+
+DOCKERFILE  The name of Dockerfile to use.
+            ${_GREEN}Default:${_CLEAR} Dockerfile
+
+DOCKER_FROM The base image to use.
+            ${_GREEN}Default:${_CLEAR} 'ubuntu:24.04'
+
+BUILDX_PLATFORMS
+            Specifies the platform(s) to build the image for.
+            ${_CYAN}Example:${_CLEAR} 'linux/amd64,linux/arm64'
+            ${_GREEN}Default:${_CLEAR} 'linux/amd64'
+
+BUILDX_BUILDER_NAME
+            If defined, the image build will be assigned to the given builder.
+            If you specify this variable, make sure that the builder exists.
+            If this value is not defined, a new builx builder with the directory name of the
+            current directory (i.e. '$(basename "${PWD}")') is created."
+            ${_CYAN}Example:${_CLEAR} 'clever_lovelace'
+            ${_GREEN}Default:${_CLEAR} undefined
+
+BUILDX_REMOVE_BUILDER
+            If defined (and only if BUILDX_BUILDER_NAME is undefined),
+            then the buildx builder created by this script will be removed after use.
+            This is useful if you build NetBox Docker on an automated system that does
+            not manage the builders for you.
+            ${_CYAN}Example:${_CLEAR} 'on'
+            ${_GREEN}Default:${_CLEAR} undefined
+
+HTTP_PROXY  The proxy to use for http requests.
+            ${_CYAN}Example:${_CLEAR} http://proxy.domain.tld:3128
+            ${_GREEN}Default:${_CLEAR} undefined
+
+NO_PROXY    Comma-separated list of domain extensions proxy should not be used for.
+            ${_CYAN}Example:${_CLEAR} .domain1.tld,.domain2.tld
+            ${_GREEN}Default:${_CLEAR} undefined
+
+DEBUG       If defined, the script does not stop when certain checks are unsatisfied.
+            ${_GREEN}Default:${_CLEAR} undefined
+
+DRY_RUN     Prints all build statements instead of running them.
+            ${_GREEN}Default:${_CLEAR} undefined
+            
+GH_ACTION   If defined, special 'echo' statements are enabled that set the
+            following environment variables in Github Actions:
+            - FINAL_DOCKER_TAG: The final value of the DOCKER_TAG env variable
+            ${_GREEN}Default:${_CLEAR} undefined
+
+CHECK_ONLY  Only checks if the build is needed and sets the GH Action output.
+            ${_GREEN}Default:${_CLEAR} undefined
+
+${_BOLD}Examples:${_CLEAR}
+
+${0} main
+            This will fetch the latest 'main' branch, build a Docker Image and tag it
+            'netboxcommunity/netbox:snapshot'.
+
+${0} v4.2.0
+            This will fetch the 'v4.2.0' tag, build a Docker Image and tag it
+            'netboxcommunity/netbox:v4.2.0' and 'netboxcommunity/netbox:v4.2'.
+
+${0} feature
+            This will fetch the 'feature' branch, build a Docker Image and tag it
+            'netboxcommunity/netbox:feature'.
+
+SRC_ORG=cimnine ${0} feature-x
+            This will fetch the 'feature-x' branch from https://github.com/cimnine/netbox.git,
+            build a Docker Image and tag it 'netboxcommunity/netbox:feature-x'.
+
+SRC_ORG=cimnine DOCKER_ORG=cimnine ${0} feature-x
+            This will fetch the 'feature-x' branch from https://github.com/cimnine/netbox.git,
+            build a Docker Image and tag it 'cimnine/netbox:feature-x'.
+END_OF_HELP
 
   if [ "${1}x" == "x" ]; then
     exit 1
@@ -76,122 +135,324 @@ if [ "${1}x" == "x" ] || [ "${1}" == "--help" ] || [ "${1}" == "-h" ]; then
   fi
 fi
 
-# read the project version and trim it
-# see https://stackoverflow.com/a/3232433/172132
-NETBOX_DOCKER_PROJECT_VERSION="${NETBOX_DOCKER_PROJECT_VERSION-$(sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' VERSION)}"
+# Check if we have everything needed for the build
+source ./build-functions/check-commands.sh
+# Load all build functions
+source ./build-functions/get-public-image-config.sh
+source ./build-functions/gh-functions.sh
 
-# variables for fetching the source
-SRC_ORG="${SRC_ORG-digitalocean}"
-SRC_REPO="${SRC_REPO-netbox}"
-BRANCH="${1}"
-URL="${URL-https://github.com/${SRC_ORG}/${SRC_REPO}/archive/$BRANCH.tar.gz}"
+IMAGE_NAMES="${IMAGE_NAMES-docker.io/netboxcommunity/netbox}"
+IFS=' ' read -ra IMAGE_NAMES <<<"${IMAGE_NAMES}"
 
-# Checking which VARIANT to build
-VARIANT="${VARIANT-main}"
-if [ "$VARIANT" == "main" ]; then
-  DOCKERFILE="Dockerfile"
+###
+# Enabling dry-run mode
+###
+if [ -z "${DRY_RUN}" ]; then
+  DRY=""
 else
-  DOCKERFILE="Dockerfile.${VARIANT}"
+  echo "⚠️ DRY_RUN MODE ON ⚠️"
+  DRY="echo"
 fi
 
-# Fail fast
-if [ ! -f "${DOCKERFILE}" ]; then
-  echo "🚨 The Dockerfile ${DOCKERFILE} for variant '${VARIANT}' doesn't exist."
+gh_echo "::group::⤵️ Fetching the NetBox source code"
 
-  if [ -z "$DEBUG" ]; then
+###
+# Variables for fetching the NetBox source
+###
+SRC_ORG="${SRC_ORG-netbox-community}"
+SRC_REPO="${SRC_REPO-netbox}"
+NETBOX_BRANCH="${1}"
+URL="${URL-https://github.com/${SRC_ORG}/${SRC_REPO}.git}"
+NETBOX_PATH="${NETBOX_PATH-.netbox}"
+
+###
+# Fetching the NetBox source
+###
+if [ "${2}" != "--push-only" ] && [ -z "${SKIP_GIT}" ]; then
+  REMOTE_EXISTS=$(git ls-remote --heads --tags "${URL}" "${NETBOX_BRANCH}" | wc -l)
+  if [ "${REMOTE_EXISTS}" == "0" ]; then
+    echo "❌ Remote branch '${NETBOX_BRANCH}' not found in '${URL}'; Nothing to do"
+    gh_out "skipped=true"
+    exit 0
+  fi
+  echo "🌐 Checking out '${NETBOX_BRANCH}' of NetBox from the url '${URL}' into '${NETBOX_PATH}'"
+  if [ ! -d "${NETBOX_PATH}" ]; then
+    $DRY git clone -q --depth 10 -b "${NETBOX_BRANCH}" "${URL}" "${NETBOX_PATH}"
+  fi
+
+  (
+    $DRY cd "${NETBOX_PATH}"
+    # shellcheck disable=SC2030
+    if [ -n "${HTTP_PROXY}" ]; then
+      git config http.proxy "${HTTP_PROXY}"
+    fi
+
+    $DRY git remote set-url origin "${URL}"
+    $DRY git fetch -qp --depth 10 origin "${NETBOX_BRANCH}"
+    $DRY git checkout -qf FETCH_HEAD
+    $DRY git prune
+  )
+  echo "✅ Checked out NetBox"
+fi
+
+gh_echo "::endgroup::"
+gh_echo "::group::🧮 Calculating Values"
+
+###
+# Determining the value for DOCKERFILE
+# and checking whether it exists
+###
+DOCKERFILE="${DOCKERFILE-Dockerfile}"
+if [ ! -f "${DOCKERFILE}" ]; then
+  echo "🚨 The Dockerfile ${DOCKERFILE} doesn't exist."
+
+  if [ -z "${DEBUG}" ]; then
     exit 1
   else
     echo "⚠️ Would exit here with code '1', but DEBUG is enabled."
   fi
 fi
 
-# variables for tagging the docker image
-DOCKER_ORG="${DOCKER_ORG-netboxcommunity}"
-DOCKER_REPO="${DOCKER_REPO-netbox}"
-case "${BRANCH}" in
-  master)
-    TAG="${TAG-latest}";;
-  develop)
-    TAG="${TAG-snapshot}";;
-  *)
-    TAG="${TAG-$BRANCH}";;
-esac
-
-DOCKER_TAG="${DOCKER_TAG-${DOCKER_ORG}/${DOCKER_REPO}:${TAG}}"
-if [ "$VARIANT" != "main" ]; then
-  DOCKER_TAG="${DOCKER_TAG}-${VARIANT}"
+###
+# Determining the value for DOCKER_FROM
+###
+if [ -z "$DOCKER_FROM" ]; then
+  DOCKER_FROM="docker.io/ubuntu:24.04"
 fi
 
+###
+# Variables for labelling the docker image
+###
+BUILD_DATE="$(date -u '+%Y-%m-%dT%H:%M+00:00')"
+
+if [ -d ".git" ] && [ -z "${SKIP_GIT}" ]; then
+  GIT_REF="$(git rev-parse HEAD)"
+fi
+
+# Read the project version from the `VERSION` file and trim it, see https://stackoverflow.com/a/3232433/172132
+PROJECT_VERSION="${PROJECT_VERSION-$(sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' VERSION)}"
+
+# Get the Git information from the netbox directory
+if [ -d "${NETBOX_PATH}/.git" ] && [ -z "${SKIP_GIT}" ]; then
+  NETBOX_GIT_REF=$(
+    cd "${NETBOX_PATH}"
+    git rev-parse HEAD
+  )
+  NETBOX_GIT_BRANCH=$(
+    cd "${NETBOX_PATH}"
+    git rev-parse --abbrev-ref HEAD
+  )
+  NETBOX_GIT_URL=$(
+    cd "${NETBOX_PATH}"
+    git remote get-url origin
+  )
+fi
+
+###
+# Variables for tagging the docker image
+###
+DOCKER_REGISTRY="${DOCKER_REGISTRY-docker.io}"
+DOCKER_ORG="${DOCKER_ORG-netboxcommunity}"
+DOCKER_REPO="${DOCKER_REPO-netbox}"
+case "${NETBOX_BRANCH}" in
+main)
+  TAG="${TAG-snapshot}"
+  ;;
+*)
+  TAG="${TAG-$NETBOX_BRANCH}"
+  ;;
+esac
+
+###
+# composing the final TARGET_DOCKER_TAG
+###
+TARGET_DOCKER_TAG="${DOCKER_TAG-${TAG}}"
+TARGET_DOCKER_TAG_PROJECT="${TARGET_DOCKER_TAG}-${PROJECT_VERSION}"
+
+###
+# composing the additional DOCKER_SHORT_TAG,
+# i.e. "v4.2.0" becomes "v4.2",
+# which is only relevant for version tags
+# Also let "latest" follow the highest version
+###
 if [[ "${TAG}" =~ ^v([0-9]+)\.([0-9]+)\.[0-9]+$ ]]; then
   MAJOR=${BASH_REMATCH[1]}
   MINOR=${BASH_REMATCH[2]}
 
-  DOCKER_SHORT_TAG="${DOCKER_SHORT_TAG-${DOCKER_ORG}/${DOCKER_REPO}:v${MAJOR}.${MINOR}}"
-
-  if [ "$VARIANT" != "main" ]; then
-    DOCKER_SHORT_TAG="${DOCKER_SHORT_TAG}-${VARIANT}"
-  fi
+  TARGET_DOCKER_SHORT_TAG="${DOCKER_SHORT_TAG-v${MAJOR}.${MINOR}}"
+  TARGET_DOCKER_LATEST_TAG="latest"
+  TARGET_DOCKER_SHORT_TAG_PROJECT="${TARGET_DOCKER_SHORT_TAG}-${PROJECT_VERSION}"
+  TARGET_DOCKER_LATEST_TAG_PROJECT="${TARGET_DOCKER_LATEST_TAG}-${PROJECT_VERSION}"
 fi
 
-DOCKER_OPTS=("${DOCKER_OPTS[@]}")
-
-# caching is only ok for version tags
-case "${TAG}" in
- v*) ;;
- *)  DOCKER_OPTS+=( "--no-cache" ) ;;
-esac
-
-DOCKER_OPTS+=( "--pull" )
-
-# Build args
-DOCKER_BUILD_ARGS=(
-  --build-arg "NETBOX_DOCKER_PROJECT_VERSION=${NETBOX_DOCKER_PROJECT_VERSION}"
-  --build-arg "FROM_TAG=${TAG}"
-  --build-arg "BRANCH=${BRANCH}"
-  --build-arg "URL=${URL}"
-  --build-arg "DOCKER_ORG=${DOCKER_ORG}"
-  --build-arg "DOCKER_REPO=${DOCKER_REPO}"
-)
-if [ -n "$HTTP_PROXY" ]; then
-  DOCKER_BUILD_ARGS+=( --build-arg "http_proxy=${HTTP_PROXY}" )
-fi
-if [ -n "$HTTPS_PROXY" ]; then
-  DOCKER_BUILD_ARGS+=( --build-arg "https_proxy=${HTTPS_PROXY}" )
-fi
-if [ -n "$FTP_PROXY" ]; then
-  DOCKER_BUILD_ARGS+=( --build-arg "ftp_proxy=${FTP_PROXY}" )
-fi
-if [ -n "$NO_PROXY" ]; then
-  DOCKER_BUILD_ARGS+=( --build-arg "no_proxy=${NO_PROXY}" )
+IMAGE_NAME_TAGS=()
+for IMAGE_NAME in "${IMAGE_NAMES[@]}"; do
+  IMAGE_NAME_TAGS+=("${IMAGE_NAME}:${TARGET_DOCKER_TAG}")
+  IMAGE_NAME_TAGS+=("${IMAGE_NAME}:${TARGET_DOCKER_TAG_PROJECT}")
+done
+if [ -n "${TARGET_DOCKER_SHORT_TAG}" ]; then
+  for IMAGE_NAME in "${IMAGE_NAMES[@]}"; do
+    IMAGE_NAME_TAGS+=("${IMAGE_NAME}:${TARGET_DOCKER_SHORT_TAG}")
+    IMAGE_NAME_TAGS+=("${IMAGE_NAME}:${TARGET_DOCKER_SHORT_TAG_PROJECT}")
+    IMAGE_NAME_TAGS+=("${IMAGE_NAME}:${TARGET_DOCKER_LATEST_TAG}")
+    IMAGE_NAME_TAGS+=("${IMAGE_NAME}:${TARGET_DOCKER_LATEST_TAG_PROJECT}")
+  done
 fi
 
-if [ -z "$DRY_RUN" ]; then
-  DOCKER_CMD="docker"
+FINAL_DOCKER_TAG="${IMAGE_NAME_TAGS[0]}"
+gh_env "FINAL_DOCKER_TAG=${IMAGE_NAME_TAGS[0]}"
+
+###
+# Checking if the build is necessary,
+# meaning build only if one of those values changed:
+# - a new tag is beeing created
+# - base image digest
+# - netbox git ref (Label: netbox.git-ref)
+# - netbox-docker git ref (Label: org.opencontainers.image.revision)
+###
+# Load information from registry (only for first registry in "IMAGE_NAMES")
+SHOULD_BUILD="false"
+BUILD_REASON=""
+if [ -z "${GH_ACTION}" ]; then
+  # Asuming non Github builds should always proceed
+  SHOULD_BUILD="true"
+  BUILD_REASON="${BUILD_REASON} interactive"
+elif [ "false" == "$(check_if_tags_exists "${IMAGE_NAMES[0]}" "$TARGET_DOCKER_TAG")" ]; then
+  SHOULD_BUILD="true"
+  BUILD_REASON="${BUILD_REASON} newtag"
 else
-  echo "⚠️ DRY_RUN MODE ON ⚠️"
-  DOCKER_CMD="echo docker"
-fi
+  echo "Checking labels for '${FINAL_DOCKER_TAG}'"
+  BASE_LAST_LAYER=$(get_image_last_layer "${DOCKER_FROM}")
+  OLD_BASE_LAST_LAYER=$(get_image_label netbox.last-base-image-layer "${FINAL_DOCKER_TAG}")
+  NETBOX_GIT_REF_OLD=$(get_image_label netbox.git-ref "${FINAL_DOCKER_TAG}")
+  GIT_REF_OLD=$(get_image_label org.opencontainers.image.revision "${FINAL_DOCKER_TAG}")
 
-if [ "${2}" != "--push-only" ] ; then
-  echo "🐳 Building the Docker image '${DOCKER_TAG}' from the url '${URL}'."
-  $DOCKER_CMD build -t "${DOCKER_TAG}" "${DOCKER_BUILD_ARGS[@]}" "${DOCKER_OPTS[@]}" -f "${DOCKERFILE}" .
-  echo "✅ Finished building the Docker images '${DOCKER_TAG}'"
-
-  if [ -n "$DOCKER_SHORT_TAG" ]; then
-    echo "🐳 Tagging image '${DOCKER_SHORT_TAG}'."
-    $DOCKER_CMD tag "${DOCKER_TAG}" "${DOCKER_SHORT_TAG}"
-    echo "✅ Tagged image '${DOCKER_SHORT_TAG}'"
+  if [ "${BASE_LAST_LAYER}" != "${OLD_BASE_LAST_LAYER}" ]; then
+    SHOULD_BUILD="true"
+    BUILD_REASON="${BUILD_REASON} ubuntu"
+  fi
+  if [ "${NETBOX_GIT_REF}" != "${NETBOX_GIT_REF_OLD}" ]; then
+    SHOULD_BUILD="true"
+    BUILD_REASON="${BUILD_REASON} netbox"
+  fi
+  if [ "${GIT_REF}" != "${GIT_REF_OLD}" ]; then
+    SHOULD_BUILD="true"
+    BUILD_REASON="${BUILD_REASON} netbox-docker"
   fi
 fi
 
-if [ "${2}" == "--push" ] || [ "${2}" == "--push-only" ] ; then
-  echo "⏫ Pushing '${DOCKER_TAG}"
-  $DOCKER_CMD push "${DOCKER_TAG}"
-  echo "✅ Finished pushing the Docker image '${DOCKER_TAG}'."
-
-  if [ -n "$DOCKER_SHORT_TAG" ]; then
-    echo "⏫ Pushing '${DOCKER_SHORT_TAG}'"
-    $DOCKER_CMD push "${DOCKER_SHORT_TAG}"
-    echo "✅ Finished pushing the Docker image '${DOCKER_SHORT_TAG}'."
-  fi
+if [ "${SHOULD_BUILD}" != "true" ]; then
+  echo "Build skipped because sources didn't change"
+  gh_out "skipped=true"
+  exit 0 # Nothing to do -> exit
+else
+  gh_out "skipped=false"
 fi
+gh_echo "::endgroup::"
+
+if [ "${CHECK_ONLY}" = "true" ]; then
+  echo "Only check if build needed was requested. Exiting"
+  exit 0
+fi
+
+###
+# Build the image
+###
+gh_echo "::group::🏗 Building the image"
+###
+# Composing all arguments for `docker build`
+###
+DOCKER_BUILD_ARGS=(
+  --pull
+  --target main
+  -f "${DOCKERFILE}"
+)
+for IMAGE_NAME in "${IMAGE_NAME_TAGS[@]}"; do
+  DOCKER_BUILD_ARGS+=(-t "${IMAGE_NAME}")
+done
+
+# --label
+DOCKER_BUILD_ARGS+=(
+  --label "netbox.original-tag=${TARGET_DOCKER_TAG_PROJECT}"
+  --label "org.opencontainers.image.created=${BUILD_DATE}"
+  --label "org.opencontainers.image.version=${PROJECT_VERSION}"
+)
+if [ -d ".git" ] && [ -z "${SKIP_GIT}" ]; then
+  DOCKER_BUILD_ARGS+=(
+    --label "org.opencontainers.image.revision=${GIT_REF}"
+  )
+fi
+if [ -d "${NETBOX_PATH}/.git" ] && [ -z "${SKIP_GIT}" ]; then
+  DOCKER_BUILD_ARGS+=(
+    --label "netbox.git-branch=${NETBOX_GIT_BRANCH}"
+    --label "netbox.git-ref=${NETBOX_GIT_REF}"
+    --label "netbox.git-url=${NETBOX_GIT_URL}"
+  )
+fi
+if [ -n "${BUILD_REASON}" ]; then
+  BUILD_REASON=$(sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' <<<"$BUILD_REASON")
+  DOCKER_BUILD_ARGS+=(--label "netbox.build-reason=${BUILD_REASON}")
+  DOCKER_BUILD_ARGS+=(--label "netbox.last-base-image-layer=${BASE_LAST_LAYER}")
+fi
+
+# --build-arg
+DOCKER_BUILD_ARGS+=(--build-arg "NETBOX_PATH=${NETBOX_PATH}")
+
+if [ -n "${DOCKER_FROM}" ]; then
+  DOCKER_BUILD_ARGS+=(--build-arg "FROM=${DOCKER_FROM}")
+fi
+# shellcheck disable=SC2031
+if [ -n "${HTTP_PROXY}" ]; then
+  DOCKER_BUILD_ARGS+=(--build-arg "http_proxy=${HTTP_PROXY}")
+  DOCKER_BUILD_ARGS+=(--build-arg "https_proxy=${HTTPS_PROXY}")
+fi
+if [ -n "${NO_PROXY}" ]; then
+  DOCKER_BUILD_ARGS+=(--build-arg "no_proxy=${NO_PROXY}")
+fi
+
+DOCKER_BUILD_ARGS+=(--platform "${BUILDX_PLATFORM-linux/amd64}")
+if [ "${2}" == "--push" ]; then
+  # output type=docker does not work with pushing
+  DOCKER_BUILD_ARGS+=(
+    --output=type=image
+    --push
+  )
+else
+  DOCKER_BUILD_ARGS+=(
+    --output=type=docker
+  )
+fi
+
+###
+# Building the docker image
+###
+if [ -z "${BUILDX_BUILDER_NAME}" ]; then
+  BUILDX_BUILDER_NAME="$(basename "${PWD}")"
+fi
+if ! docker buildx ls | grep --quiet --word-regexp "${BUILDX_BUILDER_NAME}"; then
+  echo "👷  Creating new Buildx Builder '${BUILDX_BUILDER_NAME}'"
+  $DRY docker buildx create --name "${BUILDX_BUILDER_NAME}"
+  BUILDX_BUILDER_CREATED="yes"
+fi
+
+echo "🐳 Building the Docker image '${TARGET_DOCKER_TAG_PROJECT}'."
+echo "    Build reason set to: ${BUILD_REASON}"
+$DRY docker buildx \
+  --builder "${BUILDX_BUILDER_NAME}" \
+  build \
+  "${DOCKER_BUILD_ARGS[@]}" \
+  .
+echo "✅ Finished building the Docker images"
+gh_echo "::endgroup::" # End group for Build
+
+gh_echo "::group::🏗 Image Labels"
+echo "🔎 Inspecting labels on '${IMAGE_NAME_TAGS[0]}'"
+$DRY docker inspect "${IMAGE_NAME_TAGS[0]}" --format "{{json .Config.Labels}}" | jq
+gh_echo "::endgroup::"
+
+gh_echo "::group::🏗 Clean up"
+if [ -n "${BUILDX_REMOVE_BUILDER}" ] && [ "${BUILDX_BUILDER_CREATED}" == "yes" ]; then
+  echo "👷  Removing Buildx Builder '${BUILDX_BUILDER_NAME}'"
+  $DRY docker buildx rm "${BUILDX_BUILDER_NAME}"
+fi
+gh_echo "::endgroup::"

configuration/configuration.py

@@ -1,20 +1,51 @@
-import os
-import socket
+####
+## We recommend to not edit this file.
+## Create separate files to overwrite the settings.
+## See `extra.py` as an example.
+####
 
-# For reference see http://netbox.readthedocs.io/en/latest/configuration/mandatory-settings/
-# Based on https://github.com/digitalocean/netbox/blob/develop/netbox/netbox/configuration.example.py
+import re
+from os import environ
+from os.path import abspath, dirname, join
+from typing import Any, Callable, Tuple
+
+# For reference see https://docs.netbox.dev/en/stable/configuration/
+# Based on https://github.com/netbox-community/netbox/blob/develop/netbox/netbox/configuration_example.py
+
+###
+# NetBox-Docker Helper functions
+###
 
 # Read secret from file
-def read_secret(secret_name):
+def _read_secret(secret_name: str, default: str | None = None) -> str | None:
     try:
         f = open('/run/secrets/' + secret_name, 'r', encoding='utf-8')
     except EnvironmentError:
-        return ''
+        return default
     else:
         with f:
             return f.readline().strip()
 
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# If the `map_fn` isn't defined, then the value that is read from the environment (or the default value if not found) is returned.
+# If the `map_fn` is defined, then `map_fn` is invoked and the value (that was read from the environment or the default value if not found)
+# is passed to it as a parameter. The value returned from `map_fn` is then the return value of this function.
+# The `map_fn` is not invoked, if the value (that was read from the environment or the default value if not found) is None.
+def _environ_get_and_map(variable_name: str, default: str | None = None, map_fn: Callable[[str], Any | None] = None) -> Any | None:
+    env_value = environ.get(variable_name, default)
+
+    if env_value == None:
+        return env_value
+
+    if not map_fn:
+        return env_value
+    
+    return map_fn(env_value)
+
+_AS_BOOL = lambda value : value.lower() == 'true'
+_AS_INT = lambda value : int(value)
+_AS_LIST = lambda value : list(filter(None, value.split(' ')))
+
+_BASE_DIR = dirname(dirname(abspath(__file__)))
 
 #########################
 #                       #
@@ -26,23 +57,63 @@ BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 # access to the server via any other hostnames. The first FQDN in the list will be treated as the preferred name.
 #
 # Example: ALLOWED_HOSTS = ['netbox.example.com', 'netbox.internal.local']
-ALLOWED_HOSTS = os.environ.get('ALLOWED_HOSTS', '*').split(' ')
+ALLOWED_HOSTS = environ.get('ALLOWED_HOSTS', '*').split(' ')
+# ensure that '*' or 'localhost' is always in ALLOWED_HOSTS (needed for health checks)
+if '*' not in ALLOWED_HOSTS and 'localhost' not in ALLOWED_HOSTS:
+    ALLOWED_HOSTS.append('localhost')
 
-# PostgreSQL database configuration.
+# PostgreSQL database configuration. See the Django documentation for a complete list of available parameters:
+#   https://docs.djangoproject.com/en/stable/ref/settings/#databases
 DATABASE = {
-    'NAME': os.environ.get('DB_NAME', 'netbox'),         # Database name
-    'USER': os.environ.get('DB_USER', ''),               # PostgreSQL username
-    'PASSWORD': os.environ.get('DB_PASSWORD', read_secret('db_password')),
-                                                         # PostgreSQL password
-    'HOST': os.environ.get('DB_HOST', 'localhost'),      # Database server
-    'PORT': os.environ.get('DB_PORT', ''),               # Database port (leave blank for default)
+    'NAME': environ.get('DB_NAME', 'netbox'),       # Database name
+    'USER': environ.get('DB_USER', ''),             # PostgreSQL username
+    'PASSWORD': _read_secret('db_password', environ.get('DB_PASSWORD', '')),
+                                                    # PostgreSQL password
+    'HOST': environ.get('DB_HOST', 'localhost'),    # Database server
+    'PORT': environ.get('DB_PORT', ''),             # Database port (leave blank for default)
+    'OPTIONS': {'sslmode': environ.get('DB_SSLMODE', 'prefer')},
+                                                    # Database connection SSLMODE
+    'CONN_MAX_AGE': _environ_get_and_map('DB_CONN_MAX_AGE', '300', _AS_INT),
+                                                    # Max database connection age
+    'DISABLE_SERVER_SIDE_CURSORS': _environ_get_and_map('DB_DISABLE_SERVER_SIDE_CURSORS', 'False', _AS_BOOL),
+                                                    # Disable the use of server-side cursors transaction pooling
+}
+
+# Redis database settings. Redis is used for caching and for queuing background tasks such as webhook events. A separate
+# configuration exists for each. Full connection details are required in both sections, and it is strongly recommended
+# to use two separate database IDs.
+REDIS = {
+    'tasks': {
+        'HOST': environ.get('REDIS_HOST', 'localhost'),
+        'PORT': _environ_get_and_map('REDIS_PORT', 6379, _AS_INT),
+        'SENTINELS': [tuple(uri.split(':')) for uri in _environ_get_and_map('REDIS_SENTINELS', '', _AS_LIST) if uri != ''],
+        'SENTINEL_SERVICE': environ.get('REDIS_SENTINEL_SERVICE', 'default'),
+        'SENTINEL_TIMEOUT': _environ_get_and_map('REDIS_SENTINEL_TIMEOUT', 10, _AS_INT),
+        'USERNAME': environ.get('REDIS_USERNAME', ''),
+        'PASSWORD': _read_secret('redis_password', environ.get('REDIS_PASSWORD', '')),
+        'DATABASE': _environ_get_and_map('REDIS_DATABASE', 0, _AS_INT),
+        'SSL': _environ_get_and_map('REDIS_SSL', 'False', _AS_BOOL),
+        'INSECURE_SKIP_TLS_VERIFY': _environ_get_and_map('REDIS_INSECURE_SKIP_TLS_VERIFY', 'False', _AS_BOOL),
+    },
+    'caching': {
+        'HOST': environ.get('REDIS_CACHE_HOST', environ.get('REDIS_HOST', 'localhost')),
+        'PORT': _environ_get_and_map('REDIS_CACHE_PORT', environ.get('REDIS_PORT', '6379'), _AS_INT),
+        'SENTINELS': [tuple(uri.split(':')) for uri in _environ_get_and_map('REDIS_CACHE_SENTINELS', '', _AS_LIST) if uri != ''],
+        'SENTINEL_SERVICE': environ.get('REDIS_CACHE_SENTINEL_SERVICE', environ.get('REDIS_SENTINEL_SERVICE', 'default')),
+        'USERNAME': environ.get('REDIS_CACHE_USERNAME', environ.get('REDIS_USERNAME', '')),
+        'PASSWORD': _read_secret('redis_cache_password', environ.get('REDIS_CACHE_PASSWORD', environ.get('REDIS_PASSWORD', ''))),
+        'DATABASE': _environ_get_and_map('REDIS_CACHE_DATABASE', '1', _AS_INT),
+        'SSL': _environ_get_and_map('REDIS_CACHE_SSL', environ.get('REDIS_SSL', 'False'), _AS_BOOL),
+        'INSECURE_SKIP_TLS_VERIFY': _environ_get_and_map('REDIS_CACHE_INSECURE_SKIP_TLS_VERIFY', environ.get('REDIS_INSECURE_SKIP_TLS_VERIFY', 'False'), _AS_BOOL),
+    },
 }
 
 # This key is used for secure generation of random numbers and strings. It must never be exposed outside of this file.
 # For optimal security, SECRET_KEY should be at least 50 characters in length and contain a mix of letters, numbers, and
 # symbols. NetBox will not run without this defined. For more information, see
-# https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-SECRET_KEY
-SECRET_KEY = os.environ.get('SECRET_KEY', read_secret('secret_key'))
+# https://docs.djangoproject.com/en/stable/ref/settings/#std:setting-SECRET_KEY
+SECRET_KEY = _read_secret('secret_key', environ.get('SECRET_KEY', ''))
+
 
 #########################
 #                       #
@@ -50,117 +121,232 @@ SECRET_KEY = os.environ.get('SECRET_KEY', read_secret('secret_key'))
 #                       #
 #########################
 
-# Specify one or more name and email address tuples representing NetBox administrators. These people will be notified of
-# application errors (assuming correct email settings are provided).
-ADMINS = [
-    # ['John Doe', 'jdoe@example.com'],
-]
+# # Specify one or more name and email address tuples representing NetBox administrators. These people will be notified of
+# # application errors (assuming correct email settings are provided).
+# ADMINS = [
+#    # ['John Doe', 'jdoe@example.com'],
+# ]
+
+if 'ALLOWED_URL_SCHEMES' in environ:
+    ALLOWED_URL_SCHEMES = _environ_get_and_map('ALLOWED_URL_SCHEMES', None, _AS_LIST)
 
 # Optionally display a persistent banner at the top and/or bottom of every page. HTML is allowed. To display the same
 # content in both banners, define BANNER_TOP and set BANNER_BOTTOM = BANNER_TOP.
-BANNER_TOP = os.environ.get('BANNER_TOP', '')
-BANNER_BOTTOM = os.environ.get('BANNER_BOTTOM', '')
+if 'BANNER_TOP' in environ:
+    BANNER_TOP = environ.get('BANNER_TOP', None)
+if 'BANNER_BOTTOM' in environ:
+    BANNER_BOTTOM = environ.get('BANNER_BOTTOM', None)
 
 # Text to include on the login page above the login form. HTML is allowed.
-BANNER_LOGIN = os.environ.get('BANNER_LOGIN', '')
+if 'BANNER_LOGIN' in environ:
+    BANNER_LOGIN = environ.get('BANNER_LOGIN', None)
 
-# Base URL path if accessing NetBox within a directory. For example, if installed at http://example.com/netbox/, set:
-# BASE_PATH = 'netbox/'
-BASE_PATH = os.environ.get('BASE_PATH', '')
+# Maximum number of days to retain logged changes. Set to 0 to retain changes indefinitely. (Default: 90)
+if 'CHANGELOG_RETENTION' in environ:
+    CHANGELOG_RETENTION = _environ_get_and_map('CHANGELOG_RETENTION', None, _AS_INT)
+
+# Maximum number of days to retain job results (scripts and reports). Set to 0 to retain job results in the database indefinitely. (Default: 90)
+if 'JOB_RETENTION' in environ:
+    JOB_RETENTION = _environ_get_and_map('JOB_RETENTION', None, _AS_INT)
+# JOBRESULT_RETENTION was renamed to JOB_RETENTION in the v3.5.0 release of NetBox. For backwards compatibility, map JOBRESULT_RETENTION to JOB_RETENTION
+elif 'JOBRESULT_RETENTION' in environ:
+    JOB_RETENTION = _environ_get_and_map('JOBRESULT_RETENTION', None, _AS_INT)
 
 # API Cross-Origin Resource Sharing (CORS) settings. If CORS_ORIGIN_ALLOW_ALL is set to True, all origins will be
 # allowed. Otherwise, define a list of allowed origins using either CORS_ORIGIN_WHITELIST or
 # CORS_ORIGIN_REGEX_WHITELIST. For more information, see https://github.com/ottoyiu/django-cors-headers
-CORS_ORIGIN_ALLOW_ALL = os.environ.get('CORS_ORIGIN_ALLOW_ALL', 'False').lower() == 'true'
-CORS_ORIGIN_WHITELIST = os.environ.get('CORS_ORIGIN_WHITELIST', '').split(' ')
-CORS_ORIGIN_REGEX_WHITELIST = [
-    # r'^(https?://)?(\w+\.)?example\.com$',
-]
+CORS_ORIGIN_ALLOW_ALL = _environ_get_and_map('CORS_ORIGIN_ALLOW_ALL', 'False', _AS_BOOL)
+CORS_ORIGIN_WHITELIST = _environ_get_and_map('CORS_ORIGIN_WHITELIST', 'https://localhost', _AS_LIST)
+CORS_ORIGIN_REGEX_WHITELIST = [re.compile(r) for r in _environ_get_and_map('CORS_ORIGIN_REGEX_WHITELIST', '', _AS_LIST)]
 
 # Set to True to enable server debugging. WARNING: Debugging introduces a substantial performance penalty and may reveal
-# sensitive information about your installation. Only enable debugging while performing testing. Never enable debugging
-# on a production system.
-DEBUG = os.environ.get('DEBUG', 'False').lower() == 'true'
+# sensitive information about your installation. Only enable debugging while performing testing.
+# Never enable debugging on a production system.
+DEBUG = _environ_get_and_map('DEBUG', 'False', _AS_BOOL)
+
+# This parameter serves as a safeguard to prevent some potentially dangerous behavior,
+# such as generating new database schema migrations.
+# Set this to True only if you are actively developing the NetBox code base.
+DEVELOPER = _environ_get_and_map('DEVELOPER', 'False', _AS_BOOL)
 
 # Email settings
 EMAIL = {
-    'SERVER': os.environ.get('EMAIL_SERVER', 'localhost'),
-    'PORT': int(os.environ.get('EMAIL_PORT', 25)),
-    'USERNAME': os.environ.get('EMAIL_USERNAME', ''),
-    'PASSWORD': os.environ.get('EMAIL_PASSWORD', read_secret('email_password')),
-    'TIMEOUT': int(os.environ.get('EMAIL_TIMEOUT', 10)),  # seconds
-    'FROM_EMAIL': os.environ.get('EMAIL_FROM', ''),
+    'SERVER': environ.get('EMAIL_SERVER', 'localhost'),
+    'PORT': _environ_get_and_map('EMAIL_PORT', 25, _AS_INT),
+    'USERNAME': environ.get('EMAIL_USERNAME', ''),
+    'PASSWORD': _read_secret('email_password', environ.get('EMAIL_PASSWORD', '')),
+    'USE_SSL': _environ_get_and_map('EMAIL_USE_SSL', 'False', _AS_BOOL),
+    'USE_TLS': _environ_get_and_map('EMAIL_USE_TLS', 'False', _AS_BOOL),
+    'SSL_CERTFILE': environ.get('EMAIL_SSL_CERTFILE', ''),
+    'SSL_KEYFILE': environ.get('EMAIL_SSL_KEYFILE', ''),
+    'TIMEOUT': _environ_get_and_map('EMAIL_TIMEOUT', 10, _AS_INT),  # seconds
+    'FROM_EMAIL': environ.get('EMAIL_FROM', ''),
 }
 
-# Enforcement of unique IP space can be toggled on a per-VRF basis.
-# To enforce unique IP space within the global table (all prefixes and IP addresses not assigned to a VRF),
-# set ENFORCE_GLOBAL_UNIQUE to True.
-ENFORCE_GLOBAL_UNIQUE = os.environ.get('ENFORCE_GLOBAL_UNIQUE', 'False').lower() == 'true'
+# Enforcement of unique IP space can be toggled on a per-VRF basis. To enforce unique IP space within the global table
+# (all prefixes and IP addresses not assigned to a VRF), set ENFORCE_GLOBAL_UNIQUE to True.
+if 'ENFORCE_GLOBAL_UNIQUE' in environ:
+    ENFORCE_GLOBAL_UNIQUE = _environ_get_and_map('ENFORCE_GLOBAL_UNIQUE', None, _AS_BOOL)
 
-# Enable custom logging. Please see the Django documentation for detailed guidance on configuring custom logs:
-#   https://docs.djangoproject.com/en/1.11/topics/logging/
-LOGGING = {}
+# By default, netbox sends census reporting data using a single HTTP request each time a worker starts.
+# This data enables the project maintainers to estimate how many NetBox deployments exist and track the adoption of new versions over time.
+# The only data reported by this function are the NetBox version, Python version, and a pseudorandom unique identifier.
+# To opt out of census reporting, set CENSUS_REPORTING_ENABLED to False.
+if 'CENSUS_REPORTING_ENABLED' in environ:
+    CENSUS_REPORTING_ENABLED = _environ_get_and_map('CENSUS_REPORTING_ENABLED', None, _AS_BOOL)
 
-# Setting this to True will permit only authenticated users to access any part of NetBox. By default, anonymous users
-# are permitted to access most data in NetBox (excluding secrets) but not make any changes.
-LOGIN_REQUIRED = os.environ.get('LOGIN_REQUIRED', 'False').lower() == 'true'
+# Exempt certain models from the enforcement of view permissions. Models listed here will be viewable by all users and
+# by anonymous users. List models in the form `<app>.<model>`. Add '*' to this list to exempt all models.
+EXEMPT_VIEW_PERMISSIONS = _environ_get_and_map('EXEMPT_VIEW_PERMISSIONS', '', _AS_LIST)
+
+# HTTP proxies NetBox should use when sending outbound HTTP requests (e.g. for webhooks).
+HTTP_PROXIES = {
+    'http': environ.get('HTTP_PROXY', None),
+    'https': environ.get('HTTPS_PROXY', None),
+}
+
+# IP addresses recognized as internal to the system. The debugging toolbar will be available only to clients accessing
+# NetBox from an internal IP.
+INTERNAL_IPS = _environ_get_and_map('INTERNAL_IPS', '127.0.0.1 ::1', _AS_LIST)
+
+# Enable GraphQL API.
+if 'GRAPHQL_ENABLED' in environ:
+    GRAPHQL_ENABLED = _environ_get_and_map('GRAPHQL_ENABLED', None, _AS_BOOL)
+
+# # Enable custom logging. Please see the Django documentation for detailed guidance on configuring custom logs:
+# #   https://docs.djangoproject.com/en/stable/topics/logging/
+# LOGGING = {}
+
+# Automatically reset the lifetime of a valid session upon each authenticated request. Enables users to remain
+# authenticated to NetBox indefinitely.
+LOGIN_PERSISTENCE = _environ_get_and_map('LOGIN_PERSISTENCE', 'False', _AS_BOOL)
+
+# When enabled, only authenticated users are permitted to access any part of NetBox.
+# Disabling this will allow unauthenticated users to access most areas of NetBox (but not make any changes).
+LOGIN_REQUIRED = _environ_get_and_map('LOGIN_REQUIRED', 'True', _AS_BOOL)
+
+# The length of time (in seconds) for which a user will remain logged into the web UI before being prompted to
+# re-authenticate. (Default: 1209600 [14 days])
+LOGIN_TIMEOUT = _environ_get_and_map('LOGIN_TIMEOUT', 1209600, _AS_INT)
 
 # Setting this to True will display a "maintenance mode" banner at the top of every page.
-MAINTENANCE_MODE = os.environ.get('MAINTENANCE_MODE', 'False').lower() == 'true'
+if 'MAINTENANCE_MODE' in environ:
+    MAINTENANCE_MODE = _environ_get_and_map('MAINTENANCE_MODE', None, _AS_BOOL)
+
+# Maps provider
+if 'MAPS_URL' in environ:
+    MAPS_URL = environ.get('MAPS_URL', None)
 
 # An API consumer can request an arbitrary number of objects =by appending the "limit" parameter to the URL (e.g.
 # "?limit=1000"). This setting defines the maximum limit. Setting it to 0 or None will allow an API consumer to request
 # all objects by specifying "?limit=0".
-MAX_PAGE_SIZE = int(os.environ.get('MAX_PAGE_SIZE', 1000))
+if 'MAX_PAGE_SIZE' in environ:
+    MAX_PAGE_SIZE = _environ_get_and_map('MAX_PAGE_SIZE', None, _AS_INT)
 
 # The file path where uploaded media such as image attachments are stored. A trailing slash is not needed. Note that
 # the default value of this setting is derived from the installed location.
-MEDIA_ROOT = os.environ.get('MEDIA_ROOT', os.path.join(BASE_DIR, 'media'))
+MEDIA_ROOT = environ.get('MEDIA_ROOT', join(_BASE_DIR, 'media'))
 
-# Credentials that NetBox will use to access live devices.
-NAPALM_USERNAME = os.environ.get('NAPALM_USERNAME', '')
-NAPALM_PASSWORD = os.environ.get('NAPALM_PASSWORD', read_secret('napalm_password'))
-
-# NAPALM timeout (in seconds). (Default: 30)
-NAPALM_TIMEOUT = int(os.environ.get('NAPALM_TIMEOUT', 30))
-
-# NAPALM optional arguments (see http://napalm.readthedocs.io/en/latest/support/#optional-arguments). Arguments must
-# be provided as a dictionary.
-NAPALM_ARGS = {}
+# Expose Prometheus monitoring metrics at the HTTP endpoint '/metrics'
+METRICS_ENABLED = _environ_get_and_map('METRICS_ENABLED', 'False', _AS_BOOL)
 
 # Determine how many objects to display per page within a list. (Default: 50)
-PAGINATE_COUNT = int(os.environ.get('PAGINATE_COUNT', 50))
+if 'PAGINATE_COUNT' in environ:
+    PAGINATE_COUNT = _environ_get_and_map('PAGINATE_COUNT', None, _AS_INT)
+
+# # Enable installed plugins. Add the name of each plugin to the list.
+# PLUGINS = []
+
+# # Plugins configuration settings. These settings are used by various plugins that the user may have installed.
+# # Each key in the dictionary is the name of an installed plugin and its value is a dictionary of settings.
+# PLUGINS_CONFIG = {
+# }
 
 # When determining the primary IP address for a device, IPv6 is preferred over IPv4 by default. Set this to True to
 # prefer IPv4 instead.
-PREFER_IPV4 = os.environ.get('PREFER_IPV4', 'False').lower() == 'true'
+if 'PREFER_IPV4' in environ:
+    PREFER_IPV4 = _environ_get_and_map('PREFER_IPV4', None, _AS_BOOL)
 
-# The Webhook event backend is disabled by default. Set this to True to enable it. Note that this requires a Redis
-# database be configured and accessible by NetBox (see `REDIS` below).
-WEBHOOKS_ENABLED = os.environ.get('WEBHOOKS_ENABLED', 'False').lower() == 'true'
+# The default value for the amperage field when creating new power feeds.
+if 'POWERFEED_DEFAULT_AMPERAGE' in environ:
+    POWERFEED_DEFAULT_AMPERAGE = _environ_get_and_map('POWERFEED_DEFAULT_AMPERAGE', None, _AS_INT)
 
-# Redis database settings (optional). A Redis database is required only if the webhooks backend is enabled.
-REDIS = {
-    'HOST': os.environ.get('REDIS_HOST', 'localhost'),
-    'PORT': os.environ.get('REDIS_PORT', 6379),
-    'PASSWORD': os.environ.get('REDIS_PASSWORD', read_secret('redis_password')),
-    'DATABASE': os.environ.get('REDIS_DATABASE', '0'),
-    'DEFAULT_TIMEOUT': os.environ.get('REDIS_TIMEOUT', '300'),
-    'SSL': os.environ.get('REDIS_SSL', 'False').lower() == 'true',
-}
+# The default value (percentage) for the max_utilization field when creating new power feeds.
+if 'POWERFEED_DEFAULT_MAX_UTILIZATION' in environ:
+    POWERFEED_DEFAULT_MAX_UTILIZATION = _environ_get_and_map('POWERFEED_DEFAULT_MAX_UTILIZATION', None, _AS_INT)
 
-# The file path where custom reports will be stored. A trailing slash is not needed. Note that the default value of
-# this setting is derived from the installed location.
-REPORTS_ROOT = os.environ.get('REPORTS_ROOT', '/etc/netbox/reports')
+# The default value for the voltage field when creating new power feeds.
+if 'POWERFEED_DEFAULT_VOLTAGE' in environ:
+    POWERFEED_DEFAULT_VOLTAGE = _environ_get_and_map('POWERFEED_DEFAULT_VOLTAGE', None, _AS_INT)
+
+# Rack elevation size defaults, in pixels. For best results, the ratio of width to height should be roughly 10:1.
+if 'RACK_ELEVATION_DEFAULT_UNIT_HEIGHT' in environ:
+    RACK_ELEVATION_DEFAULT_UNIT_HEIGHT = _environ_get_and_map('RACK_ELEVATION_DEFAULT_UNIT_HEIGHT', None, _AS_INT)
+if 'RACK_ELEVATION_DEFAULT_UNIT_WIDTH' in environ:
+    RACK_ELEVATION_DEFAULT_UNIT_WIDTH = _environ_get_and_map('RACK_ELEVATION_DEFAULT_UNIT_WIDTH', None, _AS_INT)
+
+# Remote authentication support
+REMOTE_AUTH_AUTO_CREATE_GROUPS = _environ_get_and_map('REMOTE_AUTH_AUTO_CREATE_GROUPS', 'False', _AS_BOOL)
+REMOTE_AUTH_AUTO_CREATE_USER = _environ_get_and_map('REMOTE_AUTH_AUTO_CREATE_USER', 'False', _AS_BOOL)
+REMOTE_AUTH_BACKEND = _environ_get_and_map('REMOTE_AUTH_BACKEND', 'netbox.authentication.RemoteUserBackend', _AS_LIST)
+REMOTE_AUTH_DEFAULT_GROUPS = _environ_get_and_map('REMOTE_AUTH_DEFAULT_GROUPS', '', _AS_LIST)
+# REMOTE_AUTH_DEFAULT_PERMISSIONS = {} # dicts can't be configured via environment variables. See extra.py instead.
+REMOTE_AUTH_ENABLED = _environ_get_and_map('REMOTE_AUTH_ENABLED', 'False', _AS_BOOL)
+REMOTE_AUTH_GROUP_HEADER = _environ_get_and_map('REMOTE_AUTH_GROUP_HEADER', 'HTTP_REMOTE_USER_GROUP')
+REMOTE_AUTH_GROUP_SEPARATOR = _environ_get_and_map('REMOTE_AUTH_GROUP_SEPARATOR', '|')
+REMOTE_AUTH_GROUP_SYNC_ENABLED = _environ_get_and_map('REMOTE_AUTH_GROUP_SYNC_ENABLED', 'False', _AS_BOOL)
+REMOTE_AUTH_HEADER = environ.get('REMOTE_AUTH_HEADER', 'HTTP_REMOTE_USER')
+REMOTE_AUTH_USER_EMAIL = environ.get('REMOTE_AUTH_USER_EMAIL', 'HTTP_REMOTE_USER_EMAIL')
+REMOTE_AUTH_USER_FIRST_NAME = environ.get('REMOTE_AUTH_USER_FIRST_NAME', 'HTTP_REMOTE_USER_FIRST_NAME')
+REMOTE_AUTH_USER_LAST_NAME = environ.get('REMOTE_AUTH_USER_LAST_NAME', 'HTTP_REMOTE_USER_LAST_NAME')
+REMOTE_AUTH_SUPERUSER_GROUPS = _environ_get_and_map('REMOTE_AUTH_SUPERUSER_GROUPS', '', _AS_LIST)
+REMOTE_AUTH_SUPERUSERS = _environ_get_and_map('REMOTE_AUTH_SUPERUSERS', '', _AS_LIST)
+REMOTE_AUTH_STAFF_GROUPS = _environ_get_and_map('REMOTE_AUTH_STAFF_GROUPS', '', _AS_LIST)
+REMOTE_AUTH_STAFF_USERS = _environ_get_and_map('REMOTE_AUTH_STAFF_USERS', '', _AS_LIST)
+
+# This repository is used to check whether there is a new release of NetBox available. Set to None to disable the
+# version check or use the URL below to check for release in the official NetBox repository.
+RELEASE_CHECK_URL = environ.get('RELEASE_CHECK_URL', None)
+# RELEASE_CHECK_URL = 'https://api.github.com/repos/netbox-community/netbox/releases'
+
+# Maximum execution time for background tasks, in seconds.
+RQ_DEFAULT_TIMEOUT = _environ_get_and_map('RQ_DEFAULT_TIMEOUT', 300, _AS_INT)
+
+# The name to use for the csrf token cookie.
+CSRF_COOKIE_NAME = environ.get('CSRF_COOKIE_NAME', 'csrftoken')
+
+# Cross-Site-Request-Forgery-Attack settings. If Netbox is sitting behind a reverse proxy, you might need to set the CSRF_TRUSTED_ORIGINS flag.
+# Django 4.0 requires to specify the URL Scheme in this setting. An example environment variable could be specified like:
+# CSRF_TRUSTED_ORIGINS=https://demo.netbox.dev http://demo.netbox.dev
+CSRF_TRUSTED_ORIGINS = _environ_get_and_map('CSRF_TRUSTED_ORIGINS', '', _AS_LIST)
+
+# The name to use for the session cookie.
+SESSION_COOKIE_NAME = environ.get('SESSION_COOKIE_NAME', 'sessionid')
+
+# If true, the `includeSubDomains` directive will be included in the HTTP Strict Transport Security (HSTS) header.
+# This directive instructs the browser to apply the HSTS policy to all subdomains of the current domain.
+SECURE_HSTS_INCLUDE_SUBDOMAINS = _environ_get_and_map('SECURE_HSTS_INCLUDE_SUBDOMAINS', 'False', _AS_BOOL)
+
+# If true, the `preload` directive will be included in the HTTP Strict Transport Security (HSTS) header.
+# This directive instructs the browser to preload the site in HTTPS. Browsers that use the HSTS preload list will force the
+# site to be accessed via HTTPS even if the user types HTTP in the address bar.
+SECURE_HSTS_PRELOAD = _environ_get_and_map('SECURE_HSTS_PRELOAD', 'False', _AS_BOOL)
+
+# If set to a non-zero integer value, the SecurityMiddleware sets the HTTP Strict Transport Security (HSTS) header on all
+# responses that do not already have it. This will instruct the browser that the website must be accessed via HTTPS,
+# blocking any HTTP request.
+SECURE_HSTS_SECONDS = _environ_get_and_map('SECURE_HSTS_SECONDS', 0, _AS_INT)
+
+# If true, all non-HTTPS requests will be automatically redirected to use HTTPS.
+SECURE_SSL_REDIRECT = _environ_get_and_map('SECURE_SSL_REDIRECT', 'False', _AS_BOOL)
+
+# By default, NetBox will store session data in the database. Alternatively, a file path can be specified here to use
+# local file storage instead. (This can be useful for enabling authentication on a standby instance with read-only
+# database access.) Note that the user as which NetBox runs must have read and write permissions to this path.
+SESSION_FILE_PATH = environ.get('SESSION_FILE_PATH', environ.get('SESSIONS_ROOT', None))
 
 # Time zone (default: UTC)
-TIME_ZONE = os.environ.get('TIME_ZONE', 'UTC')
+TIME_ZONE = environ.get('TIME_ZONE', 'UTC')
 
-# Date/time formatting. See the following link for supported formats:
-# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
-DATE_FORMAT = os.environ.get('DATE_FORMAT', 'N j, Y')
-SHORT_DATE_FORMAT = os.environ.get('SHORT_DATE_FORMAT', 'Y-m-d')
-TIME_FORMAT = os.environ.get('TIME_FORMAT', 'g:i a')
-SHORT_TIME_FORMAT = os.environ.get('SHORT_TIME_FORMAT', 'H:i:s')
-DATETIME_FORMAT = os.environ.get('DATETIME_FORMAT', 'N j, Y g:i a')
-SHORT_DATETIME_FORMAT = os.environ.get('SHORT_DATETIME_FORMAT', 'Y-m-d H:i')
+# If true disables miscellaneous functionality which depends on access to the Internet.
+ISOLATED_DEPLOYMENT = _environ_get_and_map('ISOLATED_DEPLOYMENT', 'False', _AS_BOOL)

configuration/extra.py

@@ -0,0 +1,49 @@
+####
+## This file contains extra configuration options that can't be configured
+## directly through environment variables.
+####
+
+## Specify one or more name and email address tuples representing NetBox administrators. These people will be notified of
+## application errors (assuming correct email settings are provided).
+# ADMINS = [
+#     # ['John Doe', 'jdoe@example.com'],
+# ]
+
+
+## URL schemes that are allowed within links in NetBox
+# ALLOWED_URL_SCHEMES = (
+#     'file', 'ftp', 'ftps', 'http', 'https', 'irc', 'mailto', 'sftp', 'ssh', 'tel', 'telnet', 'tftp', 'vnc', 'xmpp',
+# )
+
+## Enable installed plugins. Add the name of each plugin to the list.
+# from netbox.configuration.configuration import PLUGINS
+# PLUGINS.append('my_plugin')
+
+## Plugins configuration settings. These settings are used by various plugins that the user may have installed.
+## Each key in the dictionary is the name of an installed plugin and its value is a dictionary of settings.
+# from netbox.configuration.configuration import PLUGINS_CONFIG
+# PLUGINS_CONFIG['my_plugin'] = {
+#   'foo': 'bar',
+#   'buzz': 'bazz'
+# }
+
+
+## Remote authentication support
+# REMOTE_AUTH_DEFAULT_PERMISSIONS = {}
+
+
+## By default uploaded media is stored on the local filesystem. Using Django-storages is also supported. Provide the
+## class path of the storage driver in STORAGE_BACKEND and any configuration options in STORAGE_CONFIG. For example:
+# STORAGE_BACKEND = 'storages.backends.s3boto3.S3Boto3Storage'
+# STORAGE_CONFIG = {
+#     'AWS_ACCESS_KEY_ID': 'Key ID',
+#     'AWS_SECRET_ACCESS_KEY': 'Secret',
+#     'AWS_STORAGE_BUCKET_NAME': 'netbox',
+#     'AWS_S3_REGION_NAME': 'eu-west-1',
+# }
+
+
+## This file can contain arbitrary Python code, e.g.:
+# from datetime import datetime
+# now = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
+# BANNER_TOP = f'<marquee width="200px">This instance started on {now}.</marquee>'

configuration/gunicorn_config.py

@@ -1,8 +0,0 @@
-command = '/usr/bin/gunicorn'
-pythonpath = '/opt/netbox/netbox'
-bind = '0.0.0.0:8001'
-workers = 3
-errorlog = '-'
-accesslog = '-'
-capture_output = False
-loglevel = 'debug'

configuration/ldap/extra.py

@@ -0,0 +1,28 @@
+####
+## This file contains extra configuration options that can't be configured
+## directly through environment variables.
+## All vairables set here overwrite any existing found in ldap_config.py
+####
+
+# # This Python script inherits all the imports from ldap_config.py
+# from django_auth_ldap.config import LDAPGroupQuery # Imported since not in ldap_config.py
+
+# # Sets a base requirement of membetship to netbox-user-ro, netbox-user-rw, or netbox-user-admin.
+# AUTH_LDAP_REQUIRE_GROUP = (
+#     LDAPGroupQuery("cn=netbox-user-ro,ou=groups,dc=example,dc=com")
+#     | LDAPGroupQuery("cn=netbox-user-rw,ou=groups,dc=example,dc=com")
+#     | LDAPGroupQuery("cn=netbox-user-admin,ou=groups,dc=example,dc=com")
+# )
+
+# # Sets LDAP Flag groups variables with example.
+# AUTH_LDAP_USER_FLAGS_BY_GROUP = {
+#     "is_staff": (
+#         LDAPGroupQuery("cn=netbox-user-ro,ou=groups,dc=example,dc=com")
+#         | LDAPGroupQuery("cn=netbox-user-rw,ou=groups,dc=example,dc=com")
+#         | LDAPGroupQuery("cn=netbox-user-admin,ou=groups,dc=example,dc=com")
+#     ),
+#     "is_superuser": "cn=netbox-user-admin,ou=groups,dc=example,dc=com",
+# }
+
+# # Sets LDAP Mirror groups variables with example groups
+# AUTH_LDAP_MIRROR_GROUPS = ["netbox-user-ro", "netbox-user-rw", "netbox-user-admin"]

configuration/ldap/ldap_config.py

@@ -0,0 +1,111 @@
+from importlib import import_module
+from os import environ
+
+import ldap
+from django_auth_ldap.config import LDAPSearch
+
+
+# Read secret from file
+def _read_secret(secret_name, default=None):
+    try:
+        f = open('/run/secrets/' + secret_name, 'r', encoding='utf-8')
+    except EnvironmentError:
+        return default
+    else:
+        with f:
+            return f.readline().strip()
+
+# Import and return the group type based on string name
+def _import_group_type(group_type_name):
+    mod = import_module('django_auth_ldap.config')
+    try:
+        return getattr(mod, group_type_name)()
+    except:
+        return None
+
+# Server URI
+AUTH_LDAP_SERVER_URI = environ.get('AUTH_LDAP_SERVER_URI', '')
+
+# The following may be needed if you are binding to Active Directory.
+AUTH_LDAP_CONNECTION_OPTIONS = {
+    ldap.OPT_REFERRALS: 0
+}
+
+AUTH_LDAP_BIND_AS_AUTHENTICATING_USER = environ.get('AUTH_LDAP_BIND_AS_AUTHENTICATING_USER', 'False').lower() == 'true'
+
+# Set the DN and password for the NetBox service account if needed.
+if not AUTH_LDAP_BIND_AS_AUTHENTICATING_USER:
+    AUTH_LDAP_BIND_DN = environ.get('AUTH_LDAP_BIND_DN', '')
+    AUTH_LDAP_BIND_PASSWORD = _read_secret('auth_ldap_bind_password', environ.get('AUTH_LDAP_BIND_PASSWORD', ''))
+
+# Set a string template that describes any user’s distinguished name based on the username.
+AUTH_LDAP_USER_DN_TEMPLATE = environ.get('AUTH_LDAP_USER_DN_TEMPLATE', None)
+
+# Enable STARTTLS for ldap authentication.
+AUTH_LDAP_START_TLS = environ.get('AUTH_LDAP_START_TLS', 'False').lower() == 'true'
+
+# Include this setting if you want to ignore certificate errors. This might be needed to accept a self-signed cert.
+# Note that this is a NetBox-specific setting which sets:
+#     ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
+LDAP_IGNORE_CERT_ERRORS = environ.get('LDAP_IGNORE_CERT_ERRORS', 'False').lower() == 'true'
+
+# Include this setting if you want to validate the LDAP server certificates against a CA certificate directory on your server
+# Note that this is a NetBox-specific setting which sets:
+#     ldap.set_option(ldap.OPT_X_TLS_CACERTDIR, LDAP_CA_CERT_DIR)
+LDAP_CA_CERT_DIR = environ.get('LDAP_CA_CERT_DIR', None)
+
+# Include this setting if you want to validate the LDAP server certificates against your own CA.
+# Note that this is a NetBox-specific setting which sets:
+#     ldap.set_option(ldap.OPT_X_TLS_CACERTFILE, LDAP_CA_CERT_FILE)
+LDAP_CA_CERT_FILE = environ.get('LDAP_CA_CERT_FILE', None)
+
+AUTH_LDAP_USER_SEARCH_BASEDN = environ.get('AUTH_LDAP_USER_SEARCH_BASEDN', '')
+AUTH_LDAP_USER_SEARCH_ATTR = environ.get('AUTH_LDAP_USER_SEARCH_ATTR', 'sAMAccountName')
+AUTH_LDAP_USER_SEARCH_FILTER: str = environ.get(
+    'AUTH_LDAP_USER_SEARCH_FILTER', f'({AUTH_LDAP_USER_SEARCH_ATTR}=%(user)s)'
+)
+
+AUTH_LDAP_USER_SEARCH = LDAPSearch(
+    AUTH_LDAP_USER_SEARCH_BASEDN, ldap.SCOPE_SUBTREE, AUTH_LDAP_USER_SEARCH_FILTER
+)
+
+# This search ought to return all groups to which the user belongs. django_auth_ldap uses this to determine group
+# heirarchy.
+
+AUTH_LDAP_GROUP_SEARCH_BASEDN = environ.get('AUTH_LDAP_GROUP_SEARCH_BASEDN', '')
+AUTH_LDAP_GROUP_SEARCH_CLASS = environ.get('AUTH_LDAP_GROUP_SEARCH_CLASS', 'group')
+
+AUTH_LDAP_GROUP_SEARCH_FILTER: str = environ.get(
+    'AUTH_LDAP_GROUP_SEARCH_FILTER', f'(objectclass={AUTH_LDAP_GROUP_SEARCH_CLASS})'
+)
+AUTH_LDAP_GROUP_SEARCH = LDAPSearch(
+    AUTH_LDAP_GROUP_SEARCH_BASEDN, ldap.SCOPE_SUBTREE, AUTH_LDAP_GROUP_SEARCH_FILTER
+)
+AUTH_LDAP_GROUP_TYPE = _import_group_type(environ.get('AUTH_LDAP_GROUP_TYPE', 'GroupOfNamesType'))
+
+# Define a group required to login.
+AUTH_LDAP_REQUIRE_GROUP = environ.get('AUTH_LDAP_REQUIRE_GROUP_DN')
+
+# Define special user types using groups. Exercise great caution when assigning superuser status.
+AUTH_LDAP_USER_FLAGS_BY_GROUP = {}
+
+if AUTH_LDAP_REQUIRE_GROUP is not None:
+    AUTH_LDAP_USER_FLAGS_BY_GROUP = {
+        "is_active": environ.get('AUTH_LDAP_REQUIRE_GROUP_DN', ''),
+        "is_staff": environ.get('AUTH_LDAP_IS_ADMIN_DN', ''),
+        "is_superuser": environ.get('AUTH_LDAP_IS_SUPERUSER_DN', '')
+    }
+
+# For more granular permissions, we can map LDAP groups to Django groups.
+AUTH_LDAP_FIND_GROUP_PERMS = environ.get('AUTH_LDAP_FIND_GROUP_PERMS', 'True').lower() == 'true'
+AUTH_LDAP_MIRROR_GROUPS = environ.get('AUTH_LDAP_MIRROR_GROUPS', '').lower() == 'true'
+
+# Cache groups for one hour to reduce LDAP traffic
+AUTH_LDAP_CACHE_TIMEOUT = int(environ.get('AUTH_LDAP_CACHE_TIMEOUT', 3600))
+
+# Populate the Django user from the LDAP directory.
+AUTH_LDAP_USER_ATTR_MAP = {
+    "first_name": environ.get('AUTH_LDAP_ATTR_FIRSTNAME', 'givenName'),
+    "last_name": environ.get('AUTH_LDAP_ATTR_LASTNAME', 'sn'),
+    "email": environ.get('AUTH_LDAP_ATTR_MAIL', 'mail')
+}

configuration/ldap_config.py

@@ -1,62 +0,0 @@
-import ldap
-import os
-
-from django_auth_ldap.config import LDAPSearch, GroupOfNamesType
-
-# Server URI
-AUTH_LDAP_SERVER_URI = os.environ.get('AUTH_LDAP_SERVER_URI', '')
-
-# The following may be needed if you are binding to Active Directory.
-AUTH_LDAP_CONNECTION_OPTIONS = {
-    ldap.OPT_REFERRALS: 0
-}
-
-# Set the DN and password for the NetBox service account.
-AUTH_LDAP_BIND_DN = os.environ.get('AUTH_LDAP_BIND_DN', '')
-AUTH_LDAP_BIND_PASSWORD = os.environ.get('AUTH_LDAP_BIND_PASSWORD', '')
-
-# Set a string template that describes any user’s distinguished name based on the username.
-AUTH_LDAP_USER_DN_TEMPLATE = os.environ.get('AUTH_LDAP_USER_DN_TEMPLATE', None)
-
-# Include this setting if you want to ignore certificate errors. This might be needed to accept a self-signed cert.
-# Note that this is a NetBox-specific setting which sets:
-#     ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
-LDAP_IGNORE_CERT_ERRORS = os.environ.get('LDAP_IGNORE_CERT_ERRORS', 'False').lower() == 'true'
-
-AUTH_LDAP_USER_SEARCH_BASEDN = os.environ.get('AUTH_LDAP_USER_SEARCH_BASEDN', '')
-AUTH_LDAP_USER_SEARCH_ATTR = os.environ.get('AUTH_LDAP_USER_SEARCH_ATTR', 'sAMAccountName')
-AUTH_LDAP_USER_SEARCH = LDAPSearch(AUTH_LDAP_USER_SEARCH_BASEDN,
-                                   ldap.SCOPE_SUBTREE,
-                                   "(" + AUTH_LDAP_USER_SEARCH_ATTR + "=%(user)s)")
-
-# This search ought to return all groups to which the user belongs. django_auth_ldap uses this to determine group
-# heirarchy.
-AUTH_LDAP_GROUP_SEARCH_BASEDN = os.environ.get('AUTH_LDAP_GROUP_SEARCH_BASEDN', '')
-AUTH_LDAP_GROUP_SEARCH_CLASS = os.environ.get('AUTH_LDAP_GROUP_SEARCH_CLASS', 'group')
-AUTH_LDAP_GROUP_SEARCH = LDAPSearch(AUTH_LDAP_GROUP_SEARCH_BASEDN, ldap.SCOPE_SUBTREE,
-                                    "(objectClass=" + AUTH_LDAP_GROUP_SEARCH_CLASS + ")")
-AUTH_LDAP_GROUP_TYPE = GroupOfNamesType()
-
-# Define a group required to login.
-AUTH_LDAP_REQUIRE_GROUP = os.environ.get('AUTH_LDAP_REQUIRE_GROUP_DN', '')
-
-# Define special user types using groups. Exercise great caution when assigning superuser status.
-AUTH_LDAP_USER_FLAGS_BY_GROUP = {
-    "is_active": os.environ.get('AUTH_LDAP_REQUIRE_GROUP_DN', ''),
-    "is_staff": os.environ.get('AUTH_LDAP_IS_ADMIN_DN', ''),
-    "is_superuser": os.environ.get('AUTH_LDAP_IS_SUPERUSER_DN', '')
-}
-
-# For more granular permissions, we can map LDAP groups to Django groups.
-AUTH_LDAP_FIND_GROUP_PERMS = os.environ.get('AUTH_LDAP_FIND_GROUP_PERMS', 'True').lower() == 'true'
-
-# Cache groups for one hour to reduce LDAP traffic
-AUTH_LDAP_CACHE_GROUPS = os.environ.get('AUTH_LDAP_CACHE_GROUPS', 'True').lower() == 'true'
-AUTH_LDAP_GROUP_CACHE_TIMEOUT = int(os.environ.get('AUTH_LDAP_GROUP_CACHE_TIMEOUT', 3600))
-
-# Populate the Django user from the LDAP directory.
-AUTH_LDAP_USER_ATTR_MAP = {
-    "first_name": os.environ.get('AUTH_LDAP_ATTR_FIRSTNAME', 'givenName'),
-    "last_name": os.environ.get('AUTH_LDAP_ATTR_LASTNAME', 'sn'),
-    "email": os.environ.get('AUTH_LDAP_ATTR_MAIL', 'mail')
-}

configuration/logging.py

@@ -0,0 +1,55 @@
+# # Remove first comment(#) on each line to implement this working logging example.
+# # Add LOGLEVEL environment variable to netbox if you use this example & want a different log level.
+# from os import environ
+
+# # Set LOGLEVEL in netbox.env or docker-compose.overide.yml to override a logging level of INFO.
+# LOGLEVEL = environ.get('LOGLEVEL', 'INFO')
+
+# LOGGING = {
+
+#    'version': 1,
+#    'disable_existing_loggers': False,
+#    'formatters': {
+#        'verbose': {
+#            'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
+#            'style': '{',
+#        },
+#        'simple': {
+#            'format': '{levelname} {message}',
+#            'style': '{',
+#        },
+#    },
+#    'filters': {
+#        'require_debug_false': {
+#            '()': 'django.utils.log.RequireDebugFalse',
+#        },
+#    },
+#    'handlers': {
+#        'console': {
+#            'level': LOGLEVEL,
+#            'filters': ['require_debug_false'],
+#            'class': 'logging.StreamHandler',
+#            'formatter': 'simple'
+#        },
+#        'mail_admins': {
+#            'level': 'ERROR',
+#            'class': 'django.utils.log.AdminEmailHandler',
+#            'filters': ['require_debug_false']
+#        }
+#    },
+#    'loggers': {
+#        'django': {
+#            'handlers': ['console'],
+#            'propagate': True,
+#        },
+#        'django.request': {
+#            'handlers': ['mail_admins'],
+#            'level': 'ERROR',
+#            'propagate': False,
+#        },
+#        'django_auth_ldap': {
+#            'handlers': ['console',],
+#            'level': LOGLEVEL,
+#        }
+#    }
+# }

configuration/plugins.py

@@ -0,0 +1,13 @@
+# Add your plugins and plugin settings here.
+# Of course uncomment this file out.
+
+# To learn how to build images with your required plugins
+# See https://github.com/netbox-community/netbox-docker/wiki/Using-Netbox-Plugins
+
+# PLUGINS = ["netbox_bgp"]
+
+# PLUGINS_CONFIG = {
+#   "netbox_bgp": {
+#     ADD YOUR SETTINGS HERE
+#   }
+# }

docker-compose.override.yml.example

@@ -0,0 +1,22 @@
+services:
+  netbox:
+    ports:
+      - "8000:8080"
+    # If you want the Nginx unit status page visible from the
+    # outside of the container add the following port mapping:
+    # - "8001:8081"
+    # healthcheck:
+      # Time for which the health check can fail after the container is started.
+      # This depends mostly on the performance of your database. On the first start,
+      # when all tables need to be created the start_period should be higher than on
+      # subsequent starts. For the first start after major version upgrades of NetBox
+      # the start_period might also need to be set higher.
+      # Default value in our docker-compose.yml is 60s
+      # start_period: 90s
+    # environment:
+      # SKIP_SUPERUSER: "false"
+      # SUPERUSER_API_TOKEN: ""
+      # SUPERUSER_EMAIL: ""
+      # SUPERUSER_NAME: ""
+      # SUPERUSER_PASSWORD: ""
+

docker-compose.test.override.yml

@@ -0,0 +1,5 @@
+services:
+  netbox:
+    ports:
+      - "127.0.0.1:8000:8080"
+

docker-compose.test.yml

@@ -0,0 +1,70 @@
+services:
+  netbox: &netbox
+    image: ${IMAGE-docker.io/netboxcommunity/netbox:latest}
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      redis-cache:
+        condition: service_healthy
+    env_file: env/netbox.env
+    user: "unit:root"
+    volumes:
+      - ./test-configuration/test_config.py:/etc/netbox/config/test_config.py:z,ro
+    healthcheck:
+      test: curl -f http://localhost:8080/login/ || exit 1
+      start_period: ${NETBOX_START_PERIOD-120s}
+      timeout: 3s
+      interval: 15s
+  netbox-worker:
+    <<: *netbox
+    command:
+      - /opt/netbox/venv/bin/python
+      - /opt/netbox/netbox/manage.py
+      - rqworker
+    healthcheck:
+      test: ps -aux | grep -v grep | grep -q rqworker || exit 1
+      start_period: 40s
+      timeout: 3s
+      interval: 15s
+  netbox-housekeeping:
+    <<: *netbox
+    command:
+      - /opt/netbox/housekeeping.sh
+    healthcheck:
+      test: ps -aux | grep -v grep | grep -q housekeeping || exit 1
+      start_period: 40s
+      timeout: 3s
+      interval: 15s
+
+  postgres:
+    image: docker.io/postgres:17-alpine
+    env_file: env/postgres.env
+    healthcheck:
+      test: pg_isready -q -t 2 -d $$POSTGRES_DB -U $$POSTGRES_USER ## $$ because of docker-compose
+      start_period: 20s
+      interval: 1s
+      timeout: 5s
+      retries: 5
+
+  redis: &redis
+    image: docker.io/valkey/valkey:8.1-alpine
+    command:
+      - sh
+      - -c # this is to evaluate the $REDIS_PASSWORD from the env
+      - valkey-server --save "" --appendonly no --requirepass $$REDIS_PASSWORD ## $$ because of docker-compose
+    env_file: env/redis.env
+    healthcheck:
+      test: '[ $$(valkey-cli --pass "$${REDIS_PASSWORD}" ping) = ''PONG'' ]'
+      start_period: 5s
+      timeout: 3s
+      interval: 1s
+      retries: 5
+  redis-cache:
+    <<: *redis
+    env_file: env/redis-cache.env
+
+volumes:
+  netbox-media-files:
+    driver: local

docker-compose.yml

@@ -1,67 +1,99 @@
-version: '3'
 services:
   netbox: &netbox
-    build:
-      context: .
-      args:
-        - BRANCH=${VERSION-master}
-    image: netboxcommunity/netbox:${VERSION-latest}
+    image: docker.io/netboxcommunity/netbox:${VERSION-v4.3-3.3.0}
     depends_on:
-    - postgres
-    - redis
-    - netbox-worker
+      - postgres
+      - redis
+      - redis-cache
     env_file: env/netbox.env
+    user: "unit:root"
+    healthcheck:
+      test: curl -f http://localhost:8080/login/ || exit 1
+      start_period: 90s
+      timeout: 3s
+      interval: 15s
     volumes:
-    - ./startup_scripts:/opt/netbox/startup_scripts:z,ro
-    - ./initializers:/opt/netbox/initializers:z,ro
-    - ./configuration:/etc/netbox/config:z,ro
-    - ./reports:/etc/netbox/reports:z,ro
-    - netbox-nginx-config:/etc/netbox-nginx:z
-    - netbox-static-files:/opt/netbox/netbox/static:z
-    - netbox-media-files:/opt/netbox/netbox/media:z
+      - ./configuration:/etc/netbox/config:z,ro
+      - netbox-media-files:/opt/netbox/netbox/media:rw
+      - netbox-reports-files:/opt/netbox/netbox/reports:rw
+      - netbox-scripts-files:/opt/netbox/netbox/scripts:rw
   netbox-worker:
     <<: *netbox
     depends_on:
-    - redis
-    entrypoint:
-    - python3
-    - /opt/netbox/netbox/manage.py
+      netbox:
+        condition: service_healthy
     command:
-    - rqworker
-  nginx:
-    command: nginx -c /etc/netbox-nginx/nginx.conf
-    image: nginx:1.15-alpine
+      - /opt/netbox/venv/bin/python
+      - /opt/netbox/netbox/manage.py
+      - rqworker
+    healthcheck:
+      test: ps -aux | grep -v grep | grep -q rqworker || exit 1
+      start_period: 20s
+      timeout: 3s
+      interval: 15s
+  netbox-housekeeping:
+    <<: *netbox
     depends_on:
-    - netbox
-    ports:
-    - 8080
-    volumes:
-    - netbox-static-files:/opt/netbox/netbox/static:ro
-    - netbox-nginx-config:/etc/netbox-nginx/:ro
+      netbox:
+        condition: service_healthy
+    command:
+      - /opt/netbox/housekeeping.sh
+    healthcheck:
+      test: ps -aux | grep -v grep | grep -q housekeeping || exit 1
+      start_period: 20s
+      timeout: 3s
+      interval: 15s
+
+  # postgres
   postgres:
-    image: postgres:10.4-alpine
+    image: docker.io/postgres:17-alpine
+    healthcheck:
+      test: pg_isready -q -t 2 -d $$POSTGRES_DB -U $$POSTGRES_USER
+      start_period: 20s
+      timeout: 30s
+      interval: 10s
+      retries: 5
     env_file: env/postgres.env
     volumes:
-    - netbox-postgres-data:/var/lib/postgresql/data
+      - netbox-postgres-data:/var/lib/postgresql/data
+
+  # redis
   redis:
-    image: redis:4-alpine
+    image: docker.io/valkey/valkey:8.1-alpine
     command:
-    - sh
-    - -c # this is to evaluate the $REDIS_PASSWORD from the env
-    - redis-server --appendonly yes --requirepass $$REDIS_PASSWORD ## $$ because of docker-compose
+      - sh
+      - -c # this is to evaluate the $REDIS_PASSWORD from the env
+      - valkey-server --appendonly yes --requirepass $$REDIS_PASSWORD ## $$ because of docker-compose
+    healthcheck: &redis-healthcheck
+      test: '[ $$(valkey-cli --pass "$${REDIS_PASSWORD}" ping) = ''PONG'' ]'
+      start_period: 5s
+      timeout: 3s
+      interval: 1s
+      retries: 5
     env_file: env/redis.env
     volumes:
-    - netbox-redis-data:/data
+      - netbox-redis-data:/data
+  redis-cache:
+    image: docker.io/valkey/valkey:8.1-alpine
+    command:
+      - sh
+      - -c # this is to evaluate the $REDIS_PASSWORD from the env
+      - valkey-server --requirepass $$REDIS_PASSWORD ## $$ because of docker-compose
+    healthcheck: *redis-healthcheck
+    env_file: env/redis-cache.env
+    volumes:
+      - netbox-redis-cache-data:/data
+
 volumes:
-  netbox-static-files:
-    driver: local
-  netbox-nginx-config:
-    driver: local
   netbox-media-files:
     driver: local
-  netbox-report-files:
-    driver: local
   netbox-postgres-data:
     driver: local
+  netbox-redis-cache-data:
+    driver: local
   netbox-redis-data:
     driver: local
+  netbox-reports-files:
+    driver: local
+  netbox-scripts-files:
+    driver: local

docker/configuration.docker.py

@@ -1,10 +1,91 @@
+## Generic Parts
+# These functions are providing the functionality to load
+# arbitrary configuration files.
+#
+# They can be imported by other code (see `ldap_config.py` for an example).
+
 import importlib.util
 import sys
+from os import scandir
+from os.path import abspath, isfile
 
-try:
-  spec = importlib.util.spec_from_file_location('configuration', '/etc/netbox/config/configuration.py')
-  module = importlib.util.module_from_spec(spec)
-  spec.loader.exec_module(module)
-  sys.modules['netbox.configuration'] = module
-except:
-  raise ImportError('')
+
+def _filename(f):
+    return f.name
+
+
+def _import(module_name, path, loaded_configurations):
+    spec = importlib.util.spec_from_file_location("", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    sys.modules[module_name] = module
+
+    loaded_configurations.insert(0, module)
+
+    print(f"🧬 loaded config '{path}'")
+
+
+def read_configurations(config_module, config_dir, main_config):
+    loaded_configurations = []
+
+    main_config_path = abspath(f"{config_dir}/{main_config}.py")
+    if isfile(main_config_path):
+        _import(f"{config_module}.{main_config}", main_config_path, loaded_configurations)
+    else:
+        print(f"⚠️ Main configuration '{main_config_path}' not found.")
+
+    with scandir(config_dir) as it:
+        for f in sorted(it, key=_filename):
+            if not f.is_file():
+                continue
+
+            if f.name.startswith("__"):
+                continue
+
+            if not f.name.endswith(".py"):
+                continue
+
+            if f.name == f"{main_config}.py":
+                continue
+
+            if f.name == f"{config_dir}.py":
+                continue
+
+            module_name = f"{config_module}.{f.name[:-len('.py')]}".replace(".", "_")
+            _import(module_name, f.path, loaded_configurations)
+
+    if len(loaded_configurations) == 0:
+        print(f"‼️ No configuration files found in '{config_dir}'.")
+        raise ImportError(f"No configuration files found in '{config_dir}'.")
+
+    return loaded_configurations
+
+
+## Specific Parts
+# This section's code actually loads the various configuration files
+# into the module with the given name.
+# It contains the logic to resolve arbitrary configuration options by
+# levaraging dynamic programming using `__getattr__`.
+
+
+_loaded_configurations = read_configurations(
+    config_dir="/etc/netbox/config/",
+    config_module="netbox.configuration",
+    main_config="configuration",
+)
+
+
+def __getattr__(name):
+    for config in _loaded_configurations:
+        try:
+            return getattr(config, name)
+        except:
+            pass
+    raise AttributeError
+
+
+def __dir__():
+    names = []
+    for config in _loaded_configurations:
+        names.extend(config.__dir__())
+    return names

docker/docker-entrypoint.sh

@@ -1,58 +1,98 @@
 #!/bin/bash
+# Runs on every start of the NetBox Docker container
+
+# Stop when an error occures
 set -e
 
-# wait shortly and then run db migrations (retry on error)
-while ! ./manage.py migrate 2>&1; do
-  echo "⏳ Waiting on DB..."
-  sleep 3
-done
+# Allows NetBox to be run as non-root users
+umask 002
 
-# create superuser silently
-if [ -z ${SUPERUSER_NAME+x} ]; then
-  SUPERUSER_NAME='admin'
-fi
-if [ -z ${SUPERUSER_EMAIL+x} ]; then
-  SUPERUSER_EMAIL='admin@example.com'
-fi
-if [ -z ${SUPERUSER_PASSWORD+x} ]; then
-  if [ -f "/run/secrets/superuser_password" ]; then
-    SUPERUSER_PASSWORD="$(< /run/secrets/superuser_password)"
+# Load correct Python3 env
+# shellcheck disable=SC1091
+source /opt/netbox/venv/bin/activate
+
+# Try to connect to the DB
+DB_WAIT_TIMEOUT=${DB_WAIT_TIMEOUT-3}
+MAX_DB_WAIT_TIME=${MAX_DB_WAIT_TIME-30}
+CUR_DB_WAIT_TIME=0
+while [ "${CUR_DB_WAIT_TIME}" -lt "${MAX_DB_WAIT_TIME}" ]; do
+  # Read and truncate connection error tracebacks to last line by default
+  exec {psfd}< <(./manage.py showmigrations 2>&1)
+  read -rd '' DB_ERR <&$psfd || :
+  exec {psfd}<&-
+  wait $! && break
+  if [ -n "$DB_WAIT_DEBUG" ]; then
+    echo "$DB_ERR"
   else
+    readarray -tn 0 DB_ERR_LINES <<<"$DB_ERR"
+    echo "${DB_ERR_LINES[@]: -1}"
+    echo "[ Use DB_WAIT_DEBUG=1 in netbox.env to print full traceback for errors here ]"
+  fi
+  echo "⏳ Waiting on DB... (${CUR_DB_WAIT_TIME}s / ${MAX_DB_WAIT_TIME}s)"
+  sleep "${DB_WAIT_TIMEOUT}"
+  CUR_DB_WAIT_TIME=$((CUR_DB_WAIT_TIME + DB_WAIT_TIMEOUT))
+done
+if [ "${CUR_DB_WAIT_TIME}" -ge "${MAX_DB_WAIT_TIME}" ]; then
+  echo "❌ Waited ${MAX_DB_WAIT_TIME}s or more for the DB to become ready."
+  exit 1
+fi
+# Check if update is needed
+if ! ./manage.py migrate --check >/dev/null 2>&1; then
+  echo "⚙️ Applying database migrations"
+  ./manage.py migrate --no-input
+  echo "⚙️ Running trace_paths"
+  ./manage.py trace_paths --no-input
+  echo "⚙️ Removing stale content types"
+  ./manage.py remove_stale_contenttypes --no-input
+  echo "⚙️ Removing expired user sessions"
+  ./manage.py clearsessions
+  echo "⚙️ Building search index (lazy)"
+  ./manage.py reindex --lazy
+fi
+
+# Create Superuser if required
+if [ "$SKIP_SUPERUSER" == "true" ]; then
+  echo "↩️ Skip creating the superuser"
+else
+  if [ -z ${SUPERUSER_NAME+x} ]; then
+    SUPERUSER_NAME='admin'
+  fi
+  if [ -z ${SUPERUSER_EMAIL+x} ]; then
+    SUPERUSER_EMAIL='admin@example.com'
+  fi
+  if [ -f "/run/secrets/superuser_password" ]; then
+    SUPERUSER_PASSWORD="$(</run/secrets/superuser_password)"
+  elif [ -z ${SUPERUSER_PASSWORD+x} ]; then
     SUPERUSER_PASSWORD='admin'
   fi
-fi
-if [ -z ${SUPERUSER_API_TOKEN+x} ]; then
   if [ -f "/run/secrets/superuser_api_token" ]; then
-    SUPERUSER_API_TOKEN="$(< /run/secrets/superuser_api_token)"
-  else
+    SUPERUSER_API_TOKEN="$(</run/secrets/superuser_api_token)"
+  elif [ -z ${SUPERUSER_API_TOKEN+x} ]; then
     SUPERUSER_API_TOKEN='0123456789abcdef0123456789abcdef01234567'
   fi
-fi
 
-echo "💡 Username: ${SUPERUSER_NAME}, E-Mail: ${SUPERUSER_EMAIL}"
-
-./manage.py shell --interface python << END
-from django.contrib.auth.models import User
-from users.models import Token
+  ./manage.py shell --interface python <<END
+from users.models import Token, User
 if not User.objects.filter(username='${SUPERUSER_NAME}'):
-    u=User.objects.create_superuser('${SUPERUSER_NAME}', '${SUPERUSER_EMAIL}', '${SUPERUSER_PASSWORD}')
+    u = User.objects.create_superuser('${SUPERUSER_NAME}', '${SUPERUSER_EMAIL}', '${SUPERUSER_PASSWORD}')
     Token.objects.create(user=u, key='${SUPERUSER_API_TOKEN}')
 END
 
-if [ "$SKIP_STARTUP_SCRIPTS" == "true" ]; then
-  echo "☇ Skipping startup scripts"
-else
-  for script in /opt/netbox/startup_scripts/*.py; do
-    echo "⚙️ Executing '$script'"
-    ./manage.py shell --interface python < "${script}"
-  done
+  echo "💡 Superuser Username: ${SUPERUSER_NAME}, E-Mail: ${SUPERUSER_EMAIL}"
 fi
 
-# copy static files
-./manage.py collectstatic --no-input
+./manage.py shell --interface python <<END
+from users.models import Token
+try:
+    old_default_token = Token.objects.get(key="0123456789abcdef0123456789abcdef01234567")
+    if old_default_token:
+        print("⚠️ Warning: You have the old default admin API token in your database. This token is widely known; please remove it. Log in as your superuser and check API Tokens in your user menu.")
+except Token.DoesNotExist:
+    pass
+END
 
 echo "✅ Initialisation is done."
 
-# launch whatever is passed by docker
+# Launch whatever is passed by docker
 # (i.e. the RUN instruction in the Dockerfile)
-exec ${@}
+exec "$@"

docker/housekeeping.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+SLEEP_SECONDS=${HOUSEKEEPING_INTERVAL:=86400}
+echo "Interval set to ${SLEEP_SECONDS} seconds"
+while true; do
+  date
+  /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py housekeeping
+  sleep "${SLEEP_SECONDS}s"
+done

docker/launch-netbox.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+UNIT_CONFIG="${UNIT_CONFIG-/etc/unit/nginx-unit.json}"
+# Also used in "nginx-unit.json"
+UNIT_SOCKET="/opt/unit/unit.sock"
+
+load_configuration() {
+  MAX_WAIT=10
+  WAIT_COUNT=0
+  while [ ! -S $UNIT_SOCKET ]; do
+    if [ $WAIT_COUNT -ge $MAX_WAIT ]; then
+      echo "⚠️ No control socket found; configuration will not be loaded."
+      return 1
+    fi
+
+    WAIT_COUNT=$((WAIT_COUNT + 1))
+    echo "⏳ Waiting for control socket to be created... (${WAIT_COUNT}/${MAX_WAIT})"
+
+    sleep 1
+  done
+
+  # even when the control socket exists, it does not mean unit has finished initialisation
+  # this curl call will get a reply once unit is fully launched
+  curl --silent --output /dev/null --request GET --unix-socket $UNIT_SOCKET http://localhost/
+
+  echo "⚙️ Applying configuration from $UNIT_CONFIG"
+
+  RESP_CODE=$(
+    curl \
+      --silent \
+      --output /dev/null \
+      --write-out '%{http_code}' \
+      --request PUT \
+      --data-binary "@${UNIT_CONFIG}" \
+      --unix-socket $UNIT_SOCKET \
+      http://localhost/config
+  )
+  if [ "$RESP_CODE" != "200" ]; then
+    echo "⚠️ Could no load Unit configuration"
+    kill "$(cat /opt/unit/unit.pid)"
+    return 1
+  fi
+
+  echo "✅ Unit configuration loaded successfully"
+}
+
+load_configuration &
+
+exec unitd \
+  --no-daemon \
+  --control unix:$UNIT_SOCKET \
+  --pid /opt/unit/unit.pid \
+  --log /dev/stdout \
+  --statedir /opt/unit/state/ \
+  --tmpdir /opt/unit/tmp/ \
+  --user unit \
+  --group root

docker/ldap_config.docker.py

@@ -1,10 +1,23 @@
-import importlib.util
-import sys
+from .configuration import read_configurations
 
-try:
-  spec = importlib.util.spec_from_file_location('ldap_config', '/etc/netbox/config/ldap_config.py')
-  module = importlib.util.module_from_spec(spec)
-  spec.loader.exec_module(module)
-  sys.modules['netbox.ldap_config'] = module
-except:
-  raise ImportError('')
+_loaded_configurations = read_configurations(
+    config_dir="/etc/netbox/config/ldap/",
+    config_module="netbox.configuration.ldap",
+    main_config="ldap_config",
+)
+
+
+def __getattr__(name):
+    for config in _loaded_configurations:
+        try:
+            return getattr(config, name)
+        except:
+            pass
+    raise AttributeError
+
+
+def __dir__():
+    names = []
+    for config in _loaded_configurations:
+        names.extend(config.__dir__())
+    return names

docker/nginx-unit.json

@@ -0,0 +1,77 @@
+{
+  "listeners": {
+    "0.0.0.0:8080": {
+      "pass": "routes/main",
+      "forwarded": {
+        "client_ip": "X-Forwarded-For",
+        "protocol": "X-Forwarded-Proto",
+        "source": ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]
+      }
+    },
+    "0.0.0.0:8081": {
+      "pass": "routes/status",
+      "forwarded": {
+        "client_ip": "X-Forwarded-For",
+        "protocol": "X-Forwarded-Proto",
+        "source": ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]
+      }
+    },
+    "[::]:8080": {
+      "pass": "routes/main",
+      "forwarded": {
+        "client_ip": "X-Forwarded-For",
+        "protocol": "X-Forwarded-Proto",
+        "source": ["fc00::/7", "fe80::/10"]
+      }
+    },
+    "[::]:8081": {
+      "pass": "routes/status",
+      "forwarded": {
+        "client_ip": "X-Forwarded-For",
+        "protocol": "X-Forwarded-Proto",
+        "source": ["fc00::/7", "fe80::/10"]
+      }
+    }
+  },
+  "routes": {
+    "main": [
+      {
+        "match": {
+          "uri": "/static/*"
+        },
+        "action": {
+          "share": "/opt/netbox/netbox${uri}"
+        }
+      },
+      {
+        "action": {
+          "pass": "applications/netbox"
+        }
+      }
+    ],
+    "status": [
+      {
+        "match": {
+          "uri": "/status/*"
+        },
+        "action": {
+          "proxy": "http://unix:/opt/unit/unit.sock"
+        }
+      }
+    ]
+  },
+  "applications": {
+    "netbox": {
+      "type": "python 3",
+      "path": "/opt/netbox/netbox/",
+      "module": "netbox.wsgi",
+      "home": "/opt/netbox/venv",
+      "processes": {
+        "max": 4,
+        "spare": 1,
+        "idle_timeout": 120
+      }
+    }
+  },
+  "access_log": "/dev/stdout"
+}

docker/nginx.conf

@@ -1,36 +0,0 @@
-daemon off;
-worker_processes 1;
-
-error_log /dev/stderr info;
-
-events {
-    worker_connections 1024;
-}
-
-http {
-    include              /etc/nginx/mime.types;
-    default_type         application/octet-stream;
-    sendfile             on;
-    tcp_nopush           on;
-    keepalive_timeout    65;
-    gzip                 on;
-    server_tokens        off;
-    client_max_body_size 10M;
-
-    server {
-        listen      8080;
-        access_log  off;
-
-        location /static/ {
-            alias /opt/netbox/netbox/static/;
-        }
-
-        location / {
-            proxy_pass http://netbox:8001;
-            proxy_set_header X-Forwarded-Host $http_host;
-            proxy_set_header X-Real-IP $remote_addr;
-            proxy_set_header X-Forwarded-Proto $scheme;
-            add_header P3P 'CP="ALL DSP COR PSAa PSDa OUR NOR ONL UNI COM NAV"';
-        }
-    }
-}

docker/unit.list

@@ -0,0 +1 @@
+deb [signed-by=/usr/share/keyrings/nginx-keyring.gpg] http://packages.nginx.org/unit/ubuntu/ noble unit

env/netbox.env

@@ -1,24 +1,34 @@
-DB_NAME=netbox
-DB_USER=netbox
-DB_PASSWORD=J5brHrAXFLQSif0K
+CORS_ORIGIN_ALLOW_ALL=True
 DB_HOST=postgres
-EMAIL_SERVER=localhost
-EMAIL_PORT=25
-EMAIL_USERNAME=netbox
-EMAIL_PASSWORD=
-EMAIL_TIMEOUT=5
+DB_NAME=netbox
+DB_PASSWORD=J5brHrAXFLQSif0K
+DB_USER=netbox
 EMAIL_FROM=netbox@bar.com
+EMAIL_PASSWORD=
+EMAIL_PORT=25
+EMAIL_SERVER=localhost
+EMAIL_SSL_CERTFILE=
+EMAIL_SSL_KEYFILE=
+EMAIL_TIMEOUT=5
+EMAIL_USERNAME=netbox
+# EMAIL_USE_SSL and EMAIL_USE_TLS are mutually exclusive, i.e. they can't both be `true`!
+EMAIL_USE_SSL=false
+EMAIL_USE_TLS=false
+GRAPHQL_ENABLED=true
+HOUSEKEEPING_INTERVAL=86400
 MEDIA_ROOT=/opt/netbox/netbox/media
-NAPALM_USERNAME=
-NAPALM_PASSWORD=
-NAPALM_TIMEOUT=10
-MAX_PAGE_SIZE=1000
+METRICS_ENABLED=false
+REDIS_CACHE_DATABASE=1
+REDIS_CACHE_HOST=redis-cache
+REDIS_CACHE_INSECURE_SKIP_TLS_VERIFY=false
+REDIS_CACHE_PASSWORD=t4Ph722qJ5QHeQ1qfu36
+REDIS_CACHE_SSL=false
+REDIS_DATABASE=0
 REDIS_HOST=redis
+REDIS_INSECURE_SKIP_TLS_VERIFY=false
 REDIS_PASSWORD=H733Kdjndks81
 REDIS_SSL=false
-SECRET_KEY=r8OwDznj!!dci#P9ghmRfdu1Ysxm0AiPeDCQhKE+N_rClfWNj
-SUPERUSER_NAME=admin
-SUPERUSER_EMAIL=admin@example.com
-SUPERUSER_PASSWORD=admin
-SUPERUSER_API_TOKEN=0123456789abcdef0123456789abcdef01234567
+RELEASE_CHECK_URL=https://api.github.com/repos/netbox-community/netbox/releases
+SECRET_KEY='r(m)9nLGnz$(_q3N4z1k(EFsMCjjjzx08x9VhNVcfd%6RF#r!6DE@+V5Zk2X'
+SKIP_SUPERUSER=true
 WEBHOOKS_ENABLED=true

env/postgres.env

@@ -1,3 +1,3 @@
-POSTGRES_USER=netbox
-POSTGRES_PASSWORD=J5brHrAXFLQSif0K
 POSTGRES_DB=netbox
+POSTGRES_PASSWORD=J5brHrAXFLQSif0K
+POSTGRES_USER=netbox

env/redis-cache.env

@@ -0,0 +1 @@
+REDIS_PASSWORD=t4Ph722qJ5QHeQ1qfu36

hooks/build

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-. hooks/common
-
-run_build

hooks/common

@@ -1,82 +0,0 @@
-#!/bin/bash
-
-ensure_jq() {
-  echo "🛠🛠🛠 Installing JQ via apt-get"
-  [ -x "$(command -v jq)" ] || ( apt-get update && apt-get install -y jq )
-}
-
-ensure_dockerfile_present() {
-  if [ "${VARIANT}" == "main" ]; then
-    DOCKERFILE="Dockerfile"
-  else
-    DOCKERFILE="Dockerfile.${VARIANT}"
-
-    # Fail fast
-    if [ ! -f "${DOCKERFILE}" ]; then
-      echo "🚨 The Dockerfile '${DOCKERFILE}' for variant '${VARIANT}' doesn't exist."
-
-      if [ -z "$DEBUG" ]; then
-        exit 1
-      else
-        echo "⚠️ Would skip this, but DEBUG is enabled."
-      fi
-    fi
-
-    if [ "${DOCKERFILE}" != "${DOCKERFILE_PATH}" ]; then
-      echo "⚠️ The specified Dockerfile '${DOCKERFILE_PATH}' does not match the expected Dockerfile '${DOCKERFILE}'."
-      echo "   This script will use '${DOCKERFILE}' and ignore '${DOCKERFILE_PATH}'."
-    fi
-  fi
-}
-
-# Passes args to the scripts
-run_build() {
-  echo "🐳🐳🐳 Building '${BUILD}' images, the '${VARIANT:-main}' variant"
-  case $BUILD in
-    release)
-      # build the latest release
-      # shellcheck disable=SC2068
-      ./build-latest.sh $@
-      ;;
-    prerelease)
-      # build the latest pre-release
-      # shellcheck disable=SC2068
-      PRERELEASE=true ./build-latest.sh $@
-      ;;
-    branches)
-      # build all branches
-      # shellcheck disable=SC2068
-      ./build-branches.sh $@
-      ;;
-    special)
-      # special build
-      # shellcheck disable=SC2068
-      #SRC_ORG=lampwins TAG=webhooks-backend ./build.sh "feature/webhooks-backend" $@
-      echo "✅ No special builds today."
-      ;;
-    *)
-      echo "🚨 Unrecognized build '$BUILD'."
-
-      if [ -z "$DEBUG" ]; then
-        exit 1
-      else
-        echo "⚠️ Would exit here with code '1', but DEBUG is enabled."
-      fi
-      ;;
-  esac
-}
-
-echo "🤖🤖🤖 Preparing build"
-export DOCKER_ORG="index.docker.io/netboxcommunity"
-export DOCKER_REPO=netbox
-export DOCKERHUB_REPO=netboxcommunity/netbox
-
-# mis-using the "${DOCKER_TAG}" variable as "branch to build"
-export BUILD="${DOCKER_TAG%-*}"
-export VARIANT="${DOCKER_TAG#*-}"
-
-unset DOCKER_TAG
-
-ensure_dockerfile_present
-
-ensure_jq

hooks/push

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-. hooks/common
-
-run_build --push-only

hooks/test

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-. hooks/common
-
-if [ "${VARIANT}" == "main" ] && [ "${BUILD}" == "BRANCHES" ]; then
-  echo "🐳🐳🐳 Testing"
-  docker-compose pull --parallel
-  docker-compose build
-  docker-compose run netbox ./manage.py test
-else
-  echo "🐳🐳🐳 No tests are implemented for build '${BUILD}' with variant '${VARIANT}'."
-fi

initializers/custom_fields.yml

@@ -1,82 +0,0 @@
-# text_field:
-#   type: text
-#   label: Custom Text
-#   description: Enter text in a text field.
-#   required: false
-#   weight: 0
-#   on_objects:
-#   - dcim.models.Device
-#   - dcim.models.Rack
-#   - dcim.models.Site
-#   - dcim.models.DeviceType
-#   - ipam.models.IPAddress
-#   - ipam.models.Prefix
-#   - tenancy.models.Tenant
-#   - virtualization.models.VirtualMachine
-# integer_field:
-#   type: integer
-#   label: Custom Number
-#   description: Enter numbers into an integer field.
-#   required: true
-#   filter_logic: loose
-#   weight: 10
-#   on_objects:
-#   - tenancy.models.Tenant
-# selection_field:
-#   type: selection
-#   label: Choose between items
-#   required: false
-#   filter_logic: exact
-#   weight: 30
-#   on_objects:
-#   - dcim.models.Device
-#   choices:
-#   - value: First Item
-#     weight: 10
-#   - value: Second Item
-#     weight: 20
-#   - value: Third Item
-#     weight: 30
-#   - value: Fifth Item
-#     weight: 50
-#   - value: Fourth Item
-#     weight: 40
-# selection_field_auto_weight:
-#    type: selection
-#    label: Choose between items
-#    required: false
-#    filter_logic: loose
-#    weight: 30
-#    on_objects:
-#     - dcim.models.Device
-#    choices:
-#     - value: A
-#     - value: B
-#     - value: C
-#     - value: "D like deprecated"
-#       weight: 999
-#     - value: E
-# boolean_field:
-#   type: boolean
-#   label: Yes Or No?
-#   required: true
-#   filter_logic: loose
-#   default: "false" # important: but "false" in quotes!
-#   weight: 90
-#   on_objects:
-#   - dcim.models.Device
-# url_field:
-#   type: url
-#   label: Hyperlink
-#   description: Link to something nice.
-#   required: true
-#   filter_logic: disabled
-#   on_objects:
-#   - tenancy.models.Tenant
-# date_field:
-#   type: date
-#   label: Important Date
-#   required: false
-#   filter_logic: disabled
-#   on_objects:
-#   - dcim.models.Device

initializers/device_roles.yml

@@ -1,15 +0,0 @@
-# - name: switch
-#   slug: switch
-#   color: Grey
-# - name: router
-#   slug: router
-#   color: Cyan
-# - name: load-balancer
-#   slug: load-balancer
-#   color: Red
-# - name: server
-#   slug: server
-#   color: Blue
-# - name: patchpanel
-#   slug: patchpanel
-#   color: Black

initializers/device_types.yml

@@ -1,23 +0,0 @@
-# - model: Model 1
-#   manufacturer: Manufacturer 1
-#   slug: model-1
-#   u_height: 2
-#   custom_fields:
-#     text_field: Description
-# - model: Model 2
-#   manufacturer: Manufacturer 1
-#   slug: model-2
-#   custom_fields:
-#     text_field: Description
-# - model: Model 3
-#   manufacturer: Manufacturer 1
-#   slug: model-3
-#   is_full_depth: false
-#   u_height: 0
-#   custom_fields:
-#     text_field: Description
-# - model: Other
-#   manufacturer: NoName
-#   slug: other
-#   custom_fields:
-#     text_field: Description

initializers/devices.yml

@@ -1,27 +0,0 @@
-# - name: server01
-#   device_role: server
-#   device_type: Other
-#   site: AMS 1
-#   rack: rack-01
-#   face: Front
-#   position: 1
-#   custom_fields:
-#     text_field: Description
-# - name: server02
-#   device_role: server
-#   device_type: Other
-#   site: AMS 2
-#   rack: rack-02
-#   face: Front
-#   position: 2
-#   custom_fields:
-#     text_field: Description
-# - name: server03
-#   device_role: server
-#   device_type: Other
-#   site: SING 1
-#   rack: rack-03
-#   face: Front
-#   position: 3
-#   custom_fields:
-#     text_field: Description

initializers/groups.yml

@@ -1,16 +0,0 @@
-# applications:
-#   users:
-#   - technical_user
-# readers:
-#   users:
-#   - reader
-# writers:
-#   users:
-#   - writer
-#   permissions:
-#   - add_device
-#   - change_device
-#   - delete_device
-#   - add_virtualmachine
-#   - change_virtualmachine
-#   - delete_virtualmachine

initializers/manufacturers.yml

@@ -1,6 +0,0 @@
-# - name: Manufacturer 1
-#   slug: manufacturer-1
-# - name: Manufacturer 2
-#   slug: manufacturer-2
-# - name: NoName
-#   slug: noname

initializers/platforms.yml

@@ -1,19 +0,0 @@
-# # Allowed rpc clients are: juniper-junos, cisco-ios, opengear
-# - name: Platform 1
-#   slug: platform-1
-#   manufacturer: Manufacturer 1
-#   napalm_driver: driver1
-#   napalm_args: "{'arg1': 'value1', 'arg2': 'value2'}"
-#   rpc_client: juniper-junos
-# - name: Platform 2
-#   slug: platform-2
-#   manufacturer: Manufacturer 2
-#   napalm_driver: driver2
-#   napalm_args: "{'arg1': 'value1', 'arg2': 'value2'}"
-#   rpc_client: opengear
-# - name: Platform 3
-#   slug: platform-3
-#   manufacturer: NoName
-#   napalm_driver: driver3
-#   napalm_args: "{'arg1': 'value1', 'arg2': 'value2'}"
-#   rpc_client: juniper-junos

initializers/rack_roles.yml

@@ -1,12 +0,0 @@
-# - name: Role 1
-#   slug: role-1
-#   color: Pink
-# - name: Role 2
-#   slug: role-2
-#   color: Cyan
-# - name: Role 3
-#   slug: role-3
-#   color: Grey
-# - name: Role 4
-#   slug: role-4
-#   color: Teal

initializers/racks.yml

@@ -1,24 +0,0 @@
-# - site: AMS 1
-#   name: rack-01
-#   role: Role 1
-#   type: 4-post cabinet
-#   width: 19 inches
-#   u_height: 47
-#   custom_fields:
-#     text_field: Description
-# - site: AMS 2
-#   name: rack-02
-#   role: Role 2
-#   type: 4-post cabinet
-#   width: 19 inches
-#   u_height: 47
-#   custom_fields:
-#     text_field: Description
-# - site: SING 1
-#   name: rack-03
-#   role: Role 3
-#   type: 4-post cabinet
-#   width: 19 inches
-#   u_height: 47
-#   custom_fields:
-#     text_field: Description

initializers/regions.yml

@@ -1,10 +0,0 @@
-# - name: Singapore
-#   slug: singapore
-# - name: Amsterdam
-#   slug: amsterdam
-# - name: Downtown
-#   slug: downtown
-#   parent: Amsterdam
-# - name: Suburbs
-#   slug: suburbs
-#   parent: Amsterdam

initializers/sites.yml

@@ -1,32 +0,0 @@
-# - name: AMS 1
-#   slug: ams1
-#   region: Downtown
-#   status: 1
-#   facility: Amsterdam 1
-#   asn: 12345
-#   custom_fields:
-#     text_field: Description
-# - name: AMS 2
-#   slug: ams2
-#   region: Downtown
-#   status: 1
-#   facility: Amsterdam 2
-#   asn: 54321
-#   custom_fields:
-#     text_field: Description
-# - name: AMS 3
-#   slug: ams3
-#   region: Suburbs
-#   status: 1
-#   facility: Amsterdam 3
-#   asn: 67890
-#   custom_fields:
-#     text_field: Description
-# - name: SING 1
-#   slug: sing1
-#   region: Singapore
-#   status: 1
-#   facility: Singapore 1
-#   asn: 09876
-#   custom_fields:
-#     text_field: Description

initializers/users.yml

@@ -1,13 +0,0 @@
-# technical_user:
-#   api_token: 0123456789technicaluser789abcdef01234567 # must be looooong!
-# reader:
-#   password: reader
-# writer:
-#   password: writer
-#   permissions:
-#   - add_device
-#   - change_device
-#   - delete_device
-#   - add_virtualmachine
-#   - change_virtualmachine
-#   - delete_virtualmachine

pyproject.toml

@@ -0,0 +1,26 @@
+[tool.black]
+line_length = 100
+target-version = ['py38']
+include = '\.pyi?$'
+exclude = '''
+(
+  /(
+      \.git
+    | \.venv
+    | \.netbox
+    | \.vscode
+    | configuration
+  )/
+)
+'''
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 100
+
+[tool.pylint.messages_control]
+disable = "C0330, C0326"
+
+[tool.pylint.format]
+max-line-length = "100"

release.sh

@@ -0,0 +1,188 @@
+#!/bin/bash
+
+DEFAULT_REPO=netbox-community/netbox-docker
+REPO="${REPO-${DEFAULT_REPO}}"
+
+echomoji() {
+  EMOJI=${1}
+  TEXT=${2}
+  shift 2
+  if [ -z "$DISABLE_EMOJI" ]; then
+    echo "${EMOJI}" "${@}"
+  else
+    echo "${TEXT}" "${@}"
+  fi
+}
+
+echo_nok() {
+  echomoji "❌" "!" "${@}"
+}
+echo_ok() {
+  echomoji "✅" "-" "${@}"
+}
+echo_hint() {
+  echomoji "👉" ">" "${@}"
+}
+
+# check errors shall exit with code 1
+
+check_clean_repo() {
+  changes=$(git status --porcelain 2>/dev/null)
+  if [ ${?} ] && [ -n "$changes" ]; then
+    echo_nok "There are git changes pending:"
+    echo "$changes"
+    echo_hint "Please clean the repository before continueing: git stash --include-untracked"
+    exit 1
+  fi
+  echo_ok "Repository has no pending changes."
+}
+
+check_branch() {
+  expected_branch="${1}"
+  actual_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
+  if [ ${?} ] && [ "${actual_branch}" != "${expected_branch}" ]; then
+    echo_nok "Current branch should be '${expected_branch}', but is '${actual_branch}'."
+    echo_hint "Please change to the '${expected_branch}' branch: git checkout ${expected_branch}"
+    exit 1
+  fi
+  echo_ok "The current branch is '${actual_branch}'."
+}
+
+check_upstream() {
+  expected_upstream_branch="origin/${1}"
+  actual_upstream_branch=$(git rev-parse --abbrev-ref '@{upstream}' 2>/dev/null)
+  if [ ${?} ] && [ "${actual_upstream_branch}" != "${expected_upstream_branch}" ]; then
+    echo_nok "Current upstream branch should be '${expected_upstream_branch}', but is '${actual_upstream_branch}'."
+    echo_hint "Please set '${expected_upstream_branch}' as the upstream branch: git branch --set-upstream-to=${expected_upstream_branch}"
+    exit 1
+  fi
+  echo_ok "The current upstream branch is '${actual_upstream_branch}'."
+}
+
+check_origin() {
+  expected_origin="git@github.com:${REPO}.git"
+  actual_origin=$(git remote get-url origin 2>/dev/null)
+  if [ ${?} ] && [ "${actual_origin}" != "${expected_origin}" ]; then
+    echo_nok "The url of origin is '${actual_origin}', but '${expected_origin}' is expected."
+    echo_hint "Please set '${expected_origin}' as the url for origin: git origin set-url '${expected_origin}'"
+    exit 1
+  fi
+  echo_ok "The current origin url is '${actual_origin}'."
+}
+
+check_latest() {
+  git fetch --tags origin
+
+  local_head_commit=$(git rev-parse HEAD 2>/dev/null)
+  remote_head_commit=$(git rev-parse FETCH_HEAD 2>/dev/null)
+  if [ "${local_head_commit}" != "${remote_head_commit}" ]; then
+    echo_nok "HEAD is at '${local_head_commit}', but FETCH_HEAD is at '${remote_head_commit}'."
+    echo_hint "Please ensure that you have pushed and pulled all the latest chanegs: git pull --prune --rebase origin; git push origin"
+    exit 1
+  fi
+  echo_ok "HEAD and FETCH_HEAD both point to '${local_head_commit}'."
+}
+
+check_tag() {
+  local tag
+
+  tag=$(<VERSION)
+  if git rev-parse "${tag}" 2>/dev/null >/dev/null; then
+    echo_nok "The tag '${tag}' already points to '$(git rev-parse "${tag}" 2>/dev/null)'."
+    echo_hint "Please ensure that the 'VERSION' file has been updated before trying to release: echo X.Y.Z > VERSION"
+    exit 1
+  fi
+  echo_ok "The tag '${tag}' does not exist yet."
+}
+
+check_develop() {
+  echomoji 📋 "?" "Checking 'develop' branch"
+
+  check_branch develop
+  check_upstream develop
+  check_clean_repo
+  check_latest
+}
+
+check_release() {
+  echomoji 📋 "?" "Checking 'release' branch"
+
+  check_upstream release
+  check_clean_repo
+  check_latest
+}
+
+# git errors shall exit with code 2
+
+git_switch() {
+  echomoji 🔀 "≈" "Switching to '${1}' branch…"
+  if ! git checkout "${1}" >/dev/null; then
+    echo_nok "It was not possible to switch to the branch '${1}'."
+    exit 2
+  fi
+  echo_ok "The branch is now '${1}'."
+}
+
+git_tag() {
+  echomoji 🏷 "X" "Tagging version '${1}'…"
+  if ! git tag "${1}"; then
+    echo_nok "The tag '${1}' was not created because of an error."
+    exit 2
+  fi
+  echo_ok "The tag '$(<VERSION)' was created."
+}
+
+git_push() {
+  echomoji ⏩ "»" "Pushing the tag '${2}' to '${1}'…"
+  if ! git push "${1}" "${2}"; then
+    echo_nok "The tag '${2}' could not be pushed to '${1}'."
+    exit 2
+  fi
+  echo_ok "The tag '${2}' was pushed."
+}
+
+git_merge() {
+  echomoji ⏩ "»" "Merging '${1}'…"
+  if ! git merge --no-ff "${1}"; then
+    echo_nok "The branch '${1}' could not be merged."
+    exit 2
+  fi
+  echo_ok "The branch '${2}' was merged."
+}
+
+git_merge() {
+  echomoji ⏩ "»" "Rebasing onto '${1}'…"
+  if ! git rebase "${1}"; then
+    echo_nok "Could not rebase onto '${1}'."
+    exit 2
+  fi
+  echo_ok "Rebased onto '${2}'."
+}
+
+###
+# MAIN
+###
+
+echomoji 📋 "▶︎" "Checking pre-requisites for releasing '$(<VERSION)'"
+
+check_origin
+
+check_develop
+check_tag
+
+git_switch release
+check_release
+
+echomoji 📋 "▶︎" "Releasing '$(<VERSION)'"
+
+git_merge develop
+check_tag
+git_tag "$(<VERSION)"
+
+git_push "origin" release
+git_push "origin" "$(<VERSION)"
+
+git_switch develop
+git_rebase release
+
+echomoji ✅ "◼︎" "The release of '$(<VERSION)' is complete."

renovate.json

@@ -0,0 +1,14 @@
+{
+  "extends": [
+    "config:base",
+    ":disableDependencyDashboard"
+  ],
+  "enabled": true,
+  "labels": ["maintenance"],
+  "baseBranches": ["develop"],
+  "pip_requirements": {
+    "fileMatch": [
+      "requirements-container.txt"
+    ]
+  }
+}

reports/devices.py.example

@@ -1,46 +0,0 @@
-from dcim.constants import CONNECTION_STATUS_PLANNED, DEVICE_STATUS_ACTIVE
-from dcim.models import ConsolePort, Device, PowerPort
-from extras.reports import Report
-
-
-class DeviceConnectionsReport(Report):
-    description = "Validate the minimum physical connections for each device"
-
-    def test_console_connection(self):
-
-        # Check that every console port for every active device has a connection defined.
-        for console_port in ConsolePort.objects.select_related('device').filter(device__status=DEVICE_STATUS_ACTIVE):
-            if console_port.connected_endpoint is None:
-                self.log_failure(
-                    console_port.device,
-                    "No console connection defined for {}".format(console_port.name)
-                )
-            elif console_port.connection_status == CONNECTION_STATUS_PLANNED:
-                self.log_warning(
-                    console_port.device,
-                    "Console connection for {} marked as planned".format(console_port.name)
-                )
-            else:
-                self.log_success(console_port.device)
-
-    def test_power_connections(self):
-
-        # Check that every active device has at least two connected power supplies.
-        for device in Device.objects.filter(status=DEVICE_STATUS_ACTIVE):
-            connected_ports = 0
-            for power_port in PowerPort.objects.filter(device=device):
-                if power_port.connected_endpoint is not None:
-                    connected_ports += 1
-                    if power_port.connection_status == CONNECTION_STATUS_PLANNED:
-                        self.log_warning(
-                            device,
-                            "Power connection for {} marked as planned".format(power_port.name)
-                        )
-            if connected_ports < 2:
-                self.log_failure(
-                    device,
-                    "{} connected power supplies found (2 needed)".format(connected_ports)
-                )
-            else:
-                self.log_success(device)
-

requirements-container.txt

@@ -0,0 +1,6 @@
+django-auth-ldap==5.2.0
+dulwich==0.22.8
+python3-saml==1.16.0
+--no-binary lxml
+--no-binary xmlsec
+sentry-sdk[django]==2.29.1

startup_scripts/000_users.py

@@ -1,34 +0,0 @@
-from django.contrib.auth.models import Permission, Group, User
-from users.models import Token
-
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/users.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml=YAML(typ='safe')
-  users = yaml.load(stream)
-
-  if users is not None:
-    for username, user_details in users.items():
-      if not User.objects.filter(username=username):
-        user = User.objects.create_user(
-          username = username,
-          password = user_details.get('password', 0) or User.objects.make_random_password)
-
-        print("👤 Created user ",username)
-
-        if user_details.get('api_token', 0):
-          Token.objects.create(user=user, key=user_details['api_token'])
-
-        user_permissions = user_details.get('permissions', [])
-        if user_permissions:
-          user.user_permissions.clear()
-          for permission_codename in user_details.get('permissions', []):
-            permission = Permission.objects.get(codename=permission_codename)
-            user.user_permissions.add(permission)
-          user.save()

startup_scripts/010_groups.py

@@ -1,33 +0,0 @@
-from django.contrib.auth.models import Permission, Group, User
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/groups.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml=YAML(typ='safe')
-  groups = yaml.load(stream)
-
-  if groups is not None:
-    for groupname, group_details in groups.items():
-      group, created = Group.objects.get_or_create(name=groupname)
-
-      if created:
-        print("👥 Created group", groupname)
-
-      for username in group_details.get('users', []):
-        user = User.objects.get(username=username)
-
-        if user:
-          user.groups.add(group)
-
-      group_permissions = group_details.get('permissions', [])
-      if group_permissions:
-        group.permissions.clear()
-        print("Permissions:", group.permissions.all())
-        for permission_codename in group_details.get('permissions', []):
-          permission = Permission.objects.get(codename=permission_codename)
-          group.permissions.add(permission)

startup_scripts/020_custom_fields.py

@@ -1,75 +0,0 @@
-from extras.constants import CF_TYPE_TEXT, CF_TYPE_INTEGER, CF_TYPE_BOOLEAN, CF_TYPE_DATE, CF_TYPE_URL, CF_TYPE_SELECT, CF_FILTER_CHOICES
-from extras.models import CustomField, CustomFieldChoice
-
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-text_to_fields = {
-  'boolean': CF_TYPE_BOOLEAN,
-  'date': CF_TYPE_DATE,
-  'integer': CF_TYPE_INTEGER,
-  'selection': CF_TYPE_SELECT,
-  'text': CF_TYPE_TEXT,
-  'url': CF_TYPE_URL,
-}
-
-def get_class_for_class_path(class_path):
-  import importlib
-  from django.contrib.contenttypes.models import ContentType
-
-  module_name, class_name = class_path.rsplit(".", 1)
-  module = importlib.import_module(module_name)
-  clazz = getattr(module, class_name)
-  return ContentType.objects.get_for_model(clazz)
-
-file = Path('/opt/netbox/initializers/custom_fields.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml = YAML(typ='safe')
-  customfields = yaml.load(stream)
-
-  if customfields is not None:
-    for cf_name, cf_details in customfields.items():
-      custom_field, created = CustomField.objects.get_or_create(name = cf_name)
-
-      if created:
-        if cf_details.get('default', 0):
-          custom_field.default = cf_details['default']
-
-        if cf_details.get('description', 0):
-          custom_field.description = cf_details['description']
-
-        # If no filter_logic is specified then it will default to 'Loose'
-        if cf_details.get('filter_logic', 0):
-          for choice_id, choice_text in CF_FILTER_CHOICES:
-            if choice_text.lower() == cf_details['filter_logic']:
-              custom_field.filter_logic = choice_id
-
-        if cf_details.get('label', 0):
-          custom_field.label = cf_details['label']
-
-        for object_type in cf_details.get('on_objects', []):
-          custom_field.obj_type.add(get_class_for_class_path(object_type))
-
-        if cf_details.get('required', 0):
-          custom_field.required = cf_details['required']
-
-        if cf_details.get('type', 0):
-          custom_field.type = text_to_fields[cf_details['type']]
-
-        if cf_details.get('weight', 0):
-          custom_field.weight = cf_details['weight']
-
-        custom_field.save()
-
-        for idx, choice_details in enumerate(cf_details.get('choices', [])):
-          choice, _ = CustomFieldChoice.objects.get_or_create(
-            field=custom_field,
-            value=choice_details['value'],
-            defaults={'weight': idx * 10}
-          )
-
-        print("🔧 Created custom field", cf_name)

startup_scripts/030_regions.py

@@ -1,31 +0,0 @@
-from dcim.models import Region
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/regions.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml=YAML(typ='safe')
-  regions = yaml.load(stream)
-
-  optional_assocs = {
-    'parent': (Region, 'name')
-  }
-
-  if regions is not None:
-    for params in regions:
-
-      for assoc, details in optional_assocs.items():
-        if assoc in params:
-          model, field = details
-          query = { field: params.pop(assoc) }
-
-          params[assoc] = model.objects.get(**query)
-
-      region, created = Region.objects.get_or_create(**params)
-
-      if created:
-        print("🌐 Created region", region.name)

startup_scripts/040_sites.py

@@ -1,46 +0,0 @@
-from dcim.models import Region, Site
-from extras.models import CustomField, CustomFieldValue
-from tenancy.models import Tenant
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/sites.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml = YAML(typ='safe')
-  sites = yaml.load(stream)
-
-  optional_assocs = {
-    'region': (Region, 'name'),
-    'tenant': (Tenant, 'name')
-  }
-
-  if sites is not None:
-    for params in sites:
-      custom_fields = params.pop('custom_fields', None)
-
-      for assoc, details in optional_assocs.items():
-        if assoc in params:
-          model, field = details
-          query = { field: params.pop(assoc) }
-
-          params[assoc] = model.objects.get(**query)
-
-      site, created = Site.objects.get_or_create(**params)
-
-      if created:
-        if custom_fields is not None:
-          for cf_name, cf_value in custom_fields.items():
-            custom_field = CustomField.objects.get(name=cf_name)
-            custom_field_value = CustomFieldValue.objects.create(
-              field=custom_field,
-              obj=site,
-              value=cf_value
-            )
-
-            site.custom_field_values.add(custom_field_value)
-
-        print("📍 Created site", site.name)

startup_scripts/050_manufacturers.py

@@ -1,19 +0,0 @@
-from dcim.models import Manufacturer
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/manufacturers.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml = YAML(typ='safe')
-  manufacturers = yaml.load(stream)
-
-  if manufacturers is not None:
-    for params in manufacturers:
-      manufacturer, created = Manufacturer.objects.get_or_create(**params)
-
-      if created:
-        print("🏭 Created Manufacturer", manufacturer.name)

startup_scripts/060_device_types.py

@@ -1,56 +0,0 @@
-from dcim.models import DeviceType, Manufacturer, Region
-from tenancy.models import Tenant
-from extras.models import CustomField, CustomFieldValue
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/device_types.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml = YAML(typ='safe')
-  device_types = yaml.load(stream)
-
-  required_assocs = {
-    'manufacturer': (Manufacturer, 'name')
-  }
-
-  optional_assocs = {
-    'region': (Region, 'name'),
-    'tenant': (Tenant, 'name')
-  }
-
-  if device_types is not None:
-    for params in device_types:
-      custom_fields = params.pop('custom_fields', None)
-
-      for assoc, details in required_assocs.items():
-        model, field = details
-        query = { field: params.pop(assoc) }
-
-        params[assoc] = model.objects.get(**query)
-
-      for assoc, details in optional_assocs.items():
-        if assoc in params:
-          model, field = details
-          query = { field: params.pop(assoc) }
-
-          params[assoc] = model.objects.get(**query)
-
-      device_type, created = DeviceType.objects.get_or_create(**params)
-
-      if created:
-        if custom_fields is not None:
-          for cf_name, cf_value in custom_fields.items():
-            custom_field = CustomField.objects.get(name=cf_name)
-            custom_field_value = CustomFieldValue.objects.create(
-              field=custom_field,
-              obj=device_type,
-              value=cf_value
-            )
-
-            device_type.custom_field_values.add(custom_field_value)
-
-        print("🔡 Created device type", device_type.manufacturer, device_type.model)

startup_scripts/070_rack_roles.py

@@ -1,28 +0,0 @@
-from dcim.models import RackRole
-from ruamel.yaml import YAML
-from utilities.forms import COLOR_CHOICES
-
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/rack_roles.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml=YAML(typ='safe')
-  rack_roles = yaml.load(stream)
-
-  if rack_roles is not None:
-    for params in rack_roles:
-      if 'color' in params:
-        color = params.pop('color')
-
-        for color_tpl in COLOR_CHOICES:
-          if color in color_tpl:
-            params['color'] = color_tpl[0]
-
-      rack_role, created = RackRole.objects.get_or_create(**params)
-
-      if created:
-        print("🎨 Created rack role", rack_role.name)

startup_scripts/080_racks.py

@@ -1,66 +0,0 @@
-from dcim.models import Site, RackRole, Rack, RackGroup
-from tenancy.models import Tenant
-from extras.models import CustomField, CustomFieldValue
-from dcim.constants import RACK_TYPE_CHOICES, RACK_WIDTH_CHOICES
-from ruamel.yaml import YAML
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/racks.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml = YAML(typ='safe')
-  racks = yaml.load(stream)
-
-  required_assocs = {
-    'site': (Site, 'name')
-  }
-
-  optional_assocs = {
-    'role': (RackRole, 'name'),
-    'tenant': (Tenant, 'name'),
-    'group': (RackGroup, 'name')
-  }
-
-  if racks is not None:
-    for params in racks:
-      custom_fields = params.pop('custom_fields', None)
-
-      for assoc, details in required_assocs.items():
-        model, field = details
-        query = { field: params.pop(assoc) }
-
-        params[assoc] = model.objects.get(**query)
-
-      for assoc, details in optional_assocs.items():
-        if assoc in params:
-          model, field = details
-          query = { field: params.pop(assoc) }
-
-          params[assoc] = model.objects.get(**query)
-
-      for rack_type in RACK_TYPE_CHOICES:
-        if params['type'] in rack_type:
-          params['type'] = rack_type[0]
-
-      for rack_width in RACK_WIDTH_CHOICES:
-        if params['width'] in rack_width:
-          params['width'] = rack_width[0]
-
-      rack, created = Rack.objects.get_or_create(**params)
-
-      if created:
-        if custom_fields is not None:
-          for cf_name, cf_value in custom_fields.items():
-            custom_field = CustomField.objects.get(name=cf_name)
-            custom_field_value = CustomFieldValue.objects.create(
-              field=custom_field,
-              obj=rack,
-              value=cf_value
-            )
-
-            rack.custom_field_values.add(custom_field_value)
-
-        print("🔳 Created rack", rack.site, rack.name)

startup_scripts/090_device_roles.py

@@ -1,29 +0,0 @@
-from dcim.models import DeviceRole
-from ruamel.yaml import YAML
-from utilities.forms import COLOR_CHOICES
-
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/device_roles.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml=YAML(typ='safe')
-  device_roles = yaml.load(stream)
-
-  if device_roles is not None:
-    for params in device_roles:
-
-      if 'color' in params:
-        color = params.pop('color')
-
-        for color_tpl in COLOR_CHOICES:
-          if color in color_tpl:
-            params['color'] = color_tpl[0]
-
-      device_role, created = DeviceRole.objects.get_or_create(**params)
-
-      if created:
-        print("🎨 Created device role", device_role.name)

startup_scripts/100_platforms.py

@@ -1,32 +0,0 @@
-from dcim.models import Manufacturer, Platform
-from ruamel.yaml import YAML
-
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/platforms.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml = YAML(typ='safe')
-  platforms = yaml.load(stream)
-
-  optional_assocs = {
-    'manufacturer': (Manufacturer, 'name'),
-  }
-
-  if platforms is not None:
-    for params in platforms:
-
-      for assoc, details in optional_assocs.items():
-        if assoc in params:
-          model, field = details
-          query = { field: params.pop(assoc) }
-
-          params[assoc] = model.objects.get(**query)
-
-      platform, created = Platform.objects.get_or_create(**params)
-
-      if created:
-        print("💾 Created platform", platform.name)

startup_scripts/110_devices.py

@@ -1,71 +0,0 @@
-from dcim.models import Site, Rack, DeviceRole, DeviceType, Device, Platform
-from dcim.constants import RACK_FACE_CHOICES
-from ipam.models import IPAddress
-from virtualization.models import Cluster
-from tenancy.models import Tenant
-from extras.models import CustomField, CustomFieldValue
-from ruamel.yaml import YAML
-
-from pathlib import Path
-import sys
-
-file = Path('/opt/netbox/initializers/devices.yml')
-if not file.is_file():
-  sys.exit()
-
-with file.open('r') as stream:
-  yaml = YAML(typ='safe')
-  devices = yaml.load(stream)
-
-  required_assocs = {
-    'device_role': (DeviceRole, 'name'),
-    'device_type': (DeviceType, 'model'),
-    'site': (Site, 'name')
-  }
-
-  optional_assocs = {
-    'tenant': (Tenant, 'name'),
-    'platform': (Platform, 'name'),
-    'rack': (Rack, 'name'),
-    'cluster': (Cluster, 'name'),
-    'primary_ip4': (IPAddress, 'address'),
-    'primary_ip6': (IPAddress, 'address')
-  }
-
-  if devices is not None:
-    for params in devices:
-      custom_fields = params.pop('custom_fields', None)
-
-      for assoc, details in required_assocs.items():
-        model, field = details
-        query = { field: params.pop(assoc) }
-
-        params[assoc] = model.objects.get(**query)
-
-      for assoc, details in optional_assocs.items():
-        if assoc in params:
-          model, field = details
-          query = { field: params.pop(assoc) }
-
-          params[assoc] = model.objects.get(**query)
-
-      if 'face' in params:
-        for rack_face in RACK_FACE_CHOICES:
-          if params['face'] in rack_face:
-            params['face'] = rack_face[0]
-
-      device, created = Device.objects.get_or_create(**params)
-
-      if created:
-        if custom_fields is not None:
-          for cf_name, cf_value in custom_fields.items():
-            custom_field = CustomField.objects.get(name=cf_name)
-            custom_field_value = CustomFieldValue.objects.create(
-              field=custom_field,
-              obj=device,
-              value=cf_value
-            )
-
-            device.custom_field_values.add(custom_field_value)
-
-        print("🖥️  Created device", device.name)

test-configuration/test_config.py

@@ -0,0 +1,12 @@
+LOGGING = {
+    'version': 1,
+    'disable_existing_loggers': True
+}
+
+PLUGINS = [
+    'netbox.tests.dummy_plugin',
+]
+
+ALLOW_TOKEN_RETRIEVAL = True
+
+DEFAULT_PERMISSIONS = {}

test.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+# Runs the original NetBox unit tests and tests whether all initializers work.
+# Usage:
+#   ./test.sh latest
+#   ./test.sh v2.9.7
+#   ./test.sh develop-2.10
+#   IMAGE='netboxcommunity/netbox:latest'        ./test.sh
+#   IMAGE='netboxcommunity/netbox:v2.9.7'        ./test.sh
+#   IMAGE='netboxcommunity/netbox:develop-2.10'  ./test.sh
+#   export IMAGE='netboxcommunity/netbox:latest';       ./test.sh
+#   export IMAGE='netboxcommunity/netbox:v2.9.7';       ./test.sh
+#   export IMAGE='netboxcommunity/netbox:develop-2.10'; ./test.sh
+
+# exit when a command exits with an exit code != 0
+set -e
+
+source ./build-functions/gh-functions.sh
+
+# IMAGE is used by `docker-compose.yml` do determine the tag
+# of the Docker Image that is to be used
+if [ "${1}x" != "x" ]; then
+  # Use the command line argument
+  export IMAGE="netboxcommunity/netbox:${1}"
+else
+  export IMAGE="${IMAGE-netboxcommunity/netbox:latest}"
+fi
+
+# Ensure that an IMAGE is defined
+if [ -z "${IMAGE}" ]; then
+  echo "⚠️ No image defined"
+
+  if [ -z "${DEBUG}" ]; then
+    exit 1
+  else
+    echo "⚠️ Would 'exit 1' here, but DEBUG is '${DEBUG}'."
+  fi
+fi
+
+# The docker compose command to use
+doco="docker compose --file docker-compose.test.yml --file docker-compose.test.override.yml --project-name netbox_docker_test"
+
+test_setup() {
+  gh_echo "::group:: Test setup"
+  echo "🏗 Setup up test environment"
+  $doco up --detach --quiet-pull --wait --force-recreate --renew-anon-volumes --no-start
+  $doco start postgres
+  $doco start redis
+  $doco start redis-cache
+  gh_echo "::endgroup::"
+}
+
+test_netbox_unit_tests() {
+  gh_echo "::group:: Netbox unit tests"
+  echo "⏱ Running NetBox Unit Tests"
+  $doco run --rm netbox /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py test
+  gh_echo "::endgroup::"
+}
+
+test_compose_db_setup() {
+  gh_echo "::group:: Netbox DB migrations"
+  echo "⏱ Running NetBox DB migrations"
+  $doco run --rm netbox /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py migrate
+  gh_echo "::endgroup::"
+}
+
+test_netbox_start() {
+  gh_echo "::group:: Start Netbox service"
+  echo "⏱ Starting NetBox services"
+  $doco up --detach --wait
+  gh_echo "::endgroup::"
+}
+
+test_netbox_web() {
+  gh_echo "::group:: Web service test"
+  echo "⏱ Starting web service test"
+  RESP_CODE=$(
+    curl \
+      --silent \
+      --output /dev/null \
+      --write-out '%{http_code}' \
+      --request GET \
+      --connect-timeout 5 \
+      --max-time 10 \
+      --retry 5 \
+      --retry-delay 0 \
+      --retry-max-time 40 \
+      http://127.0.0.1:8000/login/
+  )
+  if [ "$RESP_CODE" == "200" ]; then
+    echo "Webservice running"
+  else
+    echo "⚠️ Got response code '$RESP_CODE' but expected '200'"
+    exit 1
+  fi
+  gh_echo "::endgroup::"
+}
+
+test_cleanup() {
+  echo "💣 Cleaning Up"
+  gh_echo "::group:: Docker compose logs"
+  $doco logs --no-color
+  gh_echo "::endgroup::"
+  gh_echo "::group:: Docker compose down"
+  $doco down --volumes
+  gh_echo "::endgroup::"
+}
+
+echo "🐳🐳🐳 Start testing '${IMAGE}'"
+
+# Make sure the cleanup script is executed
+trap test_cleanup EXIT ERR
+test_setup
+
+test_netbox_unit_tests
+test_compose_db_setup
+test_netbox_start
+test_netbox_web
+
+echo "🐳🐳🐳 Done testing '${IMAGE}'"