118 changed files with 2702 additions and 2750 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -1,10 +1,4 @@
-.git*
-*.md
+.github
+.travis.yml
 build*
-docker-compose*
-env
-test-configuration
-.netbox/.git*
-.netbox/contrib
-.netbox/scripts
-.netbox/upgrade.sh
+*.env
--- a/.ecrc
+++ b/.ecrc
@ -1,23 +0,0 @@
-{
-  "Verbose": false,
-  "Debug": false,
-  "IgnoreDefaults": false,
-  "SpacesAftertabs": false,
-  "NoColor": false,
-  "Exclude": [
-    "LICENSE",
-    "\\.initializers",
-    "\\.vscode"
-  ],
-  "AllowedContentTypes": [],
-  "PassedFiles": [],
-  "Disable": {
-    // set these options to true to disable specific checks
-    "EndOfLine": false,
-    "Indentation": false,
-    "InsertFinalNewline": false,
-    "TrimTrailingWhitespace": false,
-    "IndentSize": true,
-    "MaxLineLength": false
-  }
-}
--- a/.editorconfig
+++ b/.editorconfig
@ -1,11 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-charset = utf-8
-indent_style = space
-indent_size = 2
-
-[*.py]
-indent_size = 4
--- a/.flake8
+++ b/.flake8
@ -1,7 +0,0 @@
-[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
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -1,14 +0,0 @@
-# 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']
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@ -1,148 +0,0 @@
-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`
-      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: |
-        version: '3.4'
-        services:
-          netbox:
-            ports:
-              - '8080:8080'
-    validations:
-      required: true
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@ -1,15 +0,0 @@
-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.
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@ -1,68 +0,0 @@
-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
--- a/.github/issue_template.md
+++ b/.github/issue_template.md
@ -0,0 +1,55 @@
+<!--
+
+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
+```
--- a/.github/no-response.yml
+++ b/.github/no-response.yml
@ -1,10 +0,0 @@
-# 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.
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@ -1,85 +0,0 @@
-<!--
-#########################################################################
-
-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.
--- a/.github/workflows/push.yml
+++ b/.github/workflows/push.yml
@ -1,94 +0,0 @@
---
-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-latest
-    name: Checks syntax of our code
-    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
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.9"
-      - name: Lint Code Base
-        uses: github/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: .ecrc
-          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 develop
-        os:
-          - ubuntu-latest
-          - self-hosted
-      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-buildx-platform
-        name: Set BUILDX_PLATFORM to ARM64
-        if: matrix.os == 'self-hosted'
-        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 == 'self-hosted'
-        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'
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -1,84 +0,0 @@
---
-name: release
-
-on:
-  release:
-    types:
-      - published
-  schedule:
-    - cron: "45 5 * * *"
-  workflow_dispatch:
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        build_cmd:
-          - ./build-latest.sh
-          - PRERELEASE=true ./build-latest.sh
-          - ./build.sh feature
-          - ./build.sh develop
-        platform:
-          - linux/amd64,linux/arm64
-      fail-fast: false
-    runs-on: ubuntu-latest
-    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
-      - 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 }}
--- a/.gitignore
+++ b/.gitignore
@ -1,13 +1 @@
 *.sql.gz
-.netbox
-.python-version
-*.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
--- a/.hadolint.yaml
+++ b/.hadolint.yaml
@ -1,4 +0,0 @@
-ignored:
- DL3006
- DL3008
- DL3003
--- a/.markdown-lint.yml
+++ b/.markdown-lint.yml
@ -1,2 +0,0 @@
-MD013: false
-MD041: false
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,32 @@
+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=
--- a/.yamllint.yaml
+++ b/.yamllint.yaml
@ -1,4 +0,0 @@
---
-rules:
-  line-length:
-    max: 160
--- a/DOCKER_HUB.md
+++ b/DOCKER_HUB.md
@ -0,0 +1,66 @@
+# 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
--- a/159
+++ b/159
@ -1,124 +1,73 @@
-ARG FROM
-FROM ${FROM} AS builder
+FROM python:3.7-alpine3.10

-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 \
+RUN apk add --no-cache \
+      bash \
+      build-base \
      ca-certificates \
-      libldap-dev \
-      libpq-dev \
-      libsasl2-dev \
-      libssl-dev \
+      cyrus-sasl-dev \
+      graphviz \
+      jpeg-dev \
+      libffi-dev \
      libxml2-dev \
-      libxmlsec1 \
-      libxmlsec1-dev \
-      libxmlsec1-openssl \
      libxslt-dev \
-      pkg-config \
-      python3-dev \
-      python3-pip \
-      python3-venv \
-    && python3 -m venv /opt/netbox/venv \
-    && /opt/netbox/venv/bin/python3 -m pip install --upgrade \
-      pip \
-      setuptools \
-      wheel
+      openldap-dev \
+      postgresql-dev \
+      ttf-ubuntu-font-family \
+      wget

-ARG NETBOX_PATH
-COPY ${NETBOX_PATH}/requirements.txt requirements-container.txt /
-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 && \
-    /opt/netbox/venv/bin/pip install \
-      -r /requirements.txt \
-      -r /requirements-container.txt
+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>=0.15,<0.16' \
+# pinning django to the version required by netbox
+# adding it here, to install the correct version of
+# django-rq
+      'Django>=2.2,<2.3' \
+# django-rq is used for webhooks
+      django-rq

-###
-# Main stage
-###
+ARG BRANCH=master

-ARG FROM
-FROM ${FROM} AS main
+WORKDIR /tmp

-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 \
-    && curl --silent --output /usr/share/keyrings/nginx-keyring.gpg \
-      https://unit.nginx.org/keys/nginx-keyring.gpg \
-    && echo "deb [signed-by=/usr/share/keyrings/nginx-keyring.gpg] https://packages.nginx.org/unit/ubuntu/ noble unit" \
-      > /etc/apt/sources.list.d/unit.list \
-    && apt-get update -qq \
-    && apt-get install \
-      --yes -qq --no-install-recommends \
-      unit=1.33.0-1~noble \
-      unit-python3.12=1.33.0-1~noble \
-    && rm -rf /var/lib/apt/lists/*
+# As the requirements don't change very often,
+# and as they take some time to compile,
+# we try to cache them very agressively.
+ARG REQUIREMENTS_URL=https://raw.githubusercontent.com/netbox-community/netbox/$BRANCH/requirements.txt
+ADD ${REQUIREMENTS_URL} requirements.txt
+RUN pip install -r requirements.txt

-COPY --from=builder /opt/netbox/venv /opt/netbox/venv
+# Cache bust when the upstream branch changes:
+# ADD will fetch the file and check if it has changed
+# If not, Docker will use the existing build cache.
+# If yes, Docker will bust the cache and run every build step from here on.
+ARG REF_URL=https://api.github.com/repos/netbox-community/netbox/contents?ref=$BRANCH
+ADD ${REF_URL} version.json

-ARG NETBOX_PATH
-COPY ${NETBOX_PATH} /opt/netbox
-# Copy the modified 'requirements*.txt' files, to have the files actually used during installation
-COPY --from=builder /requirements.txt /requirements-container.txt /opt/netbox/
+WORKDIR /opt
+
+ARG URL=https://github.com/netbox-community/netbox/archive/$BRANCH.tar.gz
+RUN wget -q -O - "${URL}" | tar xz \
+  && mv netbox* netbox

 COPY docker/configuration.docker.py /opt/netbox/netbox/netbox/configuration.py
-COPY docker/ldap_config.docker.py /opt/netbox/netbox/netbox/ldap_config.py
+COPY configuration/gunicorn_config.py /etc/netbox/config/
+COPY docker/nginx.conf /etc/netbox-nginx/nginx.conf
 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 startup_scripts/ /opt/netbox/startup_scripts/
+COPY initializers/ /opt/netbox/initializers/
+COPY configuration/configuration.py /etc/netbox/config/configuration.py

 WORKDIR /opt/netbox/netbox

-# 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/ \
-      && SECRET_KEY="dummyKeyWithMinimumLength-------------------------" /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py collectstatic --no-input
+ENTRYPOINT [ "/opt/netbox/docker-entrypoint.sh" ]

-ENV LANG=C.utf8 PATH=/opt/netbox/venv/bin:$PATH
-ENTRYPOINT [ "/usr/bin/tini", "--" ]
+CMD ["gunicorn", "-c /etc/netbox/config/gunicorn_config.py", "netbox.wsgi"]

-CMD [ "/opt/netbox/docker-entrypoint.sh", "/opt/netbox/launch-netbox.sh" ]
+LABEL SRC_URL="$URL"

-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=""
+ARG NETBOX_DOCKER_PROJECT_VERSION=snapshot
+LABEL NETBOX_DOCKER_PROJECT_VERSION="$NETBOX_DOCKER_PROJECT_VERSION"
--- a/Dockerfile.ldap
+++ b/Dockerfile.ldap
@ -0,0 +1,9 @@
+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
--- a/README.md
+++ b/README.md
@ -1,159 +1,126 @@
 # netbox-docker

-[![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]
+[The Github repository](netbox-docker-github) houses the components needed to build Netbox as a Docker container.
+Images are built using this code and are released to [Docker Hub][netbox-dockerhub] once a day.

-[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].
+Do you have any 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.

-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.
-
-[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-dockerhub]: https://hub.docker.com/r/netboxcommunity/netbox/tags/
 [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
+[ntc-slack]: http://slack.networktocode.com/

 ## Quickstart

-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.
+To get Netbox up and running:

 ```bash
-git clone -b release https://github.com/netbox-community/netbox-docker.git
+git clone -b master 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
+docker-compose pull
+docker-compose up -d
 ```

-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.
-
-To create the first admin user run this command:
+The application will be available after a few minutes.
+Use `docker-compose port nginx 8080` to find out where to connect to.

 ```bash
-docker compose exec netbox /opt/netbox/netbox/manage.py createsuperuser
+$ echo "http://$(docker-compose port nginx 8080)/"
+http://0.0.0.0:32768/
+
+# 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 &
 ```

-If you need to restart Netbox from an empty database often, you can also set the `SUPERUSER_*` variables in your `docker-compose.override.yml` as shown in the example.
+Alternatively, use something like [Reception][docker-reception] to connect to _docker-compose_ projects.

-[wiki-getting-started]: https://github.com/netbox-community/netbox-docker/wiki/Getting-Started
+Default credentials:

-## Container Image Tags
+* Username: **admin**
+* Password: **admin**
+* API Token: **0123456789abcdef0123456789abcdef01234567**

-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.
-  These images are automatically built from [the `master` branch of NetBox][netbox-master].
-* `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 [`develop` branch of NetBox][netbox-develop].
-
-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).
-  It always points to the latest version of _NetBox Docker_.
-* `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-master]: https://github.com/netbox-community/netbox/tree/master
-[netbox-develop]: https://github.com/netbox-community/netbox/tree/develop
-
-## 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 in the Slack channel.
-
-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
+[docker-reception]: https://github.com/nxt-engineering/reception

 ## Dependencies

-This project relies only on _Docker_ and _docker-compose_ meeting these requirements:
+This project relies only on *Docker* and *docker-compose* meeting this requirements:

-* 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`.
+* The *Docker version* must be at least `1.13.0`.
+* The *docker-compose version* must be at least `1.10.0`.

-To check the version installed on your system run `docker --version` and `docker compose version`.
+To ensure this, compare the output of `docker --version` and `docker-compose --version` with the requirements above.

-## Updating
+## Reference Documentation
+
+Please refer [to the wiki][wiki] for further information on how to use this Netbox Docker image properly.
+It covers advanced topics such as using secret files, deployment to Kubernetes as well as NAPALM and LDAP configuration.
+
+[wiki]: https://github.com/netbox-community/netbox-docker/wiki/
+
+## 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].
+
+```bash
+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 'netbox-community/netbox' Github repository][netbox-github].
+Most commonly you will specify a tag or branch name.
+
+```bash
+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/netbox-community/netbox/releases
+
+## 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}}"`.

 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 code.
-
-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].

 [releases]: https://github.com/netbox-community/netbox-docker/releases
-[netbox-docker-wiki-updating]: https://github.com/netbox-community/netbox-docker/wiki/Updating

-## Rebuilding the Image
+## Rebuilding & Publishing images

-`./build.sh` can be used to rebuild the container image. See `./build.sh --help` for more information.
+`./build.sh` can be used to rebuild the Docker image. See `./build.sh --help` for more information.

-For more details on custom builds [consult our wiki][netbox-docker-wiki-build].
+### Publishing Docker Images

-[netbox-docker-wiki-build]: https://github.com/netbox-community/netbox-docker/wiki/Build
+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/

 ## Tests

-We have a test script.
-It runs NetBox's own unit tests and ensures that all initializers work:
+To run the tests coming with Netbox, use the `docker-compose.yml` file as such:

 ```bash
-IMAGE=netboxcommunity/netbox:latest ./test.sh
+docker-compose run netbox ./manage.py test
 ```

-## Support
+## About

-This repository is currently maintained by the community.
-Please consider sponsoring the maintainers of this project.
+This repository is currently maintained and funded by [nxt][nxt].
+
+[nxt]: https://nxt.engineering/en/
--- a/2
+++ b/2
@ -1 +1 @@
-3.0.2
+0.18.0
--- a/build-all.sh
+++ b/build-all.sh
@ -0,0 +1,84 @@
+#!/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
--- a/build-branches.sh
+++ b/build-branches.sh
@ -0,0 +1,28 @@
+#!/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-netbox-community}/${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
--- a/build-functions/check-commands.sh
+++ b/build-functions/check-commands.sh
@ -1,9 +0,0 @@
-#!/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
--- a/build-functions/get-public-image-config.sh
+++ b/build-functions/get-public-image-config.sh
@ -1,18 +0,0 @@
-#!/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"
-}
--- a/build-functions/gh-functions.sh
+++ b/build-functions/gh-functions.sh
@ -1,32 +0,0 @@
-#!/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
-}
--- a/build-latest.sh
+++ b/build-latest.sh
@ -1,78 +1,44 @@
 #!/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 $*"

-CURL_ARGS=(
-  --silent
-)
-
-###
-# Checking for the presence of GITHUB_TOKEN
-###
-if [ -n "${GITHUB_TOKEN}" ]; then
+if [ -n "${GITHUB_OAUTH_CLIENT_ID}" ] && [ -n "${GITHUB_OAUTH_CLIENT_SECRET}" ]; then
  echo "🗝 Performing authenticated Github API calls."
-  CURL_ARGS+=(
-    --header "Authorization: Bearer ${GITHUB_TOKEN}"
-  )
+  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

-###
-# 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"
+URL_RELEASES="https://api.github.com/repos/${GITHUB_REPO}/releases?${GITHUB_OAUTH_PARAMS}"

-# 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"
+CURL="curl -sS"

-# Querying the Github API to fetch the most recent version number
-VERSION=$($CURL "${CURL_ARGS[@]}" "${URL_RELEASES}" | jq -r "${JQ_LATEST}" 2>/dev/null)
+VERSION=$($CURL "${URL_RELEASES}" | jq -r "${JQ_LATEST}")

-###
 # 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 "${CURL_ARGS[@]}" "${URL_RELEASES}" | jq -r "${JQ_STABLE}" 2>/dev/null)
+  STABLE_VERSION=$($CURL "${URL_RELEASES}" | jq -r "${JQ_STABLE}")

-  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]\+\)')
+  # 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]\+\)')

-  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."
@ -80,6 +46,32 @@ 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
--- a/build.sh
+++ b/build.sh
@ -1,136 +1,73 @@
 #!/bin/bash
-# Clones the NetBox repository with git from Github and builds the Dockerfile
+# Builds the Dockerfile[.variant] and injects tgz'ed Netbox code from Github

 echo "▶️ $0 $*"

 set -e

 if [ "${1}x" == "x" ] || [ "${1}" == "--help" ] || [ "${1}" == "-h" ]; then
-  _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>=master:  latest
-              When <branch>=develop: 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.
-
-${_BOLD}Examples:${_CLEAR}
-
-${0} master
-            This will fetch the latest 'master' branch, build a Docker Image and tag it
-            'netboxcommunity/netbox:latest'.
-
-${0} develop
-            This will fetch the latest 'develop' branch, build a Docker Image and tag it
-            'netboxcommunity/netbox:snapshot'.
-
-${0} v2.6.6
-            This will fetch the 'v2.6.6' tag, build a Docker Image and tag it
-            'netboxcommunity/netbox:v2.6.6' and 'netboxcommunity/netbox:v2.6'.
-
-${0} develop-2.7
-            This will fetch the 'develop-2.7' branch, build a Docker Image and tag it
-            'netboxcommunity/netbox:develop-2.7'.
-
-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
+  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: netbox-community"
+  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"

  if [ "${1}x" == "x" ]; then
    exit 1
@ -139,327 +76,122 @@ END_OF_HELP
  fi
 fi

-# 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
+# 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)}"

-IMAGE_NAMES="${IMAGE_NAMES-docker.io/netboxcommunity/netbox}"
-IFS=' ' read -ra IMAGE_NAMES <<<"${IMAGE_NAMES}"
-
-###
-# Enabling dry-run mode
-###
-if [ -z "${DRY_RUN}" ]; then
-  DRY=""
-else
-  echo "⚠️ DRY_RUN MODE ON ⚠️"
-  DRY="echo"
-fi
-
-gh_echo "::group::⤵️ Fetching the NetBox source code"
-
-###
-# Variables for fetching the NetBox source
-###
+# variables for fetching the 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}"
+BRANCH="${1}"
+URL="${URL-https://github.com/${SRC_ORG}/${SRC_REPO}/archive/$BRANCH.tar.gz}"

-###
-# 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}"
+# Checking which VARIANT to build
+VARIANT="${VARIANT-main}"
+if [ "$VARIANT" == "main" ]; then
+  DOCKERFILE="Dockerfile"
+else
+  DOCKERFILE="Dockerfile.${VARIANT}"
 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}"
+# Fail fast
 if [ ! -f "${DOCKERFILE}" ]; then
-  echo "🚨 The Dockerfile ${DOCKERFILE} doesn't exist."
+  echo "🚨 The Dockerfile ${DOCKERFILE} for variant '${VARIANT}' doesn't exist."

-  if [ -z "${DEBUG}" ]; then
+  if [ -z "$DEBUG" ]; then
    exit 1
  else
    echo "⚠️ Would exit here with code '1', but DEBUG is enabled."
  fi
 fi

-###
-# 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}"
+# variables for tagging the docker image
 DOCKER_ORG="${DOCKER_ORG-netboxcommunity}"
 DOCKER_REPO="${DOCKER_REPO-netbox}"
-case "${NETBOX_BRANCH}" in
+case "${BRANCH}" in
  master)
-  TAG="${TAG-latest}"
-  ;;
+    TAG="${TAG-latest}";;
  develop)
-  TAG="${TAG-snapshot}"
-  ;;
+    TAG="${TAG-snapshot}";;
  *)
-  TAG="${TAG-$NETBOX_BRANCH}"
-  ;;
+    TAG="${TAG-$BRANCH}";;
 esac

-###
-# composing the final TARGET_DOCKER_TAG
-###
-TARGET_DOCKER_TAG="${DOCKER_TAG-${TAG}}"
-TARGET_DOCKER_TAG_PROJECT="${TARGET_DOCKER_TAG}-${PROJECT_VERSION}"
+DOCKER_TAG="${DOCKER_TAG-${DOCKER_ORG}/${DOCKER_REPO}:${TAG}}"
+if [ "$VARIANT" != "main" ]; then
+  DOCKER_TAG="${DOCKER_TAG}-${VARIANT}"
+fi

-###
-# composing the additional DOCKER_SHORT_TAG,
-# i.e. "v2.6.1" becomes "v2.6",
-# 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]}

-  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_SHORT_TAG="${DOCKER_SHORT_TAG-${DOCKER_ORG}/${DOCKER_REPO}:v${MAJOR}.${MINOR}}"

-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
-
-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 "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 [ "${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"
+  if [ "$VARIANT" != "main" ]; then
+    DOCKER_SHORT_TAG="${DOCKER_SHORT_TAG}-${VARIANT}"
  fi
 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::"
+DOCKER_OPTS=("${DOCKER_OPTS[@]}")

-if [ "${CHECK_ONLY}" = "true" ]; then
-  echo "Only check if build needed was requested. Exiting"
-  exit 0
-fi
+# caching is only ok for version tags
+case "${TAG}" in
+ v*) ;;
+ *)  DOCKER_OPTS+=( "--no-cache" ) ;;
+esac

-###
-# Build the image
-###
-gh_echo "::group::🏗 Building the image"
-###
-# Composing all arguments for `docker build`
-###
+DOCKER_OPTS+=( "--pull" )
+
+# Build args
 DOCKER_BUILD_ARGS=(
-  --pull
-  --target main
-  -f "${DOCKERFILE}"
+  --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}"
 )
-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
+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 "${NO_PROXY}" ]; then
+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}" )
 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
-  )
+if [ -z "$DRY_RUN" ]; then
+  DOCKER_CMD="docker"
 else
-  DOCKER_BUILD_ARGS+=(
-    --output=type=docker
-  )
+  echo "⚠️ DRY_RUN MODE ON ⚠️"
+  DOCKER_CMD="echo docker"
 fi

-###
-# Building the docker image
-###
-if [ -z "${BUILDX_BUILDER_NAME}" ]; then
-  BUILDX_BUILDER_NAME="$(basename "${PWD}")"
+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}'"
  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
+if [ "${2}" == "--push" ] || [ "${2}" == "--push-only" ] ; then
+  echo "⏫ Pushing '${DOCKER_TAG}"
+  $DOCKER_CMD push "${DOCKER_TAG}"
+  echo "✅ Finished pushing the Docker image '${DOCKER_TAG}'."

-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}"
+  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
 fi
-gh_echo "::endgroup::"
--- a/configuration/configuration.py
+++ b/configuration/configuration.py
@ -1,51 +1,21 @@
-####
-## We recommend to not edit this file.
-## Create separate files to overwrite the settings.
-## See `extra.py` as an example.
-####
-
+import os
 import re
-from os import environ
-from os.path import abspath, dirname, join
-from typing import Any, Callable, Tuple
+import socket

-# 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
-###
+# For reference see http://netbox.readthedocs.io/en/latest/configuration/mandatory-settings/
+# Based on https://github.com/netbox-community/netbox/blob/develop/netbox/netbox/configuration.example.py

 # Read secret from file
-def _read_secret(secret_name: str, default: str | None = None) -> str | None:
+def read_secret(secret_name):
    try:
        f = open('/run/secrets/' + secret_name, 'r', encoding='utf-8')
    except EnvironmentError:
-        return default
+        return ''
    else:
        with f:
            return f.readline().strip()

-# 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__)))
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

 #########################
 #                       #
@ -57,63 +27,34 @@ _BASE_DIR = dirname(dirname(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 = 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')
+ALLOWED_HOSTS = os.environ.get('ALLOWED_HOSTS', '*').split(' ')

-# PostgreSQL database configuration. See the Django documentation for a complete list of available parameters:
-#   https://docs.djangoproject.com/en/stable/ref/settings/#databases
+# PostgreSQL database configuration.
 DATABASE = {
-    'NAME': environ.get('DB_NAME', 'netbox'),       # Database name
-    'USER': environ.get('DB_USER', ''),             # PostgreSQL username
-    'PASSWORD': _read_secret('db_password', environ.get('DB_PASSWORD', '')),
+    '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': 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),
-    },
+    'HOST': os.environ.get('DB_HOST', 'localhost'),      # Database server
+    'PORT': os.environ.get('DB_PORT', ''),               # Database port (leave blank for default)
 }

 # 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/stable/ref/settings/#std:setting-SECRET_KEY
-SECRET_KEY = _read_secret('secret_key', environ.get('SECRET_KEY', ''))
+# https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-SECRET_KEY
+SECRET_KEY = os.environ.get('SECRET_KEY', read_secret('secret_key'))

+# Redis database settings. The Redis database is used for caching and background processing such as webhooks
+REDIS = {
+    'HOST': os.environ.get('REDIS_HOST', 'localhost'),
+    'PORT': int(os.environ.get('REDIS_PORT', 6379)),
+    'PASSWORD': os.environ.get('REDIS_PASSWORD', read_secret('redis_password')),
+    'DATABASE': os.environ.get('REDIS_DATABASE', '0'),
+    'CACHE_DATABASE': os.environ.get('REDIS_CACHE_DATABASE', '1'),
+    'DEFAULT_TIMEOUT': os.environ.get('REDIS_TIMEOUT', '300'),
+    'SSL': os.environ.get('REDIS_SSL', 'False').lower() == 'true',
+}

 #########################
 #                       #
@ -121,230 +62,117 @@ SECRET_KEY = _read_secret('secret_key', environ.get('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'],
-# ]
-
-if 'ALLOWED_URL_SCHEMES' in environ:
-    ALLOWED_URL_SCHEMES = _environ_get_and_map('ALLOWED_URL_SCHEMES', None, _AS_LIST)
+# 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'],
+]

 # 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.
-if 'BANNER_TOP' in environ:
-    BANNER_TOP = environ.get('BANNER_TOP', None)
-if 'BANNER_BOTTOM' in environ:
-    BANNER_BOTTOM = environ.get('BANNER_BOTTOM', None)
+BANNER_TOP = os.environ.get('BANNER_TOP', '')
+BANNER_BOTTOM = os.environ.get('BANNER_BOTTOM', '')

 # Text to include on the login page above the login form. HTML is allowed.
-if 'BANNER_LOGIN' in environ:
-    BANNER_LOGIN = environ.get('BANNER_LOGIN', None)
+BANNER_LOGIN = os.environ.get('BANNER_LOGIN', '')
+
+# 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', '')
+
+# Cache timeout in seconds. Set to 0 to dissable caching. Defaults to 900 (15 minutes)
+CACHE_TIMEOUT = int(os.environ.get('CACHE_TIMEOUT', 900))

 # 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)
+CHANGELOG_RETENTION = int(os.environ.get('CHANGELOG_RETENTION', 90))

 # 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 = _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)]
+CORS_ORIGIN_ALLOW_ALL = os.environ.get('CORS_ORIGIN_ALLOW_ALL', 'False').lower() == 'true'
+CORS_ORIGIN_WHITELIST = list(filter(None, os.environ.get('CORS_ORIGIN_WHITELIST', 'https://localhost').split(' ')))
+CORS_ORIGIN_REGEX_WHITELIST = [re.compile(r) for r in list(filter(None, os.environ.get('CORS_ORIGIN_REGEX_WHITELIST', '').split(' ')))]

 # 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 = _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)
+# 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'

 # Email settings
 EMAIL = {
-    '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', ''),
+    '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', ''),
 }

-# 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)
-
-# 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)
+# 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'

 # 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)
+EXEMPT_VIEW_PERMISSIONS = list(filter(None, os.environ.get('EXEMPT_VIEW_PERMISSIONS', '').split(' ')))

-# 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),
-}
+# 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 = {}

-# 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 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'

 # Setting this to True will display a "maintenance mode" banner at the top of every page.
-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)
+MAINTENANCE_MODE = os.environ.get('MAINTENANCE_MODE', 'False').lower() == 'true'

 # 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".
-if 'MAX_PAGE_SIZE' in environ:
-    MAX_PAGE_SIZE = _environ_get_and_map('MAX_PAGE_SIZE', None, _AS_INT)
+MAX_PAGE_SIZE = int(os.environ.get('MAX_PAGE_SIZE', 1000))

 # 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 = environ.get('MEDIA_ROOT', join(_BASE_DIR, 'media'))
+MEDIA_ROOT = os.environ.get('MEDIA_ROOT', os.path.join(BASE_DIR, 'media'))

 # Expose Prometheus monitoring metrics at the HTTP endpoint '/metrics'
-METRICS_ENABLED = _environ_get_and_map('METRICS_ENABLED', 'False', _AS_BOOL)
+METRICS_ENABLED = os.environ.get('METRICS_ENABLED', 'False').lower() == 'true'
+
+# 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 = {}

 # Determine how many objects to display per page within a list. (Default: 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 = {
-# }
+PAGINATE_COUNT = int(os.environ.get('PAGINATE_COUNT', 50))

 # When determining the primary IP address for a device, IPv6 is preferred over IPv4 by default. Set this to True to
 # prefer IPv4 instead.
-if 'PREFER_IPV4' in environ:
-    PREFER_IPV4 = _environ_get_and_map('PREFER_IPV4', None, _AS_BOOL)
-
-# 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)
-
-# 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 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))
+PREFER_IPV4 = os.environ.get('PREFER_IPV4', 'False').lower() == 'true'
+# 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')

 # Time zone (default: UTC)
-TIME_ZONE = environ.get('TIME_ZONE', 'UTC')
+TIME_ZONE = os.environ.get('TIME_ZONE', 'UTC')

+# 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'
+
+# 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')
--- a/configuration/extra.py
+++ b/configuration/extra.py
@ -1,49 +0,0 @@
-####
-## 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>'
--- a/configuration/gunicorn_config.py
+++ b/configuration/gunicorn_config.py
@ -0,0 +1,8 @@
+command = '/usr/bin/gunicorn'
+pythonpath = '/opt/netbox/netbox'
+bind = '0.0.0.0:8001'
+workers = 3
+errorlog = '-'
+accesslog = '-'
+capture_output = False
+loglevel = 'debug'
--- a/configuration/ldap/extra.py
+++ b/configuration/ldap/extra.py
@ -1,28 +0,0 @@
-####
-## 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"]
--- a/configuration/ldap/ldap_config.py
+++ b/configuration/ldap/ldap_config.py
@ -1,111 +0,0 @@
-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')
-}
--- a/configuration/ldap_config.py
+++ b/configuration/ldap_config.py
@ -0,0 +1,81 @@
+import ldap
+import os
+
+from django_auth_ldap.config import LDAPSearch
+from importlib import import_module
+
+# Read secret from file
+def read_secret(secret_name):
+    try:
+        f = open('/run/secrets/' + secret_name, 'r', encoding='utf-8')
+    except EnvironmentError:
+        return ''
+    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 = 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', read_secret('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 = import_group_type(os.environ.get('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')
+}
--- a/configuration/logging.py
+++ b/configuration/logging.py
@ -1,55 +0,0 @@
-# # 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,
-#        }
-#    }
-# }
--- a/configuration/plugins.py
+++ b/configuration/plugins.py
@ -1,13 +0,0 @@
-# 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
-#   }
-# }
--- a/docker-compose.override.yml
+++ b/docker-compose.override.yml
@ -1,21 +0,0 @@
-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: ""
--- a/docker-compose.override.yml.example
+++ b/docker-compose.override.yml.example
@ -1,22 +0,0 @@
-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: ""
-
--- a/docker-compose.test.override.yml
+++ b/docker-compose.test.override.yml
@ -1,5 +0,0 @@
-services:
-  netbox:
-    ports:
-      - "127.0.0.1:8000:8080"
-
--- a/docker-compose.test.yml
+++ b/docker-compose.test.yml
@ -1,70 +0,0 @@
-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:16-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.0-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
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -1,99 +1,67 @@
+version: '3'
 services:
  netbox: &netbox
-    image: docker.io/netboxcommunity/netbox:${VERSION-v4.1-3.0.2}
+    build:
+      context: .
+      args:
+        - BRANCH=${VERSION-master}
+    image: netboxcommunity/netbox:${VERSION-latest}
    depends_on:
    - postgres
    - redis
-      - redis-cache
+    - netbox-worker
    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
-      - netbox-media-files:/opt/netbox/netbox/media:rw
-      - netbox-reports-files:/opt/netbox/netbox/reports:rw
-      - netbox-scripts-files:/opt/netbox/netbox/scripts:rw
+    - ./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
  netbox-worker:
    <<: *netbox
    depends_on:
-      netbox:
-        condition: service_healthy
-    command:
-      - /opt/netbox/venv/bin/python
+    - redis
+    entrypoint:
+    - python3
    - /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:
-        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
+    - rqworker
+  nginx:
+    command: nginx -c /etc/netbox-nginx/nginx.conf
+    image: nginx:1.15-alpine
+    depends_on:
+    - netbox
+    ports:
+    - 8080
+    volumes:
+    - netbox-static-files:/opt/netbox/netbox/static:ro
+    - netbox-nginx-config:/etc/netbox-nginx/:ro
  postgres:
-    image: docker.io/postgres:16-alpine
-    healthcheck:
-      test: pg_isready -q -t 2 -d $$POSTGRES_DB -U $$POSTGRES_USER
-      start_period: 20s
-      timeout: 30s
-      interval: 10s
-      retries: 5
+    image: postgres:10.4-alpine
    env_file: env/postgres.env
    volumes:
    - netbox-postgres-data:/var/lib/postgresql/data
-
-  # redis
  redis:
-    image: docker.io/valkey/valkey:8.0-alpine
+    image: redis:4-alpine
    command:
    - 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
+    - redis-server --appendonly yes --requirepass $$REDIS_PASSWORD ## $$ because of docker-compose
    env_file: env/redis.env
    volumes:
    - netbox-redis-data:/data
-  redis-cache:
-    image: docker.io/valkey/valkey:8.0-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
--- a/docker/configuration.docker.py
+++ b/docker/configuration.docker.py
@ -1,91 +1,10 @@
-## 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

-
-def _filename(f):
-    return f.name
-
-
-def _import(module_name, path, loaded_configurations):
-    spec = importlib.util.spec_from_file_location("", path)
+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[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)
+  sys.modules['netbox.configuration'] = module
 except:
-            pass
-    raise AttributeError
-
-
-def __dir__():
-    names = []
-    for config in _loaded_configurations:
-        names.extend(config.__dir__())
-    return names
+  raise ImportError('')
--- a/docker/docker-entrypoint.sh
+++ b/docker/docker-entrypoint.sh
@ -1,98 +1,58 @@
 #!/bin/bash
-# Runs on every start of the NetBox Docker container
-
-# Stop when an error occures
 set -e

-# Allows NetBox to be run as non-root users
-umask 002
-
-# 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))
+# wait shortly and then run db migrations (retry on error)
+while ! ./manage.py migrate 2>&1; do
+  echo "⏳ Waiting on DB..."
+  sleep 3
 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
+# 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)"
-  elif [ -z ${SUPERUSER_PASSWORD+x} ]; then
+  else
    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)"
-  elif [ -z ${SUPERUSER_API_TOKEN+x} ]; then
+  else
    SUPERUSER_API_TOKEN='0123456789abcdef0123456789abcdef01234567'
  fi
+fi
+
+echo "💡 Username: ${SUPERUSER_NAME}, E-Mail: ${SUPERUSER_EMAIL}"

 ./manage.py shell --interface python << END
-from users.models import Token, User
+from django.contrib.auth.models import User
+from users.models import Token
 if not User.objects.filter(username='${SUPERUSER_NAME}'):
    u=User.objects.create_superuser('${SUPERUSER_NAME}', '${SUPERUSER_EMAIL}', '${SUPERUSER_PASSWORD}')
    Token.objects.create(user=u, key='${SUPERUSER_API_TOKEN}')
 END

-  echo "💡 Superuser Username: ${SUPERUSER_NAME}, E-Mail: ${SUPERUSER_EMAIL}"
+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
 fi

-./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
+# copy static files
+./manage.py collectstatic --no-input

 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 ${@}
--- a/docker/housekeeping.sh
+++ b/docker/housekeeping.sh
@ -1,8 +0,0 @@
-#!/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
--- a/docker/launch-netbox.sh
+++ b/docker/launch-netbox.sh
@ -1,57 +0,0 @@
-#!/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
--- a/docker/ldap_config.docker.py
+++ b/docker/ldap_config.docker.py
@ -1,23 +1,10 @@
-from .configuration import read_configurations
+import importlib.util
+import sys

-_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)
+  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:
-            pass
-    raise AttributeError
-
-
-def __dir__():
-    names = []
-    for config in _loaded_configurations:
-        names.extend(config.__dir__())
-    return names
+  raise ImportError('')
--- a/docker/nginx-unit.json
+++ b/docker/nginx-unit.json
@ -1,57 +0,0 @@
-{
-  "listeners": {
-    "0.0.0.0:8080": {
-      "pass": "routes/main"
-    },
-    "[::]:8080": {
-      "pass": "routes/main"
-    },
-    "0.0.0.0:8081": {
-      "pass": "routes/status"
-    },
-    "[::]:8081": {
-      "pass": "routes/status"
-    }
-  },
-  "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"
-}
--- a/docker/nginx.conf
+++ b/docker/nginx.conf
@ -0,0 +1,36 @@
+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"';
+        }
+    }
+}
--- a/env/netbox.env
+++ b/env/netbox.env
@ -1,34 +1,27 @@
 CORS_ORIGIN_ALLOW_ALL=True
-DB_HOST=postgres
 DB_NAME=netbox
-DB_PASSWORD=J5brHrAXFLQSif0K
 DB_USER=netbox
-EMAIL_FROM=netbox@bar.com
-EMAIL_PASSWORD=
-EMAIL_PORT=25
+DB_PASSWORD=J5brHrAXFLQSif0K
+DB_HOST=postgres
 EMAIL_SERVER=localhost
-EMAIL_SSL_CERTFILE=
-EMAIL_SSL_KEYFILE=
-EMAIL_TIMEOUT=5
+EMAIL_PORT=25
 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
+EMAIL_PASSWORD=
+EMAIL_TIMEOUT=5
+EMAIL_FROM=netbox@bar.com
 MEDIA_ROOT=/opt/netbox/netbox/media
-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
+NAPALM_USERNAME=
+NAPALM_PASSWORD=
+NAPALM_TIMEOUT=10
+MAX_PAGE_SIZE=1000
 REDIS_HOST=redis
-REDIS_INSECURE_SKIP_TLS_VERIFY=false
 REDIS_PASSWORD=H733Kdjndks81
+REDIS_DATABASE=0
+REDIS_CACHE_DATABASE=1
 REDIS_SSL=false
-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
+SECRET_KEY=r8OwDznj!!dci#P9ghmRfdu1Ysxm0AiPeDCQhKE+N_rClfWNj
+SUPERUSER_NAME=admin
+SUPERUSER_EMAIL=admin@example.com
+SUPERUSER_PASSWORD=admin
+SUPERUSER_API_TOKEN=0123456789abcdef0123456789abcdef01234567
 WEBHOOKS_ENABLED=true
--- a/env/postgres.env
+++ b/env/postgres.env
@ -1,3 +1,3 @@
-POSTGRES_DB=netbox
-POSTGRES_PASSWORD=J5brHrAXFLQSif0K
 POSTGRES_USER=netbox
+POSTGRES_PASSWORD=J5brHrAXFLQSif0K
+POSTGRES_DB=netbox
--- a/env/redis-cache.env
+++ b/env/redis-cache.env
@ -1 +0,0 @@
-REDIS_PASSWORD=t4Ph722qJ5QHeQ1qfu36
--- a/hooks/build
+++ b/hooks/build
@ -0,0 +1,5 @@
+#!/bin/bash
+
+. hooks/common
+
+run_build
--- a/hooks/common
+++ b/hooks/common
@ -0,0 +1,82 @@
+#!/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
--- a/hooks/push
+++ b/hooks/push
@ -0,0 +1,5 @@
+#!/bin/bash
+
+. hooks/common
+
+run_build --push-only
--- a/hooks/test
+++ b/hooks/test
@ -0,0 +1,12 @@
+#!/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
--- a/initializers/aggregates.yml
+++ b/initializers/aggregates.yml
@ -0,0 +1,6 @@
+# - prefix: 10.0.0.0/16
+#   rir: RFC1918
+# - prefix: fd00:ccdd::/32
+#   rir: RFC4193 ULA
+# - prefix: 2001:db8::/32
+#   rir: RFC3849
--- a/initializers/cluster_types.yml
+++ b/initializers/cluster_types.yml
@ -0,0 +1,2 @@
+# - name: Hyper-V
+#   slug: hyper-v
--- a/initializers/clusters.yml
+++ b/initializers/clusters.yml
@ -0,0 +1,5 @@
+# - name: cluster1
+#   type: Hyper-V
+# - name: cluster2
+#   type: Hyper-V
+#   site: SING 1
--- a/initializers/custom_fields.yml
+++ b/initializers/custom_fields.yml
@ -0,0 +1,82 @@
+# 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
--- a/initializers/dcim_interfaces.yml
+++ b/initializers/dcim_interfaces.yml
@ -0,0 +1,8 @@
+# - device: server01
+#   enabled: true
+#   type: Virtual
+#   name: to-server02
+# - device: server02
+#   enabled: true
+#   type: Virtual
+#   name: to-server01
--- a/initializers/device_roles.yml
+++ b/initializers/device_roles.yml
@ -0,0 +1,15 @@
+# - 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
--- a/initializers/device_types.yml
+++ b/initializers/device_types.yml
@ -0,0 +1,23 @@
+# - 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: No Name
+#   slug: other
+#   custom_fields:
+#     text_field: Description
--- a/initializers/devices.yml
+++ b/initializers/devices.yml
@ -0,0 +1,27 @@
+# - 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
--- a/initializers/groups.yml
+++ b/initializers/groups.yml
@ -0,0 +1,16 @@
+# applications:
+#   users:
+#   - technical_user
+# readers:
+#   users:
+#   - reader
+# writers:
+#   users:
+#   - writer
+#   permissions:
+#   - add_device
+#   - change_device
+#   - delete_device
+#   - add_virtualmachine
+#   - change_virtualmachine
+#   - delete_virtualmachine
--- a/initializers/ip_addresses.yml
+++ b/initializers/ip_addresses.yml
@ -0,0 +1,26 @@
+# - address: 10.1.1.1/24
+#   device: server01
+#   interface: to-server02
+#   status: Active
+#   vrf: vrf1
+# - address: 2001:db8:a000:1::1/64
+#   device: server01
+#   interface: to-server02
+#   status: Active
+#   vrf: vrf1
+# - address: 10.1.1.2/24
+#   device: server02
+#   interface: to-server01
+#   status: Active
+# - address: 2001:db8:a000:1::2/64
+#   device: server02
+#   interface: to-server01
+#   status: Active
+# - address: 10.1.1.10/24
+#   description: reserved IP
+#   status: Reserved
+#   tenant: tenant1
+# - address: 2001:db8:a000:1::10/64
+#   description: reserved IP
+#   status: Reserved
+#   tenant: tenant1
--- a/initializers/manufacturers.yml
+++ b/initializers/manufacturers.yml
@ -0,0 +1,6 @@
+# - name: Manufacturer 1
+#   slug: manufacturer-1
+# - name: Manufacturer 2
+#   slug: manufacturer-2
+# - name: No Name
+#   slug: no-name
--- a/initializers/platforms.yml
+++ b/initializers/platforms.yml
@ -0,0 +1,15 @@
+# - name: Platform 1
+#   slug: platform-1
+#   manufacturer: Manufacturer 1
+#   napalm_driver: driver1
+#   napalm_args: "{'arg1': 'value1', 'arg2': 'value2'}"
+# - name: Platform 2
+#   slug: platform-2
+#   manufacturer: Manufacturer 2
+#   napalm_driver: driver2
+#   napalm_args: "{'arg1': 'value1', 'arg2': 'value2'}"
+# - name: Platform 3
+#   slug: platform-3
+#   manufacturer: No Name
+#   napalm_driver: driver3
+#   napalm_args: "{'arg1': 'value1', 'arg2': 'value2'}"
--- a/initializers/prefix_vlan_roles.yml
+++ b/initializers/prefix_vlan_roles.yml
@ -0,0 +1,2 @@
+# - name: Main Management
+#   slug: main-management
--- a/initializers/prefixes.yml
+++ b/initializers/prefixes.yml
@ -0,0 +1,20 @@
+# - description: prefix1
+#   prefix: 10.1.1.0/24
+#   site: AMS 1
+#   status: Active
+#   tenant: tenant1
+#   vlan: vlan1
+# - description: prefix2
+#   prefix: 10.1.2.0/24
+#   site: AMS 2
+#   status: Active
+#   tenant: tenant2
+#   vlan: vlan2
+#   is_pool: true
+#   vrf: vrf2
+# - description: ipv6 prefix1
+#   prefix: 2001:db8:a000:1::/64
+#   site: AMS 2
+#   status: Active
+#   tenant: tenant2
+#   vlan: vlan2
--- a/initializers/rack_roles.yml
+++ b/initializers/rack_roles.yml
@ -0,0 +1,12 @@
+# - 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
--- a/initializers/racks.yml
+++ b/initializers/racks.yml
@ -0,0 +1,24 @@
+# - 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
--- a/initializers/regions.yml
+++ b/initializers/regions.yml
@ -0,0 +1,10 @@
+# - name: Singapore
+#   slug: singapore
+# - name: Amsterdam
+#   slug: amsterdam
+# - name: Downtown
+#   slug: downtown
+#   parent: Amsterdam
+# - name: Suburbs
+#   slug: suburbs
+#   parent: Amsterdam
--- a/initializers/rirs.yml
+++ b/initializers/rirs.yml
@ -0,0 +1,9 @@
+# - is_private: true
+#   name: RFC1918
+#   slug: rfc1918
+# - is_private: true
+#   name: RFC4193 ULA
+#   slug: rfc4193-ula
+# - is_private: true
+#   name: RFC3849
+#   slug: rfc3849
--- a/initializers/sites.yml
+++ b/initializers/sites.yml
@ -0,0 +1,32 @@
+# - 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
--- a/initializers/tenant_groups.yml
+++ b/initializers/tenant_groups.yml
@ -0,0 +1,4 @@
+# - name: Tenant Group 1
+#   slug: tenant-group-1
+# - name: Tenant Group 2
+#   slug: tenant-group-2
--- a/initializers/tenants.yml
+++ b/initializers/tenants.yml
@ -0,0 +1,5 @@
+# - name: tenant1
+#   slug: tenant1
+# - name: tenant2
+#   slug: tenant2
+#   group: Tenant Group 2
--- a/initializers/users.yml
+++ b/initializers/users.yml
@ -0,0 +1,13 @@
+# 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
--- a/initializers/virtual_machines.yml
+++ b/initializers/virtual_machines.yml
@ -0,0 +1,18 @@
+# - cluster: cluster1
+#   comments: VM1
+#   disk: 200
+#   memory: 4096
+#   name: virtual machine 1
+#   platform: Platform 2
+#   status: Active
+#   tenant: tenant1
+#   vcpus: 8
+# - cluster: cluster1
+#   comments: VM2
+#   disk: 100
+#   memory: 2048
+#   name: virtual machine 2
+#   platform: Platform 2
+#   status: Active
+#   tenant: tenant1
+#   vcpus: 8
--- a/initializers/virtualization_interfaces.yml
+++ b/initializers/virtualization_interfaces.yml
@ -0,0 +1,12 @@
+# - description: Network Interface 1
+#   enabled: true
+#   mac_address: 00:77:77:77:77:77
+#   mtu: 1500
+#   name: Network Interface 1
+#   virtual_machine: virtual machine 1
+# - description: Network Interface 2
+#   enabled: true
+#   mac_address: 00:55:55:55:55:55
+#   mtu: 1500
+#   name: Network Interface 2
+#   virtual_machine: virtual machine 1
--- a/initializers/vlan_groups.yml
+++ b/initializers/vlan_groups.yml
@ -0,0 +1,6 @@
+# - name: VLAN group 1
+#   site: AMS 1
+#   slug: vlan-group-1
+# - name: VLAN group 2
+#   site: AMS 1
+#   slug: vlan-group-2
--- a/initializers/vlans.yml
+++ b/initializers/vlans.yml
@ -0,0 +1,11 @@
+# - name: vlan1
+#   site: AMS 1
+#   status: Active
+#   vid: 5
+#   role: Main Management
+#   description: VLAN 5 for MGMT
+# - group: VLAN group 2
+#   name: vlan2
+#   site: AMS 1
+#   status: Active
+#   vid: 1300
--- a/initializers/vrfs.yml
+++ b/initializers/vrfs.yml
@ -0,0 +1,8 @@
+# - enforce_unique: true
+#   name: vrf1
+#   tenant: tenant1
+#   description: main VRF
+# - enforce_unique: true
+#   name: vrf2
+#   rd: "6500:6500"
+#   tenant: tenant2
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,26 +0,0 @@
-[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"
--- a/release.sh
+++ b/release.sh
@ -1,188 +0,0 @@
-#!/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."
--- a/renovate.json
+++ b/renovate.json
@ -1,14 +0,0 @@
-{
-  "extends": [
-    "config:base",
-    ":disableDependencyDashboard"
-  ],
-  "enabled": true,
-  "labels": ["maintenance"],
-  "baseBranches": ["develop"],
-  "pip_requirements": {
-    "fileMatch": [
-      "requirements-container.txt"
-    ]
-  }
-}
--- a/reports/devices.py.example
+++ b/reports/devices.py.example
@ -0,0 +1,46 @@
+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)
+
--- a/requirements-container.txt
+++ b/requirements-container.txt
@ -1,5 +0,0 @@
-django-auth-ldap==4.8.0
-django-storages[azure,boto3,dropbox,google,libcloud,sftp]==1.14.4
-dulwich==0.22.1
-python3-saml==1.16.0 --no-binary lxml,xmlsec
-sentry-sdk[django]==2.14.0
--- a/startup_scripts/000_users.py
+++ b/startup_scripts/000_users.py
@ -0,0 +1,34 @@
+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', []):
+            for permission in Permission.objects.filter(codename=permission_codename):
+              user.user_permissions.add(permission)
+          user.save()
--- a/startup_scripts/010_groups.py
+++ b/startup_scripts/010_groups.py
@ -0,0 +1,32 @@
+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()
+        for permission_codename in group_details.get('permissions', []):
+          for permission in Permission.objects.filter(codename=permission_codename):
+            group.permissions.add(permission)
--- a/startup_scripts/020_custom_fields.py
+++ b/startup_scripts/020_custom_fields.py
@ -0,0 +1,75 @@
+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)
--- a/startup_scripts/030_regions.py
+++ b/startup_scripts/030_regions.py
@ -0,0 +1,31 @@
+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)
--- a/startup_scripts/040_sites.py
+++ b/startup_scripts/040_sites.py
@ -0,0 +1,46 @@
+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)
--- a/startup_scripts/050_manufacturers.py
+++ b/startup_scripts/050_manufacturers.py
@ -0,0 +1,19 @@
+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)
--- a/startup_scripts/060_device_types.py
+++ b/startup_scripts/060_device_types.py
@ -0,0 +1,56 @@
+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)
--- a/startup_scripts/070_rack_roles.py
+++ b/startup_scripts/070_rack_roles.py
@ -0,0 +1,28 @@
+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)
--- a/startup_scripts/080_racks.py
+++ b/startup_scripts/080_racks.py
@ -0,0 +1,66 @@
+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)
--- a/startup_scripts/090_device_roles.py
+++ b/startup_scripts/090_device_roles.py
@ -0,0 +1,29 @@
+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)
--- a/startup_scripts/100_platforms.py
+++ b/startup_scripts/100_platforms.py
@ -0,0 +1,32 @@
+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)
--- a/Show More
+++ b/Show More
 @ -1 +1 @@
 .0.2
 .18.0