don't make factories and interfaces when there's only one

Signed-off-by: Sven Dowideit <sven.dowideit@portainer.io>

.codeclimate.yml

@@ -0,0 +1,44 @@
+version: "2"
+checks:
+  argument-count:
+    enabled: false
+  complex-logic:
+    enabled: false
+  file-lines:
+    enabled: false
+  method-complexity:
+    enabled: false
+  method-count:
+    enabled: false
+  method-lines:
+    enabled: false
+  nested-control-flow:
+    enabled: false
+  return-statements:
+    enabled: false
+  similar-code:
+    enabled: false
+  identical-code:
+    enabled: false
+plugins:
+  gofmt:
+    enabled: true
+  eslint:
+    enabled: true
+    channel: "eslint-5"
+    config:
+      config: .eslintrc.yml
+exclude_patterns:
+- assets/
+- build/
+- dist/
+- distribution/
+- node_modules
+- test/
+- webpack/
+- gruntfile.js
+- webpack.config.js
+- api/
+- "!app/kubernetes/**"
+- .github/
+- .tmp/

.dockerignore

@@ -1,5 +1,3 @@
 *
 !dist
 !build
-!metadata.json
-!docker-extension/build

.eslintrc.yml

@@ -31,12 +31,7 @@ rules:
     [
       'error',
       {
-        pathGroups:
-          [
-            { pattern: '@@/**', group: 'internal', position: 'after' },
-            { pattern: '@/**', group: 'internal' },
-            { pattern: '{Kubernetes,Portainer,Agent,Azure,Docker}/**', group: 'internal' },
-          ],
+        pathGroups: [{ pattern: '@/**', group: 'internal' }, { pattern: '{Kubernetes,Portainer,Agent,Azure,Docker}/**', group: 'internal' }],
         groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
         pathGroupsExcludedImportTypes: ['internal'],
       },
@@ -46,7 +41,6 @@ settings:
   'import/resolver':
     alias:
       map:
-        - ['@@', './app/react/components']
         - ['@', './app']
       extensions: ['.js', '.ts', '.tsx']
 
@@ -58,7 +52,6 @@ overrides:
     parser: '@typescript-eslint/parser'
     plugins:
       - '@typescript-eslint'
-      - 'regex'
     extends:
       - airbnb
       - airbnb-typescript
@@ -75,15 +68,7 @@ overrides:
         version: 'detect'
     rules:
       import/order:
-        [
-          'error',
-          {
-            pathGroups: [{ pattern: '@@/**', group: 'internal', position: 'after' }, { pattern: '@/**', group: 'internal' }],
-            groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
-            'newlines-between': 'always',
-          },
-        ]
-      no-plusplus: off
+        ['error', { pathGroups: [{ pattern: '@/**', group: 'internal' }], groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'], 'newlines-between': 'always' }]
       func-style: [error, 'declaration']
       import/prefer-default-export: off
       no-use-before-define: ['error', { functions: false }]
@@ -100,17 +85,11 @@ overrides:
       '@typescript-eslint/explicit-module-boundary-types': off
       '@typescript-eslint/no-unused-vars': 'error'
       '@typescript-eslint/no-explicit-any': 'error'
-      'jsx-a11y/label-has-associated-control': ['error', { 'assert': 'either', controlComponents: ['Input', 'Checkbox'] }]
+      'jsx-a11y/label-has-associated-control': ['error', { 'assert': 'either' }]
       'react/function-component-definition': ['error', { 'namedComponents': 'function-declaration' }]
       'react/jsx-no-bind': off
       'no-await-in-loop': 'off'
       'react/jsx-no-useless-fragment': ['error', { allowExpressions: true }]
-      'regex/invalid': ['error', [{ 'regex': '<Icon icon="(.*)"', 'message': 'Please directly import the `lucide-react` icon instead of using the string' }]]
-    overrides: # allow props spreading for hoc files
-      - files:
-          - app/**/with*.ts{,x}
-        rules:
-          'react/jsx-props-no-spreading': off
   - files:
       - app/**/*.test.*
     extends:

.git-blame-ignore-revs

@@ -2,7 +2,4 @@
 cf5056d9c03b62d91a25c3b9127caac838695f98
 
 # prettier v2
-42e7db0ae7897d3cb72b0ea1ecf57ee2dd694169
-
-# tailwind prettier
-58d66d3142950bb90a7d85511c034ac9fabba9ba
+42e7db0ae7897d3cb72b0ea1ecf57ee2dd694169

.github/workflows/lint.yml

@@ -18,15 +18,17 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - name: Check out Git repository
+        uses: actions/checkout@v2
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v1
         with:
-          node-version: '14'
-          cache: 'yarn'
-      - uses: actions/setup-go@v3
-        with:
-          go-version: 1.19.4
-      - run: yarn --frozen-lockfile
+          node-version: 12
+
+      # ESLint and Prettier must be in `package.json`
+      - name: Install Node.js dependencies
+        run: yarn --frozen-lockfile
 
       - name: Run linters
         uses: wearerequired/lint-action@v1
@@ -37,11 +39,3 @@ jobs:
           prettier_dir: app/
           gofmt: true
           gofmt_dir: api/
-      - name: Typecheck
-        uses: icrawl/action-tsc@v1
-      - name: GolangCI-Lint
-        uses: golangci/golangci-lint-action@v3
-        with:
-          version: latest
-          working-directory: api
-          args: -c .golangci.yaml

.github/workflows/nightly-security-scan.yml

@@ -1,236 +0,0 @@
-name: Nightly Code Security Scan
-
-on:
-  schedule:
-    - cron: '0 8 * * *'
-  workflow_dispatch:
-
-jobs:
-  client-dependencies:
-    name: Client dependency check
-    runs-on: ubuntu-latest
-    if: >- # only run for develop branch
-      github.ref == 'refs/heads/develop'
-    outputs:
-      js: ${{ steps.set-matrix.outputs.js_result }}
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Run Snyk to check for vulnerabilities
-        uses: snyk/actions/node@master
-        continue-on-error: true # To make sure that artifact upload gets called
-        env:
-          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
-        with:
-          json: true
-
-      - name: Upload js security scan result as artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: js-security-scan-develop-result
-          path: snyk.json
-
-      - name: Export scan result to html file
-        run: |
-          $(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 summary -report-type=snyk -path="/data/snyk.json" -output-type=table -export -export-filename="/data/js-result")
-
-      - name: Upload js result html file
-        uses: actions/upload-artifact@v3
-        with:
-          name: html-js-result-${{github.run_id}}
-          path: js-result.html
-
-      - name: Analyse the js result
-        id: set-matrix
-        run: |
-          result=$(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 summary -report-type=snyk -path="/data/snyk.json" -output-type=matrix)
-          echo "::set-output name=js_result::${result}"
-
-  server-dependencies:
-    name: Server dependency check
-    runs-on: ubuntu-latest
-    if: >- # only run for develop branch
-      github.ref == 'refs/heads/develop'
-    outputs:
-      go: ${{ steps.set-matrix.outputs.go_result }}
-    steps:
-      - uses: actions/checkout@master
-
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '1.19.4'
-
-      - name: Download go modules
-        run: cd ./api && go get -t -v -d ./...
-
-      - name: Run Snyk to check for vulnerabilities
-        continue-on-error: true # To make sure that artifact upload gets called
-        env:
-          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
-        run: |
-          yarn global add snyk
-          snyk test --file=./api/go.mod --json-file-output=snyk.json 2>/dev/null || :
-
-      - name: Upload go security scan result as artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: go-security-scan-develop-result
-          path: snyk.json
-
-      - name: Export scan result to html file
-        run: |
-          $(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 summary -report-type=snyk -path="/data/snyk.json" -output-type=table -export -export-filename="/data/go-result")
-
-      - name: Upload go result html file
-        uses: actions/upload-artifact@v3
-        with:
-          name: html-go-result-${{github.run_id}}
-          path: go-result.html
-
-      - name: Analyse the go result
-        id: set-matrix
-        run: |
-          result=$(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 summary -report-type=snyk -path="/data/snyk.json" -output-type=matrix)
-          echo "::set-output name=go_result::${result}"
-
-  image-vulnerability:
-    name: Build docker image and Image vulnerability check
-    runs-on: ubuntu-latest
-    if: >-
-      github.ref == 'refs/heads/develop'
-    outputs:
-      image: ${{ steps.set-matrix.outputs.image_result }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@master
-
-      - name: Use golang 1.19.4
-        uses: actions/setup-go@v3
-        with:
-          go-version: '1.19.4'
-
-      - name: Use Node.js 18.x
-        uses: actions/setup-node@v1
-        with:
-          node-version: 18.x
-
-      - name: Install packages
-        run: yarn --frozen-lockfile
-
-      - name: build
-        run: make build
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: build/linux/Dockerfile
-          tags: trivy-portainer:${{ github.sha }}
-          outputs: type=docker,dest=/tmp/trivy-portainer-image.tar
-
-      - name: Load docker image
-        run: |
-          docker load --input /tmp/trivy-portainer-image.tar
-
-      - name: Run Trivy vulnerability scanner
-        uses: docker://docker.io/aquasec/trivy:latest
-        continue-on-error: true
-        with:
-          args: image --ignore-unfixed=true --vuln-type="os,library" --exit-code=1 --format="json" --output="image-trivy.json" --no-progress trivy-portainer:${{ github.sha }}
-
-      - name: Upload image security scan result as artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: image-security-scan-develop-result
-          path: image-trivy.json
-
-      - name: Export scan result to html file
-        run: |
-          $(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 summary -report-type=trivy -path="/data/image-trivy.json" -output-type=table -export -export-filename="/data/image-result")
-
-      - name: Upload go result html file
-        uses: actions/upload-artifact@v3
-        with:
-          name: html-image-result-${{github.run_id}}
-          path: image-result.html
-
-      - name: Analyse the trivy result
-        id: set-matrix
-        run: |
-          result=$(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 summary -report-type=trivy -path="/data/image-trivy.json" -output-type=matrix)
-          echo "::set-output name=image_result::${result}"
-
-  result-analysis:
-    name: Analyse scan result
-    needs: [client-dependencies, server-dependencies, image-vulnerability]
-    runs-on: ubuntu-latest
-    if: >-
-      github.ref == 'refs/heads/develop'
-    strategy:
-      matrix:
-        js: ${{fromJson(needs.client-dependencies.outputs.js)}}
-        go: ${{fromJson(needs.server-dependencies.outputs.go)}}
-        image: ${{fromJson(needs.image-vulnerability.outputs.image)}}
-    steps:
-      - name: Display the results of js, go and image
-        run: |
-          echo ${{ matrix.js.status }}
-          echo ${{ matrix.go.status }}
-          echo ${{ matrix.image.status }}
-          echo ${{ matrix.js.summary }}
-          echo ${{ matrix.go.summary }}
-          echo ${{ matrix.image.summary }}
-
-      - name: Send Slack message
-        if: >-
-          matrix.js.status == 'failure' ||
-          matrix.go.status == 'failure' || 
-          matrix.image.status == 'failure'
-        uses: slackapi/slack-github-action@v1.18.0
-        with:
-          payload: |
-            {
-              "blocks": [
-                {
-                  "type": "section",
-                  "text": {
-                    "type": "mrkdwn",
-                    "text": "Code Scanning Result (*${{ github.repository }}*)\n*<${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}|GitHub Actions Workflow URL>*"
-                  }
-                }
-              ],
-              "attachments": [
-                {
-                  "color": "#FF0000",
-                  "blocks": [
-                    {
-                      "type": "section",
-                      "text": {
-                        "type": "mrkdwn",
-                        "text": "*JS dependency check*: *${{ matrix.js.status }}*\n${{ matrix.js.summary }}"
-                      }
-                    },
-                    {
-                      "type": "section",
-                      "text": {
-                        "type": "mrkdwn",
-                        "text": "*Go dependency check*: *${{ matrix.go.status }}*\n${{ matrix.go.summary }}"
-                      }
-                    },
-                    {
-                      "type": "section",
-                      "text": {
-                        "type": "mrkdwn",
-                        "text": "*Image vulnerability check*: *${{ matrix.image.status }}*\n${{ matrix.image.summary }}\n"
-                      }
-                    }
-                  ]
-                }
-              ]
-            }
-        env:
-          SLACK_WEBHOOK_URL: ${{ secrets.SECURITY_SLACK_WEBHOOK_URL }}
-          SLACK_WEBHOOK_TYPE: INCOMING_WEBHOOK

.github/workflows/pr-security.yml

@@ -1,238 +0,0 @@
-name: PR Code Security Scan
-
-on:
-  pull_request_review:
-    types:
-      - submitted
-      - edited
-    paths:
-      - 'package.json'
-      - 'api/go.mod'
-      - 'gruntfile.js'
-      - 'build/linux/Dockerfile'
-      - 'build/linux/alpine.Dockerfile'
-      - 'build/windows/Dockerfile'
-
-jobs:
-  client-dependencies:
-    name: Client dependency check
-    runs-on: ubuntu-latest
-    if: >-
-      github.event.pull_request &&
-      github.event.review.body == '/scan'
-    outputs:
-      jsdiff: ${{ steps.set-diff-matrix.outputs.js_diff_result }}
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Run Snyk to check for vulnerabilities
-        uses: snyk/actions/node@master
-        continue-on-error: true # To make sure that artifact upload gets called
-        env:
-          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
-        with:
-          json: true
-
-      - name: Upload js security scan result as artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: js-security-scan-feat-result
-          path: snyk.json
-
-      - name: Download artifacts from develop branch
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          mv ./snyk.json ./js-snyk-feature.json
-          (gh run download -n js-security-scan-develop-result -R ${{ github.repository }} 2>&1 >/dev/null) || :
-          if [[ -e ./snyk.json ]]; then
-            mv ./snyk.json ./js-snyk-develop.json
-          else
-            echo "null" > ./js-snyk-develop.json
-          fi
-
-      - name: Export scan result to html file
-        run: |
-          $(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 diff -report-type=snyk -path="/data/js-snyk-feature.json" -compare-to="/data/js-snyk-develop.json" -output-type=table -export -export-filename="/data/js-result")
-
-      - name: Upload js result html file
-        uses: actions/upload-artifact@v3
-        with:
-          name: html-js-result-compare-to-develop-${{github.run_id}}
-          path: js-result.html
-
-      - name: Analyse the js diff result
-        id: set-diff-matrix
-        run: |
-          result=$(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 diff -report-type=snyk -path="/data/js-snyk-feature.json" -compare-to="./data/js-snyk-develop.json" -output-type=matrix)
-          echo "::set-output name=js_diff_result::${result}"
-
-  server-dependencies:
-    name: Server dependency check
-    runs-on: ubuntu-latest
-    if: >-
-      github.event.pull_request &&
-      github.event.review.body == '/scan'
-    outputs:
-      godiff: ${{ steps.set-diff-matrix.outputs.go_diff_result }}
-    steps:
-      - uses: actions/checkout@master
-
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '1.19.4'
-
-      - name: Download go modules
-        run: cd ./api && go get -t -v -d ./...
-
-      - name: Run Snyk to check for vulnerabilities
-        continue-on-error: true # To make sure that artifact upload gets called
-        env:
-          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
-        run: |
-          yarn global add snyk
-          snyk test --file=./api/go.mod --json-file-output=snyk.json 2>/dev/null || :
-
-      - name: Upload go security scan result as artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: go-security-scan-feature-result
-          path: snyk.json
-
-      - name: Download artifacts from develop branch
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          mv ./snyk.json ./go-snyk-feature.json
-          (gh run download -n go-security-scan-develop-result -R ${{ github.repository }} 2>&1 >/dev/null) || :
-          if [[ -e ./snyk.json ]]; then
-            mv ./snyk.json ./go-snyk-develop.json
-          else
-            echo "null" > ./go-snyk-develop.json
-          fi
-
-      - name: Export scan result to html file
-        run: |
-          $(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 diff -report-type=snyk -path="/data/go-snyk-feature.json" -compare-to="/data/go-snyk-develop.json" -output-type=table -export -export-filename="/data/go-result")
-
-      - name: Upload go result html file
-        uses: actions/upload-artifact@v3
-        with:
-          name: html-go-result-compare-to-develop-${{github.run_id}}
-          path: go-result.html
-
-      - name: Analyse the go diff result
-        id: set-diff-matrix
-        run: |
-          result=$(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 diff -report-type=snyk -path="/data/go-snyk-feature.json" -compare-to="/data/go-snyk-develop.json" -output-type=matrix)
-          echo "::set-output name=go_diff_result::${result}"
-
-  image-vulnerability:
-    name: Build docker image and Image vulnerability check
-    runs-on: ubuntu-latest
-    if: >-
-      github.event.pull_request &&
-      github.event.review.body == '/scan'
-    outputs:
-      imagediff: ${{ steps.set-diff-matrix.outputs.image_diff_result }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@master
-
-      - name: Use golang 1.19.4
-        uses: actions/setup-go@v3
-        with:
-          go-version: '1.19.4'
-
-      - name: Use Node.js 18.x
-        uses: actions/setup-node@v1
-        with:
-          node-version: 18.x
-
-      - name: Install packages
-        run: yarn --frozen-lockfile
-
-      - name: build
-        run: make build
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: build/linux/Dockerfile
-          tags: trivy-portainer:${{ github.sha }}
-          outputs: type=docker,dest=/tmp/trivy-portainer-image.tar
-
-      - name: Load docker image
-        run: |
-          docker load --input /tmp/trivy-portainer-image.tar
-
-      - name: Run Trivy vulnerability scanner
-        uses: docker://docker.io/aquasec/trivy:latest
-        continue-on-error: true
-        with:
-          args: image --ignore-unfixed=true --vuln-type="os,library" --exit-code=1 --format="json" --output="image-trivy.json" --no-progress trivy-portainer:${{ github.sha }}
-
-      - name: Upload image security scan result as artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: image-security-scan-feature-result
-          path: image-trivy.json
-
-      - name: Download artifacts from develop branch
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          mv ./image-trivy.json ./image-trivy-feature.json
-          (gh run download -n image-security-scan-develop-result -R ${{ github.repository }} 2>&1 >/dev/null) || :
-          if [[ -e ./image-trivy.json ]]; then
-            mv ./image-trivy.json ./image-trivy-develop.json
-          else
-            echo "null" > ./image-trivy-develop.json
-          fi
-
-      - name: Export scan result to html file
-        run: |
-          $(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 diff -report-type=trivy -path="/data/image-trivy-feature.json" -compare-to="/data/image-trivy-develop.json" -output-type=table -export -export-filename="/data/image-result")
-
-      - name: Upload image result html file
-        uses: actions/upload-artifact@v3
-        with:
-          name: html-image-result-compare-to-develop-${{github.run_id}}
-          path: image-result.html
-
-      - name: Analyse the image diff result
-        id: set-diff-matrix
-        run: |
-          result=$(docker run --rm -v ${{ github.workspace }}:/data oscarzhou/scan-report:0.1.8 diff -report-type=trivy -path="/data/image-trivy-feature.json" -compare-to="./data/image-trivy-develop.json" -output-type=matrix)
-          echo "::set-output name=image_diff_result::${result}"
-
-  result-analysis:
-    name: Analyse scan result compared to develop
-    needs: [client-dependencies, server-dependencies, image-vulnerability]
-    runs-on: ubuntu-latest
-    if: >-
-      github.event.pull_request &&
-      github.event.review.body == '/scan'
-    strategy:
-      matrix:
-        jsdiff: ${{fromJson(needs.client-dependencies.outputs.jsdiff)}}
-        godiff: ${{fromJson(needs.server-dependencies.outputs.godiff)}}
-        imagediff: ${{fromJson(needs.image-vulnerability.outputs.imagediff)}}
-    steps:
-      - name: Check job status of diff result
-        if: >-
-          matrix.jsdiff.status == 'failure' ||
-          matrix.godiff.status == 'failure' ||
-          matrix.imagediff.status == 'failure'
-        run: |
-          echo ${{ matrix.jsdiff.status }}
-          echo ${{ matrix.godiff.status }}
-          echo ${{ matrix.imagediff.status }}
-          echo ${{ matrix.jsdiff.summary }}
-          echo ${{ matrix.godiff.summary }}
-          echo ${{ matrix.imagediff.summary }}
-          exit 1

.github/workflows/test-client.yaml

@@ -0,0 +1,11 @@
+name: Test Frontend
+on: push
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install modules
+        run: yarn --frozen-lockfile
+      - name: Run tests
+        run: yarn test:client

.github/workflows/test.yaml

@@ -1,29 +0,0 @@
-name: Test
-on: push
-jobs:
-  test-client:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '18'
-          cache: 'yarn'
-      - run: yarn --frozen-lockfile
-
-      - name: Run tests
-        run: yarn jest --maxWorkers=2
-  # test-server:
-  #   runs-on: ubuntu-latest
-  #   env:
-  #     GOPRIVATE: "github.com/portainer"
-  #   steps:
-  #     - uses: actions/checkout@v3
-  #     - uses: actions/setup-go@v3
-  #       with:
-  #         go-version: '1.18'
-  #     - name: Run tests
-  #       run: |
-  #         cd api
-  #         go test ./...

.github/workflows/validate-openapi-spec.yaml

@@ -1,29 +0,0 @@
-name: Validate OpenAPI specs
-
-on:
-  pull_request:
-    branches:
-      - master
-      - develop
-      - 'release/*'
-
-jobs:
-  openapi-spec:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '1.18'
-
-      - name: Download golang modules
-        run: cd ./api && go get -t -v -d ./...
-      - uses: actions/setup-node@v3
-        with:
-          node-version: '14'
-          cache: 'yarn'
-      - run: yarn --frozen-lockfile
-
-      - name: Validate OpenAPI Spec
-        run: make docs-validate

.github/workflows/validate-openapi-spec.yml

@@ -0,0 +1,53 @@
+name: Validate
+
+on:
+  pull_request:
+    branches:
+      - master
+      - develop
+      - 'release/*'
+
+jobs:
+  openapi-spec:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v2
+    - name: Setup Node v14
+      uses: actions/setup-node@v2
+      with:
+        node-version: 14
+
+    # https://github.com/actions/cache/blob/main/examples.md#node---yarn
+    - name: Get yarn cache directory path
+      id: yarn-cache-dir-path
+      run: echo "::set-output name=dir::$(yarn cache dir)"
+
+    - uses: actions/cache@v2
+      id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
+      with:
+        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-yarn-
+
+    - name: Setup Go v1.17.3
+      uses: actions/setup-go@v2
+      with:
+        go-version: '^1.17.3'
+
+    - name: Prebuild docs
+      run: yarn prebuild:docs
+
+    - name: Build OpenAPI 2.0 Spec
+      run: yarn build:docs
+
+    # Install dependencies globally to bypass installing all frontend deps
+    - name: Install swagger2openapi and swagger-cli
+      run: yarn global add swagger2openapi @apidevtools/swagger-cli
+
+    # OpenAPI2.0 does not support multiple body params (which we utilise in some of our handlers).
+    # OAS3.0 however does support multiple body params - hence its best to convert the generated OAS 2.0
+    # to OAS 3.0 and validate the output of generated OAS 3.0 instead.
+    - name: Convert OpenAPI 2.0 to OpenAPI 3.0 and validate spec
+      run: yarn validate:docs

.gitignore

@@ -7,7 +7,6 @@ storybook-static
 .tmp
 **/.vscode/settings.json
 **/.vscode/tasks.json
-.vscode
 *.DS_Store
 
 .eslintcache

.prettierignore

@@ -1,2 +1 @@
-dist
-api/datastore/test_data
+dist

.storybook/main.js

@@ -16,9 +16,6 @@ module.exports = {
             exportLocalsConvention: 'camelCaseOnly',
           },
         },
-        postcssLoaderOptions: {
-          implementation: require('postcss'),
-        },
       },
     },
   ],
@@ -29,23 +26,6 @@ module.exports = {
         extensions: config.resolve.extensions,
       }),
     ];
-
-    const svgRule = config.module.rules.find((rule) => rule.test && typeof rule.test.test === 'function' && rule.test.test('.svg'));
-    svgRule.test = new RegExp(svgRule.test.source.replace('svg|', ''));
-
-    config.module.rules.unshift({
-      test: /\.svg$/i,
-      type: 'asset',
-      resourceQuery: { not: [/c/] }, // exclude react component if *.svg?url
-    });
-
-    config.module.rules.unshift({
-      test: /\.svg$/i,
-      issuer: /\.(js|ts)(x)?$/,
-      resourceQuery: /c/, // *.svg?c
-      use: [{ loader: '@svgr/webpack', options: { icon: true } }],
-    });
-
     return config;
   },
   core: {

.storybook/preview.js

@@ -3,7 +3,6 @@ import '../app/assets/css';
 import { pushStateLocationPlugin, UIRouter } from '@uirouter/react';
 import { initialize as initMSW, mswDecorator } from 'msw-storybook-addon';
 import { handlers } from '@/setup-tests/server-handlers';
-import { QueryClient, QueryClientProvider } from 'react-query';
 
 // Initialize MSW
 initMSW({
@@ -32,17 +31,11 @@ export const parameters = {
   },
 };
 
-const testQueryClient = new QueryClient({
-  defaultOptions: { queries: { retry: false } },
-});
-
 export const decorators = [
   (Story) => (
-    <QueryClientProvider client={testQueryClient}>
-      <UIRouter plugins={[pushStateLocationPlugin]}>
-        <Story />
-      </UIRouter>
-    </QueryClientProvider>
+    <UIRouter plugins={[pushStateLocationPlugin]}>
+      <Story />
+    </UIRouter>
   ),
   mswDecorator,
 ];

CONTRIBUTING.md

@@ -25,7 +25,7 @@ Each commit message should include a **type**, a **scope** and a **subject**:
  <type>(<scope>): <subject>
 ```
 
-Lines should not exceed 100 characters. This allows the message to be easier to read on GitHub as well as in various git tools and produces a nice, neat commit log ie:
+Lines should not exceed 100 characters. This allows the message to be easier to read on github as well as in various git tools and produces a nice, neat commit log ie:
 
 ```
  #271 feat(containers): add exposed ports in the containers view
@@ -63,7 +63,7 @@ The subject contains succinct description of the change:
 
 ## Contribution process
 
-Our contribution process is described below. Some of the steps can be visualized inside GitHub via specific `status/` labels, such as `status/1-functional-review` or `status/2-technical-review`.
+Our contribution process is described below. Some of the steps can be visualized inside Github via specific `status/` labels, such as `status/1-functional-review` or `status/2-technical-review`.
 
 ### Bug report
 
@@ -93,7 +93,7 @@ $ yarn start
 
 Portainer can now be accessed at <https://localhost:9443>.
 
-Find more detailed steps at <https://docs.portainer.io/contribute/build>.
+Find more detailed steps at <https://documentation.portainer.io/contributing/instructions/>.
 
 ### Build customisation
 
@@ -103,10 +103,6 @@ You can customise the following settings:
 - `PORTAINER_PROJECT`: The root dir of the repository - `${portainerRoot}/dist/` is imported into the container to get the build artifacts and external tools (defaults to `your current dir`).
 - `PORTAINER_FLAGS`: a list of flags to be used on the portainer commandline, in the form `--admin-password=<pwd hash> --feat fdo=false --feat open-amt` (default: `""`).
 
-## Testing your build
-
-The `--log-level=DEBUG` flag can be passed to the Portainer container in order to provide additional debug output which may be useful when troubleshooting your builds. Please note that this flag was originally intended for internal use and as such the format, functionality and output may change between releases without warning.
-
 ## Adding api docs
 
 When adding a new resource (or a route handler), we should add a new tag to api/http/handler/handler.go#L136 like this:

Makefile

@@ -1,122 +0,0 @@
-# See: https://gist.github.com/asukakenji/f15ba7e588ac42795f421b48b8aede63
-# For a list of valid GOOS and GOARCH values
-# Note: these can be overriden on the command line e.g. `make PLATFORM=<platform> ARCH=<arch>`
-PLATFORM=$(shell go env GOOS)
-ARCH=$(shell go env GOARCH)
-
-TAG=latest
-SWAG_VERSION=v1.8.11
-
-# build target, can be one of "production", "testing", "development"
-ENV=development
-WEBPACK_CONFIG=webpack/webpack.$(ENV).js
-
-.DEFAULT_GOAL := help
-
-.PHONY: help build-storybook build-client devops download-binaries tidy clean client-deps
-
-##@ Building
-
-init-dist:
-	@mkdir -p dist
-
-build-storybook:
-	yarn storybook:build
-
-build: build-server build-client ## Build the server and client
-
-build-client: init-dist client-deps ## Build the client
-	export NODE_ENV=$(ENV) && yarn build --config $(WEBPACK_CONFIG)
-
-build-server: init-dist ## Build the server binary
-	./build/build_binary.sh "$(PLATFORM)" "$(ARCH)"
-
-build-image: build ## Build the Portainer image
-	docker buildx build --load -t portainerci/portainer:$(TAG) -f build/linux/Dockerfile .
-
-devops: clean init-dist download-binaries build-client ## Build the server binary for CI
-	echo "Building the devops binary..."
-	@./build/build_binary_azuredevops.sh "$(PLATFORM)" "$(ARCH)"
-
-##@ Dependencies
-
-download-binaries: ## Download dependant binaries
-	@./build/download_binaries.sh $(PLATFORM) $(ARCH)
-
-tidy: ## Tidy up the go.mod file
-	cd api && go mod tidy
- 
-client-deps: ## Install client dependencies
-	yarn
-
-##@ Cleanup
-
-clean: ## Remove all build and download artifacts
-	@echo "Clearing the dist directory..."
-	@rm -rf dist/*
-
-##@ Testing
-
-test-client: ## Run client tests
-	yarn test
-
-test-server:	## Run server tests
-	cd api && go test -v ./...
-
-test: test-client test-server ## Run all tests
-
-##@ Dev
-
-dev-client: ## Run the client in development mode 
-	yarn dev
-
-dev-server: build-image ## Run the server in development mode
-	@./dev/run_container.sh
-
-
-##@ Format
-
-format-client: ## Format client code
-	yarn format
-
-format-server: ## Format server code
-	cd api && go fmt ./...
-
-format: format-client format-server ## Format all code
-
-##@ Lint
-
-lint: lint-client lint-server ## Lint all code
-
-lint-client: ## Lint client code
-	yarn lint
-
-lint-server: ## Lint server code
-	cd api && go vet ./...
-
-##@ Extension
-
-dev-extension: build-server build-client ## Run the extension in development mode
-	make local -f build/docker-extension/Makefile
-
-##@ Docs
-
-docs-deps: ## Install docs dependencies
-	go install github.com/swaggo/swag/cmd/swag@$(SWAG_VERSION)
-
-docs-build: docs-deps ## Build docs
-	cd api && swag init -g ./http/handler/handler.go --parseDependency --parseInternal --parseDepth 2 --markdownFiles ./
-
-docs-validate: docs-build ## Validate docs
-	yarn swagger2openapi --warnOnly api/docs/swagger.yaml -o api/docs/openapi.yaml
-	yarn swagger-cli validate api/docs/openapi.yaml
-
-docs-clean: ## Clean docs
-	rm -rf api/docs
-
-docs-validate-clean: docs-validate docs-clean ## Validate and clean docs
-
-##@ Helpers
-
-help:  ## Display this help
-	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n"} /^[a-zA-Z_-]+:.*?##/ { printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)

README.md

@@ -12,15 +12,21 @@ Portainer consists of a single container that can run on any cluster. It can be
 - [Take5 – get 5 free nodes of Portainer Business for as long as you want them](https://portainer.io/pricing/take5)
 - [Portainer BE install guide](https://install.portainer.io)
 
+## Demo
+
+You can try out the public demo instance: http://demo.portainer.io/ (login with the username **admin** and the password **tryportainer**).
+
+Please note that the public demo cluster is **reset every 15min**.
+
 ## Latest Version
 
 Portainer CE is updated regularly. We aim to do an update release every couple of months.
 
-[![latest version](https://img.shields.io/github/v/release/portainer/portainer?color=%2344cc11&label=Latest%20release&style=for-the-badge)](https://github.com/portainer/portainer/releases/latest)
+**The latest version of Portainer is 2.9.x**. Portainer is on version 2, the second number denotes the month of release.
 
 ## Getting started
 
-- [Deploy Portainer](https://docs.portainer.io/start/install)
+- [Deploy Portainer](https://docs.portainer.io/v/ce-2.9/start/install)
 - [Documentation](https://documentation.portainer.io)
 - [Contribute to the project](https://documentation.portainer.io/contributing/instructions/)
 

api/.golangci.yaml

@@ -1,26 +0,0 @@
-linters:
-  # Disable all linters.
-  disable-all: true
-  enable:
-    - depguard
-linters-settings:
-  depguard:
-    list-type: denylist
-    include-go-root: true
-    packages:
-      - github.com/sirupsen/logrus
-      - golang.org/x/exp
-    packages-with-error-message:
-      - github.com/sirupsen/logrus: 'logging is allowed only by github.com/rs/zerolog'
-    ignore-file-rules:
-      - "**/*_test.go"
-    # Create additional guards that follow the same configuration pattern.
-    # Results from all guards are aggregated together.
-    # additional-guards:
-    #   - list-type: allowlist
-    #     include-go-root: false
-    #     packages:
-    #       - github.com/sirupsen/logrus
-    #     # Specify rules by which the linter ignores certain files for consideration.
-    #     ignore-file-rules:
-    #       - "!**/*_test.go"

api/adminmonitor/admin_monitor.go

@@ -2,88 +2,60 @@ package adminmonitor
 
 import (
 	"context"
-	"net/http"
-	"strings"
-	"sync"
+	"log"
 	"time"
 
-	httperror "github.com/portainer/libhttp/error"
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices"
-
-	"github.com/rs/zerolog/log"
 )
 
-const RedirectReasonAdminInitTimeout string = "AdminInitTimeout"
+var logFatalf = log.Fatalf
 
 type Monitor struct {
-	timeout           time.Duration
-	datastore         dataservices.DataStore
-	shutdownCtx       context.Context
-	cancellationFunc  context.CancelFunc
-	mu                sync.RWMutex
-	adminInitDisabled bool
+	timeout          time.Duration
+	datastore        dataservices.DataStore
+	shutdownCtx      context.Context
+	cancellationFunc context.CancelFunc
 }
 
 // New creates a monitor that when started will wait for the timeout duration and then shutdown the application unless it has been initialized.
 func New(timeout time.Duration, datastore dataservices.DataStore, shutdownCtx context.Context) *Monitor {
 	return &Monitor{
-		timeout:           timeout,
-		datastore:         datastore,
-		shutdownCtx:       shutdownCtx,
-		adminInitDisabled: false,
+		timeout:     timeout,
+		datastore:   datastore,
+		shutdownCtx: shutdownCtx,
 	}
 }
 
 // Starts starts the monitor. Active monitor could be stopped or shuttted down by cancelling the shutdown context.
 func (m *Monitor) Start() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if m.cancellationFunc != nil {
-		return
-	}
-
 	cancellationCtx, cancellationFunc := context.WithCancel(context.Background())
 	m.cancellationFunc = cancellationFunc
 
 	go func() {
-		log.Debug().Msg("start initialization monitor")
-
+		log.Println("[DEBUG] [internal,init] [message: start initialization monitor ]")
 		select {
 		case <-time.After(m.timeout):
 			initialized, err := m.WasInitialized()
 			if err != nil {
-				log.Error().Err(err).Msg("AdminMonitor failed to determine if Portainer is Initialized")
-				return
+				logFatalf("%s", err)
 			}
-
 			if !initialized {
-				log.Info().Msg("the Portainer instance timed out for security purposes, to re-enable your Portainer instance, you will need to restart Portainer")
-
-				m.mu.Lock()
-				defer m.mu.Unlock()
-
-				m.adminInitDisabled = true
-				return
+				logFatalf("[FATAL] [internal,init] No administrator account was created in %f mins. Shutting down the Portainer instance for security reasons", m.timeout.Minutes())
 			}
 		case <-cancellationCtx.Done():
-			log.Debug().Msg("canceling initialization monitor")
+			log.Println("[DEBUG] [internal,init] [message: canceling initialization monitor]")
 		case <-m.shutdownCtx.Done():
-			log.Debug().Msg("shutting down initialization monitor")
+			log.Println("[DEBUG] [internal,init] [message: shutting down initialization monitor]")
 		}
 	}()
 }
 
 // Stop stops monitor. Safe to call even if monitor wasn't started.
 func (m *Monitor) Stop() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
 	if m.cancellationFunc == nil {
 		return
 	}
-
 	m.cancellationFunc()
 	m.cancellationFunc = nil
 }
@@ -94,27 +66,5 @@ func (m *Monitor) WasInitialized() (bool, error) {
 	if err != nil {
 		return false, err
 	}
-
 	return len(users) > 0, nil
 }
-
-func (m *Monitor) WasInstanceDisabled() bool {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	return m.adminInitDisabled
-}
-
-// WithRedirect checks whether administrator initialisation timeout. If so, it will return the error with redirect reason.
-// Otherwise, it will pass through the request to next
-func (m *Monitor) WithRedirect(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if m.WasInstanceDisabled() && strings.HasPrefix(r.RequestURI, "/api") && r.RequestURI != "/api/status" && r.RequestURI != "/api/settings/public" {
-			w.Header().Set("redirect-reason", RedirectReasonAdminInitTimeout)
-			httperror.WriteError(w, http.StatusSeeOther, "Administrator initialization timeout", nil)
-			return
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}

api/adminmonitor/admin_monitor_test.go

@@ -21,18 +21,6 @@ func Test_stopCouldBeCalledMultipleTimes(t *testing.T) {
 	monitor.Stop()
 }
 
-func Test_startOrStopCouldBeCalledMultipleTimesConcurrently(t *testing.T) {
-	monitor := New(1*time.Minute, nil, context.Background())
-
-	go monitor.Start()
-	monitor.Start()
-
-	go monitor.Stop()
-	monitor.Stop()
-
-	time.Sleep(2 * time.Second)
-}
-
 func Test_canStopStartedMonitor(t *testing.T) {
 	monitor := New(1*time.Minute, nil, context.Background())
 	monitor.Start()
@@ -42,13 +30,21 @@ func Test_canStopStartedMonitor(t *testing.T) {
 	assert.Nil(t, monitor.cancellationFunc, "cancellation function should absent in stopped monitor")
 }
 
-func Test_start_shouldDisableInstanceAfterTimeout_ifNotInitialized(t *testing.T) {
+func Test_start_shouldFatalAfterTimeout_ifNotInitialized(t *testing.T) {
 	timeout := 10 * time.Millisecond
 
 	datastore := i.NewDatastore(i.WithUsers([]portainer.User{}))
+
+	var fataled bool
+	origLogFatalf := logFatalf
+	logFatalf = func(s string, v ...interface{}) { fataled = true }
+	defer func() {
+		logFatalf = origLogFatalf
+	}()
+
 	monitor := New(timeout, datastore, context.Background())
 	monitor.Start()
+	<-time.After(2 * timeout)
 
-	<-time.After(20 * timeout)
-	assert.True(t, monitor.WasInstanceDisabled(), "monitor should have been timeout and instance is disabled")
+	assert.True(t, fataled, "monitor should been timeout and fatal")
 }

api/agent/version.go

@@ -1,71 +0,0 @@
-package agent
-
-import (
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net/http"
-	"strconv"
-	"time"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/url"
-)
-
-// GetAgentVersionAndPlatform returns the agent version and platform
-//
-// it sends a ping to the agent and parses the version and platform from the headers
-func GetAgentVersionAndPlatform(endpointUrl string, tlsConfig *tls.Config) (portainer.AgentPlatform, string, error) {
-	httpCli := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-
-	if tlsConfig != nil {
-		httpCli.Transport = &http.Transport{
-			TLSClientConfig: tlsConfig,
-		}
-	}
-
-	parsedURL, err := url.ParseURL(endpointUrl + "/ping")
-	if err != nil {
-		return 0, "", err
-	}
-
-	parsedURL.Scheme = "https"
-
-	req, err := http.NewRequest(http.MethodGet, parsedURL.String(), nil)
-	if err != nil {
-		return 0, "", err
-	}
-
-	resp, err := httpCli.Do(req)
-	if err != nil {
-		return 0, "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusNoContent {
-		return 0, "", fmt.Errorf("Failed request with status %d", resp.StatusCode)
-	}
-
-	version := resp.Header.Get(portainer.PortainerAgentHeader)
-	if version == "" {
-		return 0, "", errors.New("Version Header is missing")
-	}
-
-	agentPlatformHeader := resp.Header.Get(portainer.HTTPResponseAgentPlatform)
-	if agentPlatformHeader == "" {
-		return 0, "", errors.New("Agent Platform Header is missing")
-	}
-
-	agentPlatformNumber, err := strconv.Atoi(agentPlatformHeader)
-	if err != nil {
-		return 0, "", err
-	}
-
-	if agentPlatformNumber == 0 {
-		return 0, "", errors.New("Agent platform is invalid")
-	}
-
-	return portainer.AgentPlatform(agentPlatformNumber), version, nil
-}

api/api-description.md

@@ -50,15 +50,4 @@ Instead, it acts as a reverse-proxy to the Docker HTTP API. This means that you
 
 To do so, you can use the `/endpoints/{id}/docker` Portainer API environment(endpoint) (which is not documented below due to Swagger limitations). This environment(endpoint) has a restricted access policy so you still need to be authenticated to be able to query this environment(endpoint). Any query on this environment(endpoint) will be proxied to the Docker API of the associated environment(endpoint) (requests and responses objects are the same as documented in the Docker API).
 
-# Private Registry
-
-Using private registry, you will need to pass a based64 encoded JSON string ‘{"registryId":\<registryID value\>}’ inside the Request Header. The parameter name is "X-Registry-Auth".
-\<registryID value\> - The registry ID where the repository was created.
-
-Example:
-
-```
-eyJyZWdpc3RyeUlkIjoxfQ==
-```
-
 **NOTE**: You can find more information on how to query the Docker API in the [Docker official documentation](https://docs.docker.com/engine/api/v1.30/) as well as in [this Portainer example](https://documentation.portainer.io/api/api-examples/).

api/apikey/apikey.go

@@ -2,6 +2,7 @@ package apikey
 
 import (
 	"crypto/rand"
+	"github.com/portainer/portainer/api/database"
 	"io"
 
 	portainer "github.com/portainer/portainer/api"
@@ -12,11 +13,11 @@ type APIKeyService interface {
 	HashRaw(rawKey string) []byte
 	GenerateApiKey(user portainer.User, description string) (string, *portainer.APIKey, error)
 	GetAPIKey(apiKeyID portainer.APIKeyID) (*portainer.APIKey, error)
-	GetAPIKeys(userID portainer.UserID) ([]portainer.APIKey, error)
+	GetAPIKeys(userID database.UserID) ([]portainer.APIKey, error)
 	GetDigestUserAndKey(digest []byte) (portainer.User, portainer.APIKey, error)
 	UpdateAPIKey(apiKey *portainer.APIKey) error
 	DeleteAPIKey(apiKeyID portainer.APIKeyID) error
-	InvalidateUserKeyCache(userId portainer.UserID) bool
+	InvalidateUserKeyCache(userId database.UserID) bool
 }
 
 // generateRandomKey generates a random key of specified length

api/apikey/cache.go

@@ -3,6 +3,7 @@ package apikey
 import (
 	lru "github.com/hashicorp/golang-lru"
 	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/database"
 )
 
 const defaultAPIKeyCacheSize = 1024
@@ -57,7 +58,7 @@ func (c *apiKeyCache) Delete(digest []byte) {
 }
 
 // InvalidateUserKeyCache loops through all the api-keys associated to a user and removes them from the cache
-func (c *apiKeyCache) InvalidateUserKeyCache(userId portainer.UserID) bool {
+func (c *apiKeyCache) InvalidateUserKeyCache(userId database.UserID) bool {
 	present := false
 	for _, k := range c.cache.Keys() {
 		user, _, _ := c.Get([]byte(k.(string)))

api/apikey/service.go

@@ -4,12 +4,13 @@ import (
 	"crypto/sha256"
 	"encoding/base64"
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 	"time"
 
+	"github.com/pkg/errors"
+
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices"
-
-	"github.com/pkg/errors"
 )
 
 const portainerAPIKeyPrefix = "ptr_"
@@ -70,7 +71,7 @@ func (a *apiKeyService) GetAPIKey(apiKeyID portainer.APIKeyID) (*portainer.APIKe
 }
 
 // GetAPIKeys returns all the API keys associated to a user.
-func (a *apiKeyService) GetAPIKeys(userID portainer.UserID) ([]portainer.APIKey, error) {
+func (a *apiKeyService) GetAPIKeys(userID database.UserID) ([]portainer.APIKey, error) {
 	return a.apiKeyRepository.GetAPIKeysByUserID(userID)
 }
 
@@ -122,6 +123,6 @@ func (a *apiKeyService) DeleteAPIKey(apiKeyID portainer.APIKeyID) error {
 	return a.apiKeyRepository.DeleteAPIKey(apiKeyID)
 }
 
-func (a *apiKeyService) InvalidateUserKeyCache(userId portainer.UserID) bool {
+func (a *apiKeyService) InvalidateUserKeyCache(userId database.UserID) bool {
 	return a.cache.InvalidateUserKeyCache(userId)
 }

api/apikey/service_test.go

@@ -2,7 +2,7 @@ package apikey
 
 import (
 	"crypto/sha256"
-	"fmt"
+	"log"
 	"strings"
 	"testing"
 	"time"
@@ -10,8 +10,6 @@ import (
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/datastore"
 	"github.com/stretchr/testify/assert"
-
-	"github.com/rs/zerolog/log"
 )
 
 func Test_SatisfiesAPIKeyServiceInterface(t *testing.T) {
@@ -22,7 +20,7 @@ func Test_SatisfiesAPIKeyServiceInterface(t *testing.T) {
 func Test_GenerateApiKey(t *testing.T) {
 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	service := NewAPIKeyService(store.APIKeyRepository(), store.User())
@@ -76,7 +74,7 @@ func Test_GenerateApiKey(t *testing.T) {
 func Test_GetAPIKey(t *testing.T) {
 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	service := NewAPIKeyService(store.APIKeyRepository(), store.User())
@@ -96,7 +94,7 @@ func Test_GetAPIKey(t *testing.T) {
 func Test_GetAPIKeys(t *testing.T) {
 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	service := NewAPIKeyService(store.APIKeyRepository(), store.User())
@@ -117,7 +115,7 @@ func Test_GetAPIKeys(t *testing.T) {
 func Test_GetDigestUserAndKey(t *testing.T) {
 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	service := NewAPIKeyService(store.APIKeyRepository(), store.User())
@@ -153,7 +151,7 @@ func Test_GetDigestUserAndKey(t *testing.T) {
 func Test_UpdateAPIKey(t *testing.T) {
 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	service := NewAPIKeyService(store.APIKeyRepository(), store.User())
@@ -171,9 +169,11 @@ func Test_UpdateAPIKey(t *testing.T) {
 		_, apiKeyGot, err := service.GetDigestUserAndKey(apiKey.Digest)
 		is.NoError(err)
 
-		log.Debug().Str("wanted", fmt.Sprintf("%+v", apiKey)).Str("got", fmt.Sprintf("%+v", apiKeyGot)).Msg("")
+		log.Println(apiKey)
+		log.Println(apiKeyGot)
 
 		is.Equal(apiKey.LastUsed, apiKeyGot.LastUsed)
+
 	})
 
 	t.Run("Successfully updates api-key in cache upon api-key update", func(t *testing.T) {
@@ -199,7 +199,7 @@ func Test_UpdateAPIKey(t *testing.T) {
 func Test_DeleteAPIKey(t *testing.T) {
 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	service := NewAPIKeyService(store.APIKeyRepository(), store.User())
@@ -240,7 +240,7 @@ func Test_DeleteAPIKey(t *testing.T) {
 func Test_InvalidateUserKeyCache(t *testing.T) {
 	is := assert.New(t)
 
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	service := NewAPIKeyService(store.APIKeyRepository(), store.User())

api/archive/tar.go

@@ -34,45 +34,3 @@ func TarFileInBuffer(fileContent []byte, fileName string, mode int64) ([]byte, e
 
 	return buffer.Bytes(), nil
 }
-
-// tarFileInBuffer represents a tar archive buffer.
-type tarFileInBuffer struct {
-	b *bytes.Buffer
-	w *tar.Writer
-}
-
-func NewTarFileInBuffer() *tarFileInBuffer {
-	var b bytes.Buffer
-	return &tarFileInBuffer{
-		b: &b,
-		w: tar.NewWriter(&b),
-	}
-}
-
-// Put puts a single file to tar archive buffer.
-func (t *tarFileInBuffer) Put(fileContent []byte, fileName string, mode int64) error {
-	hdr := &tar.Header{
-		Name: fileName,
-		Mode: mode,
-		Size: int64(len(fileContent)),
-	}
-
-	if err := t.w.WriteHeader(hdr); err != nil {
-		return err
-	}
-
-	if _, err := t.w.Write(fileContent); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Bytes returns the archive as a byte array.
-func (t *tarFileInBuffer) Bytes() []byte {
-	return t.b.Bytes()
-}
-
-func (t *tarFileInBuffer) Close() error {
-	return t.w.Close()
-}

api/archive/targz_test.go

@@ -2,12 +2,14 @@ package archive
 
 import (
 	"fmt"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
 	"testing"
 
+	"github.com/docker/docker/pkg/ioutils"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -25,18 +27,22 @@ func listFiles(dir string) []string {
 }
 
 func Test_shouldCreateArhive(t *testing.T) {
-	tmpdir := t.TempDir()
+	tmpdir, _ := ioutils.TempDir("", "backup")
+	defer os.RemoveAll(tmpdir)
+
 	content := []byte("content")
-	os.WriteFile(path.Join(tmpdir, "outer"), content, 0600)
+	ioutil.WriteFile(path.Join(tmpdir, "outer"), content, 0600)
 	os.MkdirAll(path.Join(tmpdir, "dir"), 0700)
-	os.WriteFile(path.Join(tmpdir, "dir", ".dotfile"), content, 0600)
-	os.WriteFile(path.Join(tmpdir, "dir", "inner"), content, 0600)
+	ioutil.WriteFile(path.Join(tmpdir, "dir", ".dotfile"), content, 0600)
+	ioutil.WriteFile(path.Join(tmpdir, "dir", "inner"), content, 0600)
 
 	gzPath, err := TarGzDir(tmpdir)
 	assert.Nil(t, err)
 	assert.Equal(t, filepath.Join(tmpdir, fmt.Sprintf("%s.tar.gz", filepath.Base(tmpdir))), gzPath)
 
-	extractionDir := t.TempDir()
+	extractionDir, _ := ioutils.TempDir("", "extract")
+	defer os.RemoveAll(extractionDir)
+
 	cmd := exec.Command("tar", "-xzf", gzPath, "-C", extractionDir)
 	err = cmd.Run()
 	if err != nil {
@@ -47,7 +53,7 @@ func Test_shouldCreateArhive(t *testing.T) {
 	wasExtracted := func(p string) {
 		fullpath := path.Join(extractionDir, p)
 		assert.Contains(t, extractedFiles, fullpath)
-		copyContent, _ := os.ReadFile(fullpath)
+		copyContent, _ := ioutil.ReadFile(fullpath)
 		assert.Equal(t, content, copyContent)
 	}
 
@@ -57,18 +63,22 @@ func Test_shouldCreateArhive(t *testing.T) {
 }
 
 func Test_shouldCreateArhiveXXXXX(t *testing.T) {
-	tmpdir := t.TempDir()
+	tmpdir, _ := ioutils.TempDir("", "backup")
+	defer os.RemoveAll(tmpdir)
+
 	content := []byte("content")
-	os.WriteFile(path.Join(tmpdir, "outer"), content, 0600)
+	ioutil.WriteFile(path.Join(tmpdir, "outer"), content, 0600)
 	os.MkdirAll(path.Join(tmpdir, "dir"), 0700)
-	os.WriteFile(path.Join(tmpdir, "dir", ".dotfile"), content, 0600)
-	os.WriteFile(path.Join(tmpdir, "dir", "inner"), content, 0600)
+	ioutil.WriteFile(path.Join(tmpdir, "dir", ".dotfile"), content, 0600)
+	ioutil.WriteFile(path.Join(tmpdir, "dir", "inner"), content, 0600)
 
 	gzPath, err := TarGzDir(tmpdir)
 	assert.Nil(t, err)
 	assert.Equal(t, filepath.Join(tmpdir, fmt.Sprintf("%s.tar.gz", filepath.Base(tmpdir))), gzPath)
 
-	extractionDir := t.TempDir()
+	extractionDir, _ := ioutils.TempDir("", "extract")
+	defer os.RemoveAll(extractionDir)
+
 	r, _ := os.Open(gzPath)
 	ExtractTarGz(r, extractionDir)
 	if err != nil {
@@ -79,7 +89,7 @@ func Test_shouldCreateArhiveXXXXX(t *testing.T) {
 	wasExtracted := func(p string) {
 		fullpath := path.Join(extractionDir, p)
 		assert.Contains(t, extractedFiles, fullpath)
-		copyContent, _ := os.ReadFile(fullpath)
+		copyContent, _ := ioutil.ReadFile(fullpath)
 		assert.Equal(t, content, copyContent)
 	}
 

api/archive/zip.go

@@ -4,12 +4,12 @@ import (
 	"archive/zip"
 	"bytes"
 	"fmt"
+	"github.com/pkg/errors"
 	"io"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
-
-	"github.com/pkg/errors"
 )
 
 // UnzipArchive will unzip an archive from bytes into the dest destination folder on disk
@@ -36,7 +36,7 @@ func extractFileFromArchive(file *zip.File, dest string) error {
 	}
 	defer f.Close()
 
-	data, err := io.ReadAll(f)
+	data, err := ioutil.ReadAll(f)
 	if err != nil {
 		return err
 	}

api/archive/zip_test.go

@@ -1,14 +1,17 @@
 package archive
 
 import (
+	"github.com/stretchr/testify/assert"
+	"io/ioutil"
+	"os"
 	"path/filepath"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestUnzipFile(t *testing.T) {
-	dir := t.TempDir()
+	dir, err := ioutil.TempDir("", "unzip-test-")
+	assert.NoError(t, err)
+	defer os.RemoveAll(dir)
 	/*
 		Archive structure.
 		├── 0
@@ -18,7 +21,7 @@ func TestUnzipFile(t *testing.T) {
 		└── 0.txt
 	*/
 
-	err := UnzipFile("./testdata/sample_archive.zip", dir)
+	err = UnzipFile("./testdata/sample_archive.zip", dir)
 
 	assert.NoError(t, err)
 	archiveDir := dir + "/sample_archive"

api/backup/backup.go

@@ -7,14 +7,13 @@ import (
 	"path/filepath"
 	"time"
 
+	"github.com/pkg/errors"
 	"github.com/portainer/portainer/api/archive"
 	"github.com/portainer/portainer/api/crypto"
 	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/filesystem"
 	"github.com/portainer/portainer/api/http/offlinegate"
-
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const rwxr__r__ os.FileMode = 0744
@@ -48,9 +47,9 @@ func CreateBackupArchive(password string, gate *offlinegate.OfflineGate, datasto
 
 		err := datastore.Export(exportFilename)
 		if err != nil {
-			log.Error().Err(err).Str("filename", exportFilename).Msg("failed to export")
+			logrus.WithError(err).Debugf("failed to export to %s", exportFilename)
 		} else {
-			log.Debug().Str("filename", exportFilename).Msg("file exported")
+			logrus.Debugf("exported to %s", exportFilename)
 		}
 	}
 

api/backup/restore.go

@@ -3,10 +3,8 @@ package backup
 import (
 	"context"
 	"io"
-	"io/fs"
 	"os"
 	"path/filepath"
-	"regexp"
 	"time"
 
 	"github.com/pkg/errors"
@@ -45,12 +43,6 @@ func RestoreArchive(archive io.Reader, password string, filestorePath string, ga
 		return errors.Wrap(err, "Failed to stop db")
 	}
 
-	// At some point, backups were created containing a subdirectory, now we need to handle both
-	restorePath, err = getRestoreSourcePath(restorePath)
-	if err != nil {
-		return errors.Wrap(err, "failed to restore from backup. Portainer database missing from backup file")
-	}
-
 	if err = restoreFiles(restorePath, filestorePath); err != nil {
 		return errors.Wrap(err, "failed to restore the system state")
 	}
@@ -67,26 +59,6 @@ func extractArchive(r io.Reader, destinationDirPath string) error {
 	return archive.ExtractTarGz(r, destinationDirPath)
 }
 
-func getRestoreSourcePath(dir string) (string, error) {
-	// find portainer.db or portainer.edb file. Return the parent directory
-	var portainerdbRegex = regexp.MustCompile(`^portainer.e?db$`)
-
-	backupDirPath := dir
-	err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-
-		if portainerdbRegex.MatchString(d.Name()) {
-			backupDirPath = filepath.Dir(path)
-			return filepath.SkipDir
-		}
-		return nil
-	})
-
-	return backupDirPath, err
-}
-
 func restoreFiles(srcDir string, destinationDir string) error {
 	for _, filename := range filesToRestore {
 		err := filesystem.CopyPath(filepath.Join(srcDir, filename), destinationDir)

api/build/variables.go

@@ -1,9 +0,0 @@
-package build
-
-// Variables to be set during the build time
-var BuildNumber string
-var ImageTag string
-var NodejsVersion string
-var YarnVersion string
-var WebpackVersion string
-var GoVersion string

api/chisel/schedules.go

@@ -1,18 +1,16 @@
 package chisel
 
 import (
+	"github.com/portainer/portainer/api/database"
+	"github.com/portainer/portainer/api/dataservices/edgejob"
+	"strconv"
+
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/edge/cache"
 )
 
 // AddEdgeJob register an EdgeJob inside the tunnel details associated to an environment(endpoint).
-func (service *Service) AddEdgeJob(endpoint *portainer.Endpoint, edgeJob *portainer.EdgeJob) {
-	if endpoint.Edge.AsyncMode {
-		return
-	}
-
-	service.mu.Lock()
-	tunnel := service.getTunnelDetails(endpoint.ID)
+func (service *Service) AddEdgeJob(endpointID database.EndpointID, edgeJob *edgejob.EdgeJob) {
+	tunnel := service.GetTunnelDetails(endpointID)
 
 	existingJobIndex := -1
 	for idx, existingJob := range tunnel.Jobs {
@@ -28,47 +26,24 @@ func (service *Service) AddEdgeJob(endpoint *portainer.Endpoint, edgeJob *portai
 		tunnel.Jobs[existingJobIndex] = *edgeJob
 	}
 
-	cache.Del(endpoint.ID)
-
-	service.mu.Unlock()
+	key := strconv.Itoa(int(endpointID))
+	service.tunnelDetailsMap.Set(key, tunnel)
 }
 
 // RemoveEdgeJob will remove the specified Edge job from each tunnel it was registered with.
-func (service *Service) RemoveEdgeJob(edgeJobID portainer.EdgeJobID) {
-	service.mu.Lock()
+func (service *Service) RemoveEdgeJob(edgeJobID edgejob.EdgeJobID) {
+	for item := range service.tunnelDetailsMap.IterBuffered() {
+		tunnelDetails := item.Val.(*portainer.TunnelDetails)
 
-	for endpointID, tunnel := range service.tunnelDetailsMap {
-		n := 0
-		for _, edgeJob := range tunnel.Jobs {
-			if edgeJob.ID != edgeJobID {
-				tunnel.Jobs[n] = edgeJob
-				n++
+		updatedJobs := make([]edgejob.EdgeJob, 0)
+		for _, edgeJob := range tunnelDetails.Jobs {
+			if edgeJob.ID == edgeJobID {
+				continue
 			}
+			updatedJobs = append(updatedJobs, edgeJob)
 		}
 
-		tunnel.Jobs = tunnel.Jobs[:n]
-
-		cache.Del(endpointID)
+		tunnelDetails.Jobs = updatedJobs
+		service.tunnelDetailsMap.Set(item.Key, tunnelDetails)
 	}
-
-	service.mu.Unlock()
-}
-
-func (service *Service) RemoveEdgeJobFromEndpoint(endpointID portainer.EndpointID, edgeJobID portainer.EdgeJobID) {
-	service.mu.Lock()
-	tunnel := service.getTunnelDetails(endpointID)
-
-	n := 0
-	for _, edgeJob := range tunnel.Jobs {
-		if edgeJob.ID != edgeJobID {
-			tunnel.Jobs[n] = edgeJob
-			n++
-		}
-	}
-
-	tunnel.Jobs = tunnel.Jobs[:n]
-
-	cache.Del(endpointID)
-
-	service.mu.Unlock()
 }

api/chisel/service.go

@@ -3,17 +3,18 @@ package chisel
 import (
 	"context"
 	"fmt"
-	"net/http"
-	"sync"
-	"time"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/dataservices"
+	"github.com/portainer/portainer/api/database"
 	"github.com/portainer/portainer/api/http/proxy"
+	"log"
+	"net/http"
+	"strconv"
+	"time"
 
 	"github.com/dchest/uniuri"
 	chserver "github.com/jpillora/chisel/server"
-	"github.com/rs/zerolog/log"
+	cmap "github.com/orcaman/concurrent-map"
+	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/dataservices"
 )
 
 const (
@@ -28,26 +29,25 @@ const (
 type Service struct {
 	serverFingerprint string
 	serverPort        string
-	tunnelDetailsMap  map[portainer.EndpointID]*portainer.TunnelDetails
+	tunnelDetailsMap  cmap.ConcurrentMap
 	dataStore         dataservices.DataStore
 	snapshotService   portainer.SnapshotService
 	chiselServer      *chserver.Server
 	shutdownCtx       context.Context
 	ProxyManager      *proxy.Manager
-	mu                sync.Mutex
 }
 
 // NewService returns a pointer to a new instance of Service
 func NewService(dataStore dataservices.DataStore, shutdownCtx context.Context) *Service {
 	return &Service{
-		tunnelDetailsMap: make(map[portainer.EndpointID]*portainer.TunnelDetails),
+		tunnelDetailsMap: cmap.New(),
 		dataStore:        dataStore,
 		shutdownCtx:      shutdownCtx,
 	}
 }
 
 // pingAgent ping the given agent so that the agent can keep the tunnel alive
-func (service *Service) pingAgent(endpointID portainer.EndpointID) error {
+func (service *Service) pingAgent(endpointID database.EndpointID) error {
 	tunnel := service.GetTunnelDetails(endpointID)
 	requestURL := fmt.Sprintf("http://127.0.0.1:%d/ping", tunnel.Port)
 	req, err := http.NewRequest(http.MethodHead, requestURL, nil)
@@ -59,17 +59,17 @@ func (service *Service) pingAgent(endpointID portainer.EndpointID) error {
 		Timeout: 3 * time.Second,
 	}
 	_, err = httpClient.Do(req)
-	return err
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // KeepTunnelAlive keeps the tunnel of the given environment for maxAlive duration, or until ctx is done
-func (service *Service) KeepTunnelAlive(endpointID portainer.EndpointID, ctx context.Context, maxAlive time.Duration) {
+func (service *Service) KeepTunnelAlive(endpointID database.EndpointID, ctx context.Context, maxAlive time.Duration) {
 	go func() {
-		log.Debug().
-			Int("endpoint_id", int(endpointID)).
-			Float64("max_alive_minutes", maxAlive.Minutes()).
-			Msg("start")
-
+		log.Printf("[DEBUG] [chisel,KeepTunnelAlive] [endpoint_id: %d] [message: start for %.0f minutes]\n", endpointID, maxAlive.Minutes())
 		maxAliveTicker := time.NewTicker(maxAlive)
 		defer maxAliveTicker.Stop()
 		pingTicker := time.NewTicker(tunnelCleanupInterval)
@@ -81,25 +81,14 @@ func (service *Service) KeepTunnelAlive(endpointID portainer.EndpointID, ctx con
 				service.SetTunnelStatusToActive(endpointID)
 				err := service.pingAgent(endpointID)
 				if err != nil {
-					log.Debug().
-						Int("endpoint_id", int(endpointID)).
-						Err(err).
-						Msg("ping agent")
+					log.Printf("[DEBUG] [chisel,KeepTunnelAlive] [endpoint_id: %d] [warning: ping agent err=%s]\n", endpointID, err)
 				}
 			case <-maxAliveTicker.C:
-				log.Debug().
-					Int("endpoint_id", int(endpointID)).
-					Float64("timeout_minutes", maxAlive.Minutes()).
-					Msg("tunnel keep alive timeout")
-
+				log.Printf("[DEBUG] [chisel,KeepTunnelAlive] [endpoint_id: %d] [message: stop as %.0f minutes timeout]\n", endpointID, maxAlive.Minutes())
 				return
 			case <-ctx.Done():
 				err := ctx.Err()
-				log.Debug().
-					Int("endpoint_id", int(endpointID)).
-					Err(err).
-					Msg("tunnel stop")
-
+				log.Printf("[DEBUG] [chisel,KeepTunnelAlive] [endpoint_id: %d] [message: stop as err=%s]\n", endpointID, err)
 				return
 			}
 		}
@@ -178,10 +167,7 @@ func (service *Service) retrievePrivateKeySeed() (string, error) {
 }
 
 func (service *Service) startTunnelVerificationLoop() {
-	log.Debug().
-		Float64("check_interval_seconds", tunnelCleanupInterval.Seconds()).
-		Msg("starting tunnel management process")
-
+	log.Printf("[DEBUG] [chisel, monitoring] [check_interval_seconds: %f] [message: starting tunnel management process]", tunnelCleanupInterval.Seconds())
 	ticker := time.NewTicker(tunnelCleanupInterval)
 
 	for {
@@ -189,12 +175,10 @@ func (service *Service) startTunnelVerificationLoop() {
 		case <-ticker.C:
 			service.checkTunnels()
 		case <-service.shutdownCtx.Done():
-			log.Debug().Msg("shutting down tunnel service")
-
+			log.Println("[DEBUG] Shutting down tunnel service")
 			if err := service.StopTunnelServer(); err != nil {
-				log.Debug().Err(err).Msg("stopped tunnel service")
+				log.Printf("Stopped tunnel service: %s", err)
 			}
-
 			ticker.Stop()
 			return
 		}
@@ -202,65 +186,49 @@ func (service *Service) startTunnelVerificationLoop() {
 }
 
 func (service *Service) checkTunnels() {
-	tunnels := make(map[portainer.EndpointID]portainer.TunnelDetails)
+	for item := range service.tunnelDetailsMap.IterBuffered() {
+		tunnel := item.Val.(*portainer.TunnelDetails)
 
-	service.mu.Lock()
-	for key, tunnel := range service.tunnelDetailsMap {
 		if tunnel.LastActivity.IsZero() || tunnel.Status == portainer.EdgeAgentIdle {
 			continue
 		}
 
-		if tunnel.Status == portainer.EdgeAgentManagementRequired && time.Since(tunnel.LastActivity) < requiredTimeout {
-			continue
-		}
-
-		if tunnel.Status == portainer.EdgeAgentActive && time.Since(tunnel.LastActivity) < activeTimeout {
-			continue
-		}
-
-		tunnels[key] = *tunnel
-	}
-	service.mu.Unlock()
-
-	for endpointID, tunnel := range tunnels {
 		elapsed := time.Since(tunnel.LastActivity)
-		log.Debug().
-			Int("endpoint_id", int(endpointID)).
-			Str("status", tunnel.Status).
-			Float64("status_time_seconds", elapsed.Seconds()).
-			Msg("environment tunnel monitoring")
+		log.Printf("[DEBUG] [chisel,monitoring] [endpoint_id: %s] [status: %s] [status_time_seconds: %f] [message: environment tunnel monitoring]", item.Key, tunnel.Status, elapsed.Seconds())
 
-		if tunnel.Status == portainer.EdgeAgentManagementRequired && elapsed > requiredTimeout {
-			log.Debug().
-				Int("endpoint_id", int(endpointID)).
-				Str("status", tunnel.Status).
-				Float64("status_time_seconds", elapsed.Seconds()).
-				Float64("timeout_seconds", requiredTimeout.Seconds()).
-				Msg("REQUIRED state timeout exceeded")
+		if tunnel.Status == portainer.EdgeAgentManagementRequired && elapsed.Seconds() < requiredTimeout.Seconds() {
+			continue
+		} else if tunnel.Status == portainer.EdgeAgentManagementRequired && elapsed.Seconds() > requiredTimeout.Seconds() {
+			log.Printf("[DEBUG] [chisel,monitoring] [endpoint_id: %s] [status: %s] [status_time_seconds: %f] [timeout_seconds: %f] [message: REQUIRED state timeout exceeded]", item.Key, tunnel.Status, elapsed.Seconds(), requiredTimeout.Seconds())
 		}
 
-		if tunnel.Status == portainer.EdgeAgentActive && elapsed > activeTimeout {
-			log.Debug().
-				Int("endpoint_id", int(endpointID)).
-				Str("status", tunnel.Status).
-				Float64("status_time_seconds", elapsed.Seconds()).
-				Float64("timeout_seconds", activeTimeout.Seconds()).
-				Msg("ACTIVE state timeout exceeded")
+		if tunnel.Status == portainer.EdgeAgentActive && elapsed.Seconds() < activeTimeout.Seconds() {
+			continue
+		} else if tunnel.Status == portainer.EdgeAgentActive && elapsed.Seconds() > activeTimeout.Seconds() {
+			log.Printf("[DEBUG] [chisel,monitoring] [endpoint_id: %s] [status: %s] [status_time_seconds: %f] [timeout_seconds: %f] [message: ACTIVE state timeout exceeded]", item.Key, tunnel.Status, elapsed.Seconds(), activeTimeout.Seconds())
 
-			err := service.snapshotEnvironment(endpointID, tunnel.Port)
+			endpointID, err := strconv.Atoi(item.Key)
 			if err != nil {
-				log.Error().
-					Int("endpoint_id", int(endpointID)).
-					Err(err).
-					Msg("unable to snapshot Edge environment")
+				log.Printf("[ERROR] [chisel,snapshot,conversion] Invalid environment identifier (id: %s): %s", item.Key, err)
+			}
+
+			err = service.snapshotEnvironment(database.EndpointID(endpointID), tunnel.Port)
+			if err != nil {
+				log.Printf("[ERROR] [snapshot] Unable to snapshot Edge environment (id: %s): %s", item.Key, err)
 			}
 		}
 
-		service.SetTunnelStatusToIdle(portainer.EndpointID(endpointID))
+		endpointID, err := strconv.Atoi(item.Key)
+		if err != nil {
+			log.Printf("[ERROR] [chisel,conversion] Invalid environment identifier (id: %s): %s", item.Key, err)
+			continue
+		}
+
+		service.SetTunnelStatusToIdle(database.EndpointID(endpointID))
 	}
 }
 
-func (service *Service) snapshotEnvironment(endpointID portainer.EndpointID, tunnelPort int) error {
+func (service *Service) snapshotEnvironment(endpointID database.EndpointID, tunnelPort int) error {
 	endpoint, err := service.dataStore.Endpoint().Endpoint(endpointID)
 	if err != nil {
 		return err

api/chisel/tunnel.go

@@ -2,17 +2,18 @@ package chisel
 
 import (
 	"encoding/base64"
-	"errors"
 	"fmt"
+	"github.com/portainer/portainer/api/database"
+	"github.com/portainer/portainer/api/dataservices/edgejob"
 	"math/rand"
+	"strconv"
 	"strings"
 	"time"
 
 	"github.com/portainer/libcrypto"
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/edge/cache"
 
 	"github.com/dchest/uniuri"
+	portainer "github.com/portainer/portainer/api"
 )
 
 const (
@@ -20,13 +21,13 @@ const (
 	maxAvailablePort = 65535
 )
 
-// NOTE: it needs to be called with the lock acquired
 // getUnusedPort is used to generate an unused random port in the dynamic port range.
 // Dynamic ports (also called private ports) are 49152 to 65535.
 func (service *Service) getUnusedPort() int {
 	port := randomInt(minAvailablePort, maxAvailablePort)
 
-	for _, tunnel := range service.tunnelDetailsMap {
+	for item := range service.tunnelDetailsMap.IterBuffered() {
+		tunnel := item.Val.(*portainer.TunnelDetails)
 		if tunnel.Port == port {
 			return service.getUnusedPort()
 		}
@@ -39,38 +40,26 @@ func randomInt(min, max int) int {
 	return min + rand.Intn(max-min)
 }
 
-// NOTE: it needs to be called with the lock acquired
-func (service *Service) getTunnelDetails(endpointID portainer.EndpointID) *portainer.TunnelDetails {
-
-	if tunnel, ok := service.tunnelDetailsMap[endpointID]; ok {
-		return tunnel
-	}
-
-	tunnel := &portainer.TunnelDetails{
-		Status: portainer.EdgeAgentIdle,
-	}
-
-	service.tunnelDetailsMap[endpointID] = tunnel
-
-	cache.Del(endpointID)
-
-	return tunnel
-}
-
 // GetTunnelDetails returns information about the tunnel associated to an environment(endpoint).
-func (service *Service) GetTunnelDetails(endpointID portainer.EndpointID) portainer.TunnelDetails {
-	service.mu.Lock()
-	defer service.mu.Unlock()
+func (service *Service) GetTunnelDetails(endpointID database.EndpointID) *portainer.TunnelDetails {
+	key := strconv.Itoa(int(endpointID))
 
-	return *service.getTunnelDetails(endpointID)
+	if item, ok := service.tunnelDetailsMap.Get(key); ok {
+		tunnelDetails := item.(*portainer.TunnelDetails)
+		return tunnelDetails
+	}
+
+	jobs := make([]edgejob.EdgeJob, 0)
+	return &portainer.TunnelDetails{
+		Status:      portainer.EdgeAgentIdle,
+		Port:        0,
+		Jobs:        jobs,
+		Credentials: "",
+	}
 }
 
 // GetActiveTunnel retrieves an active tunnel which allows communicating with edge agent
-func (service *Service) GetActiveTunnel(endpoint *portainer.Endpoint) (portainer.TunnelDetails, error) {
-	if endpoint.Edge.AsyncMode {
-		return portainer.TunnelDetails{}, errors.New("cannot open tunnel on async endpoint")
-	}
-
+func (service *Service) GetActiveTunnel(endpoint *portainer.Endpoint) (*portainer.TunnelDetails, error) {
 	tunnel := service.GetTunnelDetails(endpoint.ID)
 
 	if tunnel.Status == portainer.EdgeAgentActive {
@@ -81,13 +70,13 @@ func (service *Service) GetActiveTunnel(endpoint *portainer.Endpoint) (portainer
 	if tunnel.Status == portainer.EdgeAgentIdle || tunnel.Status == portainer.EdgeAgentManagementRequired {
 		err := service.SetTunnelStatusToRequired(endpoint.ID)
 		if err != nil {
-			return portainer.TunnelDetails{}, fmt.Errorf("failed opening tunnel to endpoint: %w", err)
+			return nil, fmt.Errorf("failed opening tunnel to endpoint: %w", err)
 		}
 
 		if endpoint.EdgeCheckinInterval == 0 {
 			settings, err := service.dataStore.Settings().Settings()
 			if err != nil {
-				return portainer.TunnelDetails{}, fmt.Errorf("failed fetching settings from db: %w", err)
+				return nil, fmt.Errorf("failed fetching settings from db: %w", err)
 			}
 
 			endpoint.EdgeCheckinInterval = settings.EdgeAgentCheckinInterval
@@ -96,29 +85,29 @@ func (service *Service) GetActiveTunnel(endpoint *portainer.Endpoint) (portainer
 		time.Sleep(2 * time.Duration(endpoint.EdgeCheckinInterval) * time.Second)
 	}
 
-	return service.GetTunnelDetails(endpoint.ID), nil
+	tunnel = service.GetTunnelDetails(endpoint.ID)
+
+	return tunnel, nil
 }
 
 // SetTunnelStatusToActive update the status of the tunnel associated to the specified environment(endpoint).
 // It sets the status to ACTIVE.
-func (service *Service) SetTunnelStatusToActive(endpointID portainer.EndpointID) {
-	service.mu.Lock()
-	tunnel := service.getTunnelDetails(endpointID)
+func (service *Service) SetTunnelStatusToActive(endpointID database.EndpointID) {
+	tunnel := service.GetTunnelDetails(endpointID)
 	tunnel.Status = portainer.EdgeAgentActive
 	tunnel.Credentials = ""
 	tunnel.LastActivity = time.Now()
-	service.mu.Unlock()
 
-	cache.Del(endpointID)
+	key := strconv.Itoa(int(endpointID))
+	service.tunnelDetailsMap.Set(key, tunnel)
 }
 
 // SetTunnelStatusToIdle update the status of the tunnel associated to the specified environment(endpoint).
 // It sets the status to IDLE.
 // It removes any existing credentials associated to the tunnel.
-func (service *Service) SetTunnelStatusToIdle(endpointID portainer.EndpointID) {
-	service.mu.Lock()
+func (service *Service) SetTunnelStatusToIdle(endpointID database.EndpointID) {
+	tunnel := service.GetTunnelDetails(endpointID)
 
-	tunnel := service.getTunnelDetails(endpointID)
 	tunnel.Status = portainer.EdgeAgentIdle
 	tunnel.Port = 0
 	tunnel.LastActivity = time.Now()
@@ -129,11 +118,10 @@ func (service *Service) SetTunnelStatusToIdle(endpointID portainer.EndpointID) {
 		service.chiselServer.DeleteUser(strings.Split(credentials, ":")[0])
 	}
 
+	key := strconv.Itoa(int(endpointID))
+	service.tunnelDetailsMap.Set(key, tunnel)
+
 	service.ProxyManager.DeleteEndpointProxy(endpointID)
-
-	service.mu.Unlock()
-
-	cache.Del(endpointID)
 }
 
 // SetTunnelStatusToRequired update the status of the tunnel associated to the specified environment(endpoint).
@@ -141,13 +129,8 @@ func (service *Service) SetTunnelStatusToIdle(endpointID portainer.EndpointID) {
 // If no port is currently associated to the tunnel, it will associate a random unused port to the tunnel
 // and generate temporary credentials that can be used to establish a reverse tunnel on that port.
 // Credentials are encrypted using the Edge ID associated to the environment(endpoint).
-func (service *Service) SetTunnelStatusToRequired(endpointID portainer.EndpointID) error {
-	defer cache.Del(endpointID)
-
-	tunnel := service.getTunnelDetails(endpointID)
-
-	service.mu.Lock()
-	defer service.mu.Unlock()
+func (service *Service) SetTunnelStatusToRequired(endpointID database.EndpointID) error {
+	tunnel := service.GetTunnelDetails(endpointID)
 
 	if tunnel.Port == 0 {
 		endpoint, err := service.dataStore.Endpoint().Endpoint(endpointID)
@@ -171,6 +154,9 @@ func (service *Service) SetTunnelStatusToRequired(endpointID portainer.EndpointI
 			return err
 		}
 		tunnel.Credentials = credentials
+
+		key := strconv.Itoa(int(endpointID))
+		service.tunnelDetailsMap.Set(key, tunnel)
 	}
 
 	return nil

api/cli/cli.go

@@ -2,14 +2,15 @@ package cli
 
 import (
 	"errors"
-	"os"
-	"path/filepath"
-	"strings"
+	"log"
 	"time"
 
 	portainer "github.com/portainer/portainer/api"
 
-	"github.com/rs/zerolog/log"
+	"os"
+	"path/filepath"
+	"strings"
+
 	"gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -34,9 +35,8 @@ func (*Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
 		TunnelPort:                kingpin.Flag("tunnel-port", "Port to serve the tunnel server").Default(defaultTunnelServerPort).String(),
 		Assets:                    kingpin.Flag("assets", "Path to the assets").Default(defaultAssetsDirectory).Short('a').String(),
 		Data:                      kingpin.Flag("data", "Path to the folder where the data is stored").Default(defaultDataDirectory).Short('d').String(),
-		DemoEnvironment:           kingpin.Flag("demo", "Demo environment").Bool(),
 		EndpointURL:               kingpin.Flag("host", "Environment URL").Short('H').String(),
-		FeatureFlags:              kingpin.Flag("feat", "List of feature flags").Strings(),
+		FeatureFlags:              BoolPairs(kingpin.Flag("feat", "List of feature flags").Hidden()),
 		EnableEdgeComputeFeatures: kingpin.Flag("edge-compute", "Enable Edge Compute features").Bool(),
 		NoAnalytics:               kingpin.Flag("no-analytics", "Disable Analytics in app (deprecated)").Bool(),
 		TLS:                       kingpin.Flag("tlsverify", "TLS support").Default(defaultTLS).Bool(),
@@ -51,7 +51,7 @@ func (*Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
 		SSLKey:                    kingpin.Flag("sslkey", "Path to the SSL key used to secure the Portainer instance").String(),
 		Rollback:                  kingpin.Flag("rollback", "Rollback the database store to the previous version").Bool(),
 		SnapshotInterval:          kingpin.Flag("snapshot-interval", "Duration between each environment snapshot job").String(),
-		AdminPassword:             kingpin.Flag("admin-password", "Set admin password with provided hash").String(),
+		AdminPassword:             kingpin.Flag("admin-password", "Hashed admin password").String(),
 		AdminPasswordFile:         kingpin.Flag("admin-password-file", "Path to the file containing the password for the admin user").String(),
 		Labels:                    pairs(kingpin.Flag("hide-label", "Hide containers with a specific label in the UI").Short('l')),
 		Logo:                      kingpin.Flag("logo", "URL for the logo displayed in the UI").String(),
@@ -61,8 +61,6 @@ func (*Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
 		MaxBatchSize:              kingpin.Flag("max-batch-size", "Maximum size of a batch").Int(),
 		MaxBatchDelay:             kingpin.Flag("max-batch-delay", "Maximum delay before a batch starts").Duration(),
 		SecretKeyName:             kingpin.Flag("secret-key-name", "Secret key name for encryption and will be used as /run/secrets/<secret-key-name>.").Default(defaultSecretKeyName).String(),
-		LogLevel:                  kingpin.Flag("log-level", "Set the minimum logging level to show").Default("INFO").Enum("DEBUG", "INFO", "WARN", "ERROR"),
-		LogMode:                   kingpin.Flag("log-mode", "Set the logging output mode").Default("PRETTY").Enum("PRETTY", "JSON"),
 	}
 
 	kingpin.Parse()
@@ -102,11 +100,11 @@ func (*Service) ValidateFlags(flags *portainer.CLIFlags) error {
 
 func displayDeprecationWarnings(flags *portainer.CLIFlags) {
 	if *flags.NoAnalytics {
-		log.Warn().Msg("the --no-analytics flag has been kept to allow migration of instances running a previous version of Portainer with this flag enabled, to version 2.0 where enabling this flag will have no effect")
+		log.Println("Warning: The --no-analytics flag has been kept to allow migration of instances running a previous version of Portainer with this flag enabled, to version 2.0 where enabling this flag will have no effect.")
 	}
 
 	if *flags.SSL {
-		log.Warn().Msg("SSL is enabled by default and there is no need for the --ssl flag, it has been kept to allow migration of instances running a previous version of Portainer with this flag enabled")
+		log.Println("Warning: SSL is enabled by default and there is no need for the --ssl flag. It has been kept to allow migration of instances running a previous version of Portainer with this flag enabled")
 	}
 }
 

api/cli/confirm.go

@@ -2,14 +2,14 @@ package cli
 
 import (
 	"bufio"
-	"fmt"
+	"log"
 	"os"
 	"strings"
 )
 
 // Confirm starts a rollback db cli application
 func Confirm(message string) (bool, error) {
-	fmt.Printf("%s [y/N]", message)
+	log.Printf("%s [y/N]", message)
 
 	reader := bufio.NewReader(os.Stdin)
 	answer, err := reader.ReadString('\n')

api/cli/defaults.go

@@ -18,6 +18,8 @@ const (
 	defaultHTTPDisabled        = "false"
 	defaultHTTPEnabled         = "false"
 	defaultSSL                 = "false"
+	defaultSSLCertPath         = "/certs/portainer.crt"
+	defaultSSLKeyPath          = "/certs/portainer.key"
 	defaultBaseURL             = "/"
 	defaultSecretKeyName       = "portainer"
 )

api/cli/defaults_windows.go

@@ -15,6 +15,8 @@ const (
 	defaultHTTPDisabled        = "false"
 	defaultHTTPEnabled         = "false"
 	defaultSSL                 = "false"
+	defaultSSLCertPath         = "C:\\certs\\portainer.crt"
+	defaultSSLKeyPath          = "C:\\certs\\portainer.key"
 	defaultSnapshotInterval    = "5m"
 	defaultBaseURL             = "/"
 	defaultSecretKeyName       = "portainer"

api/cli/pairlistbool.go

@@ -1,10 +1,10 @@
 package cli
 
 import (
-	"strings"
-
 	portainer "github.com/portainer/portainer/api"
 
+	"strings"
+
 	"gopkg.in/alecthomas/kingpin.v2"
 )
 

api/cmd/portainer/import.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"log"
+
+	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/datastore"
+	"github.com/sirupsen/logrus"
+)
+
+func importFromJson(fileService portainer.FileService, store *datastore.Store) {
+	// EXPERIMENTAL - if used with an incomplete json file, it will fail, as we don't have a way to default the model values
+	importFile := "/data/import.json"
+	if exists, _ := fileService.FileExists(importFile); exists {
+		if err := store.Import(importFile); err != nil {
+			logrus.WithError(err).Debugf("Import %s failed", importFile)
+
+			// TODO: should really rollback on failure, but then we have nothing.
+		} else {
+			logrus.Printf("Successfully imported %s to new portainer database", importFile)
+		}
+		// TODO: this is bad - its to ensure that any defaults that were broken in import, or migrations get set back to what we want
+		// I also suspect that everything from "Init to Init" is potentially a migration
+		err := store.Init()
+		if err != nil {
+			log.Fatalf("Failed initializing data store: %v", err)
+		}
+	}
+}

api/cmd/portainer/log.go

@@ -2,54 +2,41 @@ package main
 
 import (
 	"fmt"
-	stdlog "log"
-	"os"
+	"log"
+	"strings"
 
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-	"github.com/rs/zerolog/pkgerrors"
+	"github.com/sirupsen/logrus"
 )
 
+type portainerFormatter struct {
+	logrus.TextFormatter
+}
+
+func (f *portainerFormatter) Format(entry *logrus.Entry) ([]byte, error) {
+	var levelColor int
+	switch entry.Level {
+	case logrus.DebugLevel, logrus.TraceLevel:
+		levelColor = 31 // gray
+	case logrus.WarnLevel:
+		levelColor = 33 // yellow
+	case logrus.ErrorLevel, logrus.FatalLevel, logrus.PanicLevel:
+		levelColor = 31 // red
+	default:
+		levelColor = 36 // blue
+	}
+	return []byte(fmt.Sprintf("\x1b[%dm%s\x1b[0m %s %s\n", levelColor, strings.ToUpper(entry.Level.String()), entry.Time.Format(f.TimestampFormat), entry.Message)), nil
+}
+
 func configureLogger() {
-	zerolog.ErrorStackFieldName = "stack_trace"
-	zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
-	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+	logger := logrus.New() // logger is to implicitly substitute stdlib's log
+	log.SetOutput(logger.Writer())
 
-	stdlog.SetFlags(0)
-	stdlog.SetOutput(log.Logger)
+	formatter := &logrus.TextFormatter{DisableTimestamp: true, DisableLevelTruncation: true}
+	formatterLogrus := &portainerFormatter{logrus.TextFormatter{DisableTimestamp: false, DisableLevelTruncation: true, TimestampFormat: "2006/01/02 15:04:05", FullTimestamp: true}}
 
-	log.Logger = log.Logger.With().Caller().Stack().Logger()
-}
-
-func setLoggingLevel(level string) {
-	switch level {
-	case "ERROR":
-		zerolog.SetGlobalLevel(zerolog.ErrorLevel)
-	case "WARN":
-		zerolog.SetGlobalLevel(zerolog.WarnLevel)
-	case "INFO":
-		zerolog.SetGlobalLevel(zerolog.InfoLevel)
-	case "DEBUG":
-		zerolog.SetGlobalLevel(zerolog.DebugLevel)
-	}
-}
-
-func setLoggingMode(mode string) {
-	switch mode {
-	case "PRETTY":
-		log.Logger = log.Output(zerolog.ConsoleWriter{
-			Out:           os.Stderr,
-			NoColor:       true,
-			TimeFormat:    "2006/01/02 03:04PM",
-			FormatMessage: formatMessage})
-	case "JSON":
-		log.Logger = log.Output(os.Stderr)
-	}
-}
-
-func formatMessage(i interface{}) string {
-	if i == nil {
-		return ""
-	}
-	return fmt.Sprintf("%s |", i)
+	logger.SetFormatter(formatter)
+	logrus.SetFormatter(formatterLogrus)
+
+	logger.SetLevel(logrus.DebugLevel)
+	logrus.SetLevel(logrus.DebugLevel)
 }

api/cmd/portainer/main.go

@@ -3,27 +3,30 @@ package main
 import (
 	"context"
 	"crypto/sha256"
-	"math/rand"
+	"fmt"
+	docker2 "github.com/portainer/portainer/api/orchestrators/docker"
+	kubernetes2 "github.com/portainer/portainer/api/orchestrators/kubernetes"
+	kubecli "github.com/portainer/portainer/api/orchestrators/kubernetes/cli"
+	"github.com/portainer/portainer/api/orchestrators/snapshot"
+	"log"
 	"os"
 	"path"
+	"strconv"
 	"strings"
 	"time"
 
-	libstack "github.com/portainer/docker-compose-wrapper"
-	"github.com/portainer/docker-compose-wrapper/compose"
+	"github.com/sirupsen/logrus"
+
+	"github.com/portainer/libhelm"
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/apikey"
-	"github.com/portainer/portainer/api/build"
 	"github.com/portainer/portainer/api/chisel"
 	"github.com/portainer/portainer/api/cli"
 	"github.com/portainer/portainer/api/crypto"
 	"github.com/portainer/portainer/api/database"
 	"github.com/portainer/portainer/api/database/boltdb"
-	"github.com/portainer/portainer/api/database/models"
 	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/datastore"
-	"github.com/portainer/portainer/api/demo"
-	"github.com/portainer/portainer/api/docker"
 	"github.com/portainer/portainer/api/exec"
 	"github.com/portainer/portainer/api/filesystem"
 	"github.com/portainer/portainer/api/git"
@@ -34,52 +37,40 @@ import (
 	kubeproxy "github.com/portainer/portainer/api/http/proxy/factory/kubernetes"
 	"github.com/portainer/portainer/api/internal/authorization"
 	"github.com/portainer/portainer/api/internal/edge"
-	"github.com/portainer/portainer/api/internal/edge/edgestacks"
-	"github.com/portainer/portainer/api/internal/snapshot"
 	"github.com/portainer/portainer/api/internal/ssl"
-	"github.com/portainer/portainer/api/internal/upgrade"
 	"github.com/portainer/portainer/api/jwt"
-	"github.com/portainer/portainer/api/kubernetes"
-	kubecli "github.com/portainer/portainer/api/kubernetes/cli"
 	"github.com/portainer/portainer/api/ldap"
 	"github.com/portainer/portainer/api/oauth"
 	"github.com/portainer/portainer/api/scheduler"
-	"github.com/portainer/portainer/api/stacks/deployments"
-	"github.com/portainer/portainer/pkg/featureflags"
-	"github.com/portainer/portainer/pkg/libhelm"
-
-	"github.com/gofrs/uuid"
-	"github.com/rs/zerolog/log"
+	"github.com/portainer/portainer/api/stacks"
 )
 
 func initCLI() *portainer.CLIFlags {
 	var cliService portainer.CLIService = &cli.Service{}
 	flags, err := cliService.ParseFlags(portainer.APIVersion)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed parsing flags")
+		logrus.Fatalf("Failed parsing flags: %v", err)
 	}
 
 	err = cliService.ValidateFlags(flags)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed validating flags")
+		logrus.Fatalf("Failed validating flags:%v", err)
 	}
-
 	return flags
 }
 
 func initFileService(dataStorePath string) portainer.FileService {
 	fileService, err := filesystem.NewService(dataStorePath, "")
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed creating file service")
+		logrus.Fatalf("Failed creating file service: %v", err)
 	}
-
 	return fileService
 }
 
 func initDataStore(flags *portainer.CLIFlags, secretKey []byte, fileService portainer.FileService, shutdownCtx context.Context) dataservices.DataStore {
 	connection, err := database.NewDatabase("boltdb", *flags.Data, secretKey)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed creating database connection")
+		logrus.Fatalf("failed creating database connection: %s", err)
 	}
 
 	if bconn, ok := connection.(*boltdb.DbConnection); ok {
@@ -87,74 +78,80 @@ func initDataStore(flags *portainer.CLIFlags, secretKey []byte, fileService port
 		bconn.MaxBatchDelay = *flags.MaxBatchDelay
 		bconn.InitialMmapSize = *flags.InitialMmapSize
 	} else {
-		log.Fatal().Msg("failed creating database connection: expecting a boltdb database type but a different one was received")
+		logrus.Fatalf("failed creating database connection: expecting a boltdb database type but a different one was received")
 	}
 
 	store := datastore.NewStore(*flags.Data, fileService, connection)
 	isNew, err := store.Open()
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed opening store")
+		logrus.Fatalf("Failed opening store: %v", err)
 	}
 
 	if *flags.Rollback {
 		err := store.Rollback(false)
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed rolling back")
+			logrus.Fatalf("Failed rolling back: %v", err)
 		}
 
-		log.Info().Msg("exiting rollback")
+		logrus.Println("Exiting rollback")
 		os.Exit(0)
+		return nil
 	}
 
 	// Init sets some defaults - it's basically a migration
 	err = store.Init()
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing data store")
+		logrus.Fatalf("Failed initializing data store: %v", err)
 	}
 
 	if isNew {
-		instanceId, err := uuid.NewV4()
-		if err != nil {
-			log.Fatal().Err(err).Msg("failed generating instance id")
-		}
-
 		// from MigrateData
-		v := models.Version{
-			SchemaVersion: portainer.APIVersion,
-			Edition:       int(portainer.PortainerCE),
-			InstanceID:    instanceId.String(),
-		}
-		store.VersionService.UpdateVersion(&v)
+		store.VersionService.StoreDBVersion(portainer.DBVersion)
 
-		err = updateSettingsFromFlags(store, flags)
+		err := updateSettingsFromFlags(store, flags)
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed updating settings from flags")
+			logrus.Fatalf("Failed updating settings from flags: %v", err)
 		}
 	} else {
-		err = store.MigrateData()
+		storedVersion, err := store.VersionService.DBVersion()
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed migration")
+			logrus.Fatalf("Something Failed during creation of new database: %v", err)
+		}
+		if storedVersion != portainer.DBVersion {
+			err = store.MigrateData()
+			if err != nil {
+				logrus.Fatalf("Failed migration: %v", err)
+			}
 		}
 	}
 
 	err = updateSettingsFromFlags(store, flags)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed updating settings from flags")
+		log.Fatalf("Failed updating settings from flags: %v", err)
 	}
 
 	// this is for the db restore functionality - needs more tests.
 	go func() {
 		<-shutdownCtx.Done()
 		defer connection.Close()
-	}()
 
+		exportFilename := path.Join(*flags.Data, fmt.Sprintf("export-%d.json", time.Now().Unix()))
+
+		err := store.Export(exportFilename)
+		if err != nil {
+			logrus.WithError(err).Debugf("Failed to export to %s", exportFilename)
+		} else {
+			logrus.Debugf("exported to %s", exportFilename)
+		}
+		connection.Close()
+	}()
 	return store
 }
 
-func initComposeStackManager(composeDeployer libstack.Deployer, reverseTunnelService portainer.ReverseTunnelService, proxyManager *proxy.Manager) portainer.ComposeStackManager {
-	composeWrapper, err := exec.NewComposeStackManager(composeDeployer, proxyManager)
+func initComposeStackManager(assetsPath string, configPath string, reverseTunnelService portainer.ReverseTunnelService, proxyManager *proxy.Manager) portainer.ComposeStackManager {
+	composeWrapper, err := exec.NewComposeStackManager(assetsPath, configPath, proxyManager)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed creating compose manager")
+		logrus.Fatalf("Failed creating compose manager: %v", err)
 	}
 
 	return composeWrapper
@@ -184,15 +181,10 @@ func initAPIKeyService(datastore dataservices.DataStore) apikey.APIKeyService {
 }
 
 func initJWTService(userSessionTimeout string, dataStore dataservices.DataStore) (dataservices.JWTService, error) {
-	if userSessionTimeout == "" {
-		userSessionTimeout = portainer.DefaultUserSessionTimeout
-	}
-
 	jwtService, err := jwt.NewService(userSessionTimeout, dataStore)
 	if err != nil {
 		return nil, err
 	}
-
 	return jwtService, nil
 }
 
@@ -212,11 +204,11 @@ func initOAuthService() portainer.OAuthService {
 	return oauth.NewService()
 }
 
-func initGitService(ctx context.Context) portainer.GitService {
-	return git.NewService(ctx)
+func initGitService() portainer.GitService {
+	return git.NewService()
 }
 
-func initSSLService(addr, certPath, keyPath string, fileService portainer.FileService, dataStore dataservices.DataStore, shutdownTrigger context.CancelFunc) (*ssl.Service, error) {
+func initSSLService(addr, dataPath, certPath, keyPath string, fileService portainer.FileService, dataStore dataservices.DataStore, shutdownTrigger context.CancelFunc) (*ssl.Service, error) {
 	slices := strings.Split(addr, ":")
 	host := slices[0]
 	if host == "" {
@@ -233,25 +225,16 @@ func initSSLService(addr, certPath, keyPath string, fileService portainer.FileSe
 	return sslService, nil
 }
 
-func initDockerClientFactory(signatureService portainer.DigitalSignatureService, reverseTunnelService portainer.ReverseTunnelService) *docker.ClientFactory {
-	return docker.NewClientFactory(signatureService, reverseTunnelService)
+func initDockerClientFactory(signatureService portainer.DigitalSignatureService, reverseTunnelService portainer.ReverseTunnelService) *docker2.ClientFactory {
+	return docker2.NewClientFactory(signatureService, reverseTunnelService)
 }
 
-func initKubernetesClientFactory(signatureService portainer.DigitalSignatureService, reverseTunnelService portainer.ReverseTunnelService, dataStore dataservices.DataStore, instanceID, addrHTTPS, userSessionTimeout string) (*kubecli.ClientFactory, error) {
-	return kubecli.NewClientFactory(signatureService, reverseTunnelService, dataStore, instanceID, addrHTTPS, userSessionTimeout)
+func initKubernetesClientFactory(signatureService portainer.DigitalSignatureService, reverseTunnelService portainer.ReverseTunnelService, instanceID string, dataStore dataservices.DataStore) *kubecli.ClientFactory {
+	return kubecli.NewClientFactory(signatureService, reverseTunnelService, instanceID, dataStore)
 }
 
-func initSnapshotService(
-	snapshotIntervalFromFlag string,
-	dataStore dataservices.DataStore,
-	dockerClientFactory *docker.ClientFactory,
-	kubernetesClientFactory *kubecli.ClientFactory,
-	shutdownCtx context.Context,
-) (portainer.SnapshotService, error) {
-	dockerSnapshotter := docker.NewSnapshotter(dockerClientFactory)
-	kubernetesSnapshotter := kubernetes.NewSnapshotter(kubernetesClientFactory)
-
-	snapshotService, err := snapshot.NewService(snapshotIntervalFromFlag, dataStore, dockerSnapshotter, kubernetesSnapshotter, shutdownCtx)
+func initSnapshotService(snapshotIntervalFromFlag string, dataStore dataservices.DataStore, dockerClientFactory *docker2.ClientFactory, kubernetesClientFactory *kubecli.ClientFactory, shutdownCtx context.Context) (portainer.SnapshotService, error) {
+	snapshotService, err := snapshot.NewService(snapshotIntervalFromFlag, dataStore, dockerClientFactory, kubernetesClientFactory, shutdownCtx)
 	if err != nil {
 		return nil, err
 	}
@@ -292,12 +275,6 @@ func updateSettingsFromFlags(dataStore dataservices.DataStore, flags *portainer.
 		settings.BlackListedLabels = *flags.Labels
 	}
 
-	if agentKey, ok := os.LookupEnv("AGENT_SECRET"); ok {
-		settings.AgentSecret = agentKey
-	} else {
-		settings.AgentSecret = ""
-	}
-
 	err = dataStore.Settings().UpdateSettings(settings)
 	if err != nil {
 		return err
@@ -314,7 +291,55 @@ func updateSettingsFromFlags(dataStore dataservices.DataStore, flags *portainer.
 		sslSettings.HTTPEnabled = true
 	}
 
-	return dataStore.SSLSettings().UpdateSettings(sslSettings)
+	err = dataStore.SSLSettings().UpdateSettings(sslSettings)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// enableFeaturesFromFlags turns on or off feature flags
+// e.g.  portainer --feat open-amt --feat fdo=true ... (defaults to true)
+// note, settings are persisted to the DB. To turn off `--feat open-amt=false`
+func enableFeaturesFromFlags(dataStore dataservices.DataStore, flags *portainer.CLIFlags) error {
+	settings, err := dataStore.Settings().Settings()
+	if err != nil {
+		return err
+	}
+
+	if settings.FeatureFlagSettings == nil {
+		settings.FeatureFlagSettings = make(map[portainer.Feature]bool)
+	}
+
+	// loop through feature flags to check if they are supported
+	for _, feat := range *flags.FeatureFlags {
+		var correspondingFeature *portainer.Feature
+		for i, supportedFeat := range portainer.SupportedFeatureFlags {
+			if strings.EqualFold(feat.Name, string(supportedFeat)) {
+				correspondingFeature = &portainer.SupportedFeatureFlags[i]
+			}
+		}
+
+		if correspondingFeature == nil {
+			return fmt.Errorf("unknown feature flag '%s'", feat.Name)
+		}
+
+		featureState, err := strconv.ParseBool(feat.Value)
+		if err != nil {
+			return fmt.Errorf("feature flag's '%s' value should be true or false", feat.Name)
+		}
+
+		if featureState {
+			logrus.Printf("Feature %v : on", *correspondingFeature)
+		} else {
+			logrus.Printf("Feature %v : off", *correspondingFeature)
+		}
+
+		settings.FeatureFlagSettings[*correspondingFeature] = featureState
+	}
+
+	return dataStore.Settings().UpdateSettings(settings)
 }
 
 func loadAndParseKeyPair(fileService portainer.FileService, signatureService portainer.DigitalSignatureService) error {
@@ -337,7 +362,7 @@ func generateAndStoreKeyPair(fileService portainer.FileService, signatureService
 func initKeyPair(fileService portainer.FileService, signatureService portainer.DigitalSignatureService) error {
 	existingKeyPair, err := fileService.KeyPairFilesExist()
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed checking for existing key pair")
+		logrus.Fatalf("Failed checking for existing key pair: %v", err)
 	}
 
 	if existingKeyPair {
@@ -347,7 +372,7 @@ func initKeyPair(fileService portainer.FileService, signatureService portainer.D
 }
 
 func createTLSSecuredEndpoint(flags *portainer.CLIFlags, dataStore dataservices.DataStore, snapshotService portainer.SnapshotService) error {
-	tlsConfiguration := portainer.TLSConfiguration{
+	tlsConfiguration := database.TLSConfiguration{
 		TLS:           *flags.TLS,
 		TLSSkipVerify: *flags.TLSSkipVerify,
 	}
@@ -360,34 +385,11 @@ func createTLSSecuredEndpoint(flags *portainer.CLIFlags, dataStore dataservices.
 		tlsConfiguration.TLS = true
 	}
 
-	endpointID := dataStore.Endpoint().GetNextIdentifier()
-	endpoint := &portainer.Endpoint{
-		ID:                 portainer.EndpointID(endpointID),
-		Name:               "primary",
-		URL:                *flags.EndpointURL,
-		GroupID:            portainer.EndpointGroupID(1),
-		Type:               portainer.DockerEnvironment,
-		TLSConfig:          tlsConfiguration,
-		UserAccessPolicies: portainer.UserAccessPolicies{},
-		TeamAccessPolicies: portainer.TeamAccessPolicies{},
-		TagIDs:             []portainer.TagID{},
-		Status:             portainer.EndpointStatusUp,
-		Snapshots:          []portainer.DockerSnapshot{},
-		Kubernetes:         portainer.KubernetesDefault(),
-
-		SecuritySettings: portainer.EndpointSecuritySettings{
-			AllowVolumeBrowserForRegularUsers: false,
-			EnableHostManagementFeatures:      false,
-
-			AllowSysctlSettingForRegularUsers:         true,
-			AllowBindMountsForRegularUsers:            true,
-			AllowPrivilegedModeForRegularUsers:        true,
-			AllowHostNamespaceForRegularUsers:         true,
-			AllowContainerCapabilitiesForRegularUsers: true,
-			AllowDeviceMappingForRegularUsers:         true,
-			AllowStackManagementForRegularUsers:       true,
-		},
-	}
+	endpoint := dataStore.Endpoint().NewDefault()
+	endpoint.Name = "primary"
+	endpoint.URL = *flags.EndpointURL
+	endpoint.GroupID = portainer.EndpointGroupID(1)
+	endpoint.Type = portainer.DockerEnvironment
 
 	if strings.HasPrefix(endpoint.URL, "tcp://") {
 		tlsConfig, err := crypto.CreateTLSConfigurationFromDisk(tlsConfiguration.TLSCACertPath, tlsConfiguration.TLSCertPath, tlsConfiguration.TLSKeyPath, tlsConfiguration.TLSSkipVerify)
@@ -407,11 +409,7 @@ func createTLSSecuredEndpoint(flags *portainer.CLIFlags, dataStore dataservices.
 
 	err := snapshotService.SnapshotEndpoint(endpoint)
 	if err != nil {
-		log.Error().
-			Str("endpoint", endpoint.Name).
-			Str("URL", endpoint.URL).
-			Err(err).
-			Msg("environment snapshot error")
+		logrus.Printf("http error: environment snapshot error (environment=%s, URL=%s) (err=%s)\n", endpoint.Name, endpoint.URL, err)
 	}
 
 	return dataStore.Endpoint().Create(endpoint)
@@ -425,41 +423,15 @@ func createUnsecuredEndpoint(endpointURL string, dataStore dataservices.DataStor
 		}
 	}
 
-	endpointID := dataStore.Endpoint().GetNextIdentifier()
-	endpoint := &portainer.Endpoint{
-		ID:                 portainer.EndpointID(endpointID),
-		Name:               "primary",
-		URL:                endpointURL,
-		GroupID:            portainer.EndpointGroupID(1),
-		Type:               portainer.DockerEnvironment,
-		TLSConfig:          portainer.TLSConfiguration{},
-		UserAccessPolicies: portainer.UserAccessPolicies{},
-		TeamAccessPolicies: portainer.TeamAccessPolicies{},
-		TagIDs:             []portainer.TagID{},
-		Status:             portainer.EndpointStatusUp,
-		Snapshots:          []portainer.DockerSnapshot{},
-		Kubernetes:         portainer.KubernetesDefault(),
-
-		SecuritySettings: portainer.EndpointSecuritySettings{
-			AllowVolumeBrowserForRegularUsers: false,
-			EnableHostManagementFeatures:      false,
-
-			AllowSysctlSettingForRegularUsers:         true,
-			AllowBindMountsForRegularUsers:            true,
-			AllowPrivilegedModeForRegularUsers:        true,
-			AllowHostNamespaceForRegularUsers:         true,
-			AllowContainerCapabilitiesForRegularUsers: true,
-			AllowDeviceMappingForRegularUsers:         true,
-			AllowStackManagementForRegularUsers:       true,
-		},
-	}
+	endpoint := dataStore.Endpoint().NewDefault()
+	endpoint.Name = "primary"
+	endpoint.URL = endpointURL
+	endpoint.GroupID = portainer.EndpointGroupID(1)
+	endpoint.Type = portainer.DockerEnvironment
 
 	err := snapshotService.SnapshotEndpoint(endpoint)
 	if err != nil {
-		log.Error().
-			Str("endpoint", endpoint.Name).
-			Str("URL", endpoint.URL).Err(err).
-			Msg("environment snapshot error")
+		logrus.Printf("http error: environment snapshot error (environment=%s, URL=%s) (err=%s)\n", endpoint.Name, endpoint.URL, err)
 	}
 
 	return dataStore.Endpoint().Create(endpoint)
@@ -476,8 +448,7 @@ func initEndpoint(flags *portainer.CLIFlags, dataStore dataservices.DataStore, s
 	}
 
 	if len(endpoints) > 0 {
-		log.Info().Msg("instance already has defined environments, skipping the environment defined via CLI")
-
+		logrus.Println("Instance already has defined environments. Skipping the environment defined via CLI.")
 		return nil
 	}
 
@@ -491,9 +462,9 @@ func loadEncryptionSecretKey(keyfilename string) []byte {
 	content, err := os.ReadFile(path.Join("/run/secrets", keyfilename))
 	if err != nil {
 		if os.IsNotExist(err) {
-			log.Info().Str("filename", keyfilename).Msg("encryption key file not present")
+			logrus.Printf("Encryption key file `%s` not present", keyfilename)
 		} else {
-			log.Info().Err(err).Msg("error reading encryption key file")
+			logrus.Printf("Error reading encryption key file: %v", err)
 		}
 
 		return nil
@@ -507,76 +478,70 @@ func loadEncryptionSecretKey(keyfilename string) []byte {
 func buildServer(flags *portainer.CLIFlags) portainer.Server {
 	shutdownCtx, shutdownTrigger := context.WithCancel(context.Background())
 
-	if flags.FeatureFlags != nil {
-		featureflags.Parse(*flags.FeatureFlags, portainer.SupportedFeatureFlags)
-	}
-
 	fileService := initFileService(*flags.Data)
 	encryptionKey := loadEncryptionSecretKey(*flags.SecretKeyName)
 	if encryptionKey == nil {
-		log.Info().Msg("proceeding without encryption key")
+		logrus.Println("Proceeding without encryption key")
 	}
 
 	dataStore := initDataStore(flags, encryptionKey, fileService, shutdownCtx)
 
 	if err := dataStore.CheckCurrentEdition(); err != nil {
-		log.Fatal().Err(err).Msg("")
+		logrus.Fatal(err)
 	}
-
 	instanceID, err := dataStore.Version().InstanceID()
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed getting instance id")
+		logrus.Fatalf("Failed getting instance id: %v", err)
 	}
 
 	apiKeyService := initAPIKeyService(dataStore)
 
 	settings, err := dataStore.Settings().Settings()
 	if err != nil {
-		log.Fatal().Err(err).Msg("")
+		logrus.Fatal(err)
 	}
-
 	jwtService, err := initJWTService(settings.UserSessionTimeout, dataStore)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing JWT service")
+		logrus.Fatalf("Failed initializing JWT service: %v", err)
+	}
+
+	err = enableFeaturesFromFlags(dataStore, flags)
+	if err != nil {
+		logrus.Fatalf("Failed enabling feature flag: %v", err)
 	}
 
 	ldapService := initLDAPService()
-
 	oauthService := initOAuthService()
-
-	gitService := initGitService(shutdownCtx)
+	gitService := initGitService()
 
 	openAMTService := openamt.NewService()
 
 	cryptoService := initCryptoService()
-
 	digitalSignatureService := initDigitalSignatureService()
 
-	edgeStacksService := edgestacks.NewService(dataStore)
-
-	sslService, err := initSSLService(*flags.AddrHTTPS, *flags.SSLCert, *flags.SSLKey, fileService, dataStore, shutdownTrigger)
+	sslService, err := initSSLService(*flags.AddrHTTPS, *flags.Data, *flags.SSLCert, *flags.SSLKey, fileService, dataStore, shutdownTrigger)
 	if err != nil {
-		log.Fatal().Err(err).Msg("")
+		logrus.Fatal(err)
 	}
 
 	sslSettings, err := sslService.GetSSLSettings()
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed to get SSL settings")
+		logrus.Fatalf("Failed to get ssl settings: %s", err)
 	}
 
 	err = initKeyPair(fileService, digitalSignatureService)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing key pair")
+		logrus.Fatalf("Failed initializing key pair: %v", err)
 	}
 
 	reverseTunnelService := chisel.NewService(dataStore, shutdownCtx)
 
 	dockerClientFactory := initDockerClientFactory(digitalSignatureService, reverseTunnelService)
-	kubernetesClientFactory, err := initKubernetesClientFactory(digitalSignatureService, reverseTunnelService, dataStore, instanceID, *flags.AddrHTTPS, settings.UserSessionTimeout)
+	kubernetesClientFactory := initKubernetesClientFactory(digitalSignatureService, reverseTunnelService, instanceID, dataStore)
 
 	snapshotService, err := initSnapshotService(*flags.SnapshotInterval, dataStore, dockerClientFactory, kubernetesClientFactory, shutdownCtx)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing snapshot service")
+		logrus.Fatalf("Failed initializing snapshot service: %v", err)
 	}
 	snapshotService.Start()
 
@@ -585,63 +550,49 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 
 	kubernetesTokenCacheManager := kubeproxy.NewTokenCacheManager()
 
-	kubeClusterAccessService := kubernetes.NewKubeClusterAccessService(*flags.BaseURL, *flags.AddrHTTPS, sslSettings.CertPath)
+	kubeConfigService := kubernetes2.NewKubeConfigCAService(*flags.AddrHTTPS, sslSettings.CertPath)
 
-	proxyManager := proxy.NewManager(dataStore, digitalSignatureService, reverseTunnelService, dockerClientFactory, kubernetesClientFactory, kubernetesTokenCacheManager, gitService)
+	proxyManager := proxy.NewManager(dataStore, digitalSignatureService, reverseTunnelService, dockerClientFactory, kubernetesClientFactory, kubernetesTokenCacheManager)
 
 	reverseTunnelService.ProxyManager = proxyManager
 
 	dockerConfigPath := fileService.GetDockerConfigPath()
 
-	composeDeployer, err := compose.NewComposeDeployer(*flags.Assets, dockerConfigPath)
-	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing compose deployer")
-	}
-
-	composeStackManager := initComposeStackManager(composeDeployer, reverseTunnelService, proxyManager)
+	composeStackManager := initComposeStackManager(*flags.Assets, dockerConfigPath, reverseTunnelService, proxyManager)
 
 	swarmStackManager, err := initSwarmStackManager(*flags.Assets, dockerConfigPath, digitalSignatureService, fileService, reverseTunnelService, dataStore)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing swarm stack manager")
+		logrus.Fatalf("Failed initializing swarm stack manager: %v", err)
 	}
 
 	kubernetesDeployer := initKubernetesDeployer(kubernetesTokenCacheManager, kubernetesClientFactory, dataStore, reverseTunnelService, digitalSignatureService, proxyManager, *flags.Assets)
 
 	helmPackageManager, err := initHelmPackageManager(*flags.Assets)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing helm package manager")
+		logrus.Fatalf("Failed initializing helm package manager: %v", err)
 	}
 
 	err = edge.LoadEdgeJobs(dataStore, reverseTunnelService)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed loading edge jobs from database")
+		logrus.Fatalf("Failed loading edge jobs from database: %v", err)
 	}
 
 	applicationStatus := initStatus(instanceID)
 
-	demoService := demo.NewService()
-	if *flags.DemoEnvironment {
-		err := demoService.Init(dataStore, cryptoService)
-		if err != nil {
-			log.Fatal().Err(err).Msg("failed initializing demo environment")
-		}
-	}
-
 	err = initEndpoint(flags, dataStore, snapshotService)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing environment")
+		logrus.Fatalf("Failed initializing environment: %v", err)
 	}
 
 	adminPasswordHash := ""
 	if *flags.AdminPasswordFile != "" {
 		content, err := fileService.GetFileContent(*flags.AdminPasswordFile, "")
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed getting admin password file")
+			logrus.Fatalf("Failed getting admin password file: %v", err)
 		}
-
 		adminPasswordHash, err = cryptoService.Hash(strings.TrimSuffix(string(content), "\n"))
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed hashing admin password")
+			logrus.Fatalf("Failed hashing admin password: %v", err)
 		}
 	} else if *flags.AdminPassword != "" {
 		adminPasswordHash = *flags.AdminPassword
@@ -650,57 +601,38 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 	if adminPasswordHash != "" {
 		users, err := dataStore.User().UsersByRole(portainer.AdministratorRole)
 		if err != nil {
-			log.Fatal().Err(err).Msg("failed getting admin user")
+			logrus.Fatalf("Failed getting admin user: %v", err)
 		}
 
 		if len(users) == 0 {
-			log.Info().Msg("created admin user with the given password.")
+			logrus.Println("Created admin user with the given password.")
 			user := &portainer.User{
 				Username: "admin",
 				Role:     portainer.AdministratorRole,
 				Password: adminPasswordHash,
 			}
-
 			err := dataStore.User().Create(user)
 			if err != nil {
-				log.Fatal().Err(err).Msg("failed creating admin user")
+				logrus.Fatalf("Failed creating admin user: %v", err)
 			}
 		} else {
-			log.Info().Msg("instance already has an administrator user defined, skipping admin password related flags.")
+			logrus.Println("Instance already has an administrator user defined. Skipping admin password related flags.")
 		}
 	}
 
 	err = reverseTunnelService.StartTunnelServer(*flags.TunnelAddr, *flags.TunnelPort, snapshotService)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed starting tunnel server")
+		logrus.Fatalf("Failed starting tunnel server: %v", err)
 	}
 
-	scheduler := scheduler.NewScheduler(shutdownCtx)
-	stackDeployer := deployments.NewStackDeployer(swarmStackManager, composeStackManager, kubernetesDeployer)
-	deployments.StartStackSchedules(scheduler, stackDeployer, dataStore, gitService)
-
 	sslDBSettings, err := dataStore.SSLSettings().Settings()
 	if err != nil {
-		log.Fatal().Msg("failed to fetch SSL settings from DB")
+		logrus.Fatalf("Failed to fetch ssl settings from DB")
 	}
 
-	upgradeService, err := upgrade.NewService(*flags.Assets, composeDeployer)
-	if err != nil {
-		log.Fatal().Err(err).Msg("failed initializing upgrade service")
-	}
-
-	// Our normal migrations run as part of the database initialization
-	// but some more complex migrations require access to a kubernetes or docker
-	// client. Therefore we run a separate migration process just before
-	// starting the server.
-	postInitMigrator := datastore.NewPostInitMigrator(
-		kubernetesClientFactory,
-		dockerClientFactory,
-		dataStore,
-	)
-	if err := postInitMigrator.PostInitMigrate(); err != nil {
-		log.Fatal().Err(err).Msg("failure during post init migrations")
-	}
+	scheduler := scheduler.NewScheduler(shutdownCtx)
+	stackDeployer := stacks.NewStackDeployer(swarmStackManager, composeStackManager, kubernetesDeployer)
+	stacks.StartStackSchedules(scheduler, stackDeployer, dataStore, gitService)
 
 	return &http.Server{
 		AuthorizationService:        authorizationService,
@@ -711,13 +643,12 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		HTTPEnabled:                 sslDBSettings.HTTPEnabled,
 		AssetsPath:                  *flags.Assets,
 		DataStore:                   dataStore,
-		EdgeStacksService:           edgeStacksService,
 		SwarmStackManager:           swarmStackManager,
 		ComposeStackManager:         composeStackManager,
 		KubernetesDeployer:          kubernetesDeployer,
 		HelmPackageManager:          helmPackageManager,
-		APIKeyService:               apiKeyService,
 		CryptoService:               cryptoService,
+		APIKeyService:               apiKeyService,
 		JWTService:                  jwtService,
 		FileService:                 fileService,
 		LDAPService:                 ldapService,
@@ -726,7 +657,7 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		OpenAMTService:              openAMTService,
 		ProxyManager:                proxyManager,
 		KubernetesTokenCacheManager: kubernetesTokenCacheManager,
-		KubeClusterAccessService:    kubeClusterAccessService,
+		KubeConfigService:           kubeConfigService,
 		SignatureService:            digitalSignatureService,
 		SnapshotService:             snapshotService,
 		SSLService:                  sslService,
@@ -736,35 +667,19 @@ func buildServer(flags *portainer.CLIFlags) portainer.Server {
 		ShutdownCtx:                 shutdownCtx,
 		ShutdownTrigger:             shutdownTrigger,
 		StackDeployer:               stackDeployer,
-		DemoService:                 demoService,
-		UpgradeService:              upgradeService,
+		BaseURL:                     *flags.BaseURL,
 	}
 }
 
 func main() {
-	rand.Seed(time.Now().UnixNano())
-
-	configureLogger()
-	setLoggingMode("PRETTY")
-
 	flags := initCLI()
 
-	setLoggingLevel(*flags.LogLevel)
-	setLoggingMode(*flags.LogMode)
+	configureLogger()
 
 	for {
 		server := buildServer(flags)
-		log.Info().
-			Str("version", portainer.APIVersion).
-			Str("build_number", build.BuildNumber).
-			Str("image_tag", build.ImageTag).
-			Str("nodejs_version", build.NodejsVersion).
-			Str("yarn_version", build.YarnVersion).
-			Str("webpack_version", build.WebpackVersion).
-			Str("go_version", build.GoVersion).
-			Msg("starting Portainer")
-
+		logrus.Printf("[INFO] [cmd,main] Starting Portainer version %s\n", portainer.APIVersion)
 		err := server.Start()
-		log.Info().Err(err).Msg("HTTP server exited")
+		logrus.Printf("[INFO] [cmd,main] Http server exited: %v\n", err)
 	}
 }

api/cmd/portainer/main_test.go

@@ -0,0 +1,110 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/cli"
+	"github.com/portainer/portainer/api/dataservices"
+	"github.com/portainer/portainer/api/datastore"
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/alecthomas/kingpin.v2"
+)
+
+type mockKingpinSetting string
+
+func (m mockKingpinSetting) SetValue(value kingpin.Value) {
+	value.Set(string(m))
+}
+
+func Test_enableFeaturesFromFlags(t *testing.T) {
+	is := assert.New(t)
+
+	_, store, teardown := datastore.MustNewTestStore(true)
+	defer teardown()
+
+	tests := []struct {
+		featureFlag string
+		isSupported bool
+	}{
+		{"test", false},
+	}
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("%s succeeds:%v", test.featureFlag, test.isSupported), func(t *testing.T) {
+			mockKingpinSetting := mockKingpinSetting(test.featureFlag)
+			flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+			err := enableFeaturesFromFlags(store, flags)
+			if test.isSupported {
+				is.NoError(err)
+			} else {
+				is.Error(err)
+			}
+		})
+	}
+
+	t.Run("passes for all supported feature flags", func(t *testing.T) {
+		for _, flag := range portainer.SupportedFeatureFlags {
+			mockKingpinSetting := mockKingpinSetting(flag)
+			flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+			err := enableFeaturesFromFlags(store, flags)
+			is.NoError(err)
+		}
+	})
+}
+
+const FeatTest portainer.Feature = "optional-test"
+
+func optionalFunc(dataStore dataservices.DataStore) string {
+
+	// TODO: this is a code smell - finding out if a feature flag is enabled should not require having access to the store, and asking for a settings obj.
+	//       ideally, the `if` should look more like:
+	//       if featureflags.FlagEnabled(FeatTest) {}
+	settings, err := dataStore.Settings().Settings()
+	if err != nil {
+		return err.Error()
+	}
+
+	if settings.FeatureFlagSettings[FeatTest] {
+		return "enabled"
+	}
+	return "disabled"
+}
+
+func Test_optionalFeature(t *testing.T) {
+	portainer.SupportedFeatureFlags = append(portainer.SupportedFeatureFlags, FeatTest)
+
+	is := assert.New(t)
+
+	_, store, teardown := datastore.MustNewTestStore(true)
+	defer teardown()
+
+	// Enable the test feature
+	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+		mockKingpinSetting := mockKingpinSetting(FeatTest)
+		flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+		err := enableFeaturesFromFlags(store, flags)
+		is.NoError(err)
+		is.Equal("enabled", optionalFunc(store))
+	})
+
+	// Same store, so the feature flag should still be enabled
+	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+		is.Equal("enabled", optionalFunc(store))
+	})
+
+	// disable the test feature
+	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+		mockKingpinSetting := mockKingpinSetting(FeatTest + "=false")
+		flags := &portainer.CLIFlags{FeatureFlags: cli.BoolPairs(mockKingpinSetting)}
+		err := enableFeaturesFromFlags(store, flags)
+		is.NoError(err)
+		is.Equal("disabled", optionalFunc(store))
+	})
+
+	// Same store, so feature flag should still be disabled
+	t.Run(fmt.Sprintf("%s succeeds:%v", FeatTest, true), func(t *testing.T) {
+		is.Equal("disabled", optionalFunc(store))
+	})
+
+}

api/crypto/aes.go

@@ -13,7 +13,7 @@ import (
 // Person with better knowledge is welcomed to improve it.
 // sourced from https://golang.org/src/crypto/cipher/example_test.go
 
-var emptySalt []byte = make([]byte, 0)
+var emptySalt []byte = make([]byte, 0, 0)
 
 // AesEncrypt reads from input, encrypts with AES-256 and writes to the output.
 // passphrase is used to generate an encryption key.

api/crypto/aes_test.go

@@ -2,15 +2,18 @@ package crypto
 
 import (
 	"io"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/docker/docker/pkg/ioutils"
 	"github.com/stretchr/testify/assert"
 )
 
 func Test_encryptAndDecrypt_withTheSamePassword(t *testing.T) {
-	tmpdir := t.TempDir()
+	tmpdir, _ := ioutils.TempDir("", "encrypt")
+	defer os.RemoveAll(tmpdir)
 
 	var (
 		originFilePath    = filepath.Join(tmpdir, "origin")
@@ -19,7 +22,7 @@ func Test_encryptAndDecrypt_withTheSamePassword(t *testing.T) {
 	)
 
 	content := []byte("content")
-	os.WriteFile(originFilePath, content, 0600)
+	ioutil.WriteFile(originFilePath, content, 0600)
 
 	originFile, _ := os.Open(originFilePath)
 	defer originFile.Close()
@@ -29,7 +32,7 @@ func Test_encryptAndDecrypt_withTheSamePassword(t *testing.T) {
 
 	err := AesEncrypt(originFile, encryptedFileWriter, []byte("passphrase"))
 	assert.Nil(t, err, "Failed to encrypt a file")
-	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	encryptedContent, err := ioutil.ReadFile(encryptedFilePath)
 	assert.Nil(t, err, "Couldn't read encrypted file")
 	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
@@ -44,12 +47,13 @@ func Test_encryptAndDecrypt_withTheSamePassword(t *testing.T) {
 
 	io.Copy(decryptedFileWriter, decryptedReader)
 
-	decryptedContent, _ := os.ReadFile(decryptedFilePath)
+	decryptedContent, _ := ioutil.ReadFile(decryptedFilePath)
 	assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
 }
 
 func Test_encryptAndDecrypt_withEmptyPassword(t *testing.T) {
-	tmpdir := t.TempDir()
+	tmpdir, _ := ioutils.TempDir("", "encrypt")
+	defer os.RemoveAll(tmpdir)
 
 	var (
 		originFilePath    = filepath.Join(tmpdir, "origin")
@@ -58,7 +62,7 @@ func Test_encryptAndDecrypt_withEmptyPassword(t *testing.T) {
 	)
 
 	content := []byte("content")
-	os.WriteFile(originFilePath, content, 0600)
+	ioutil.WriteFile(originFilePath, content, 0600)
 
 	originFile, _ := os.Open(originFilePath)
 	defer originFile.Close()
@@ -68,7 +72,7 @@ func Test_encryptAndDecrypt_withEmptyPassword(t *testing.T) {
 
 	err := AesEncrypt(originFile, encryptedFileWriter, []byte(""))
 	assert.Nil(t, err, "Failed to encrypt a file")
-	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	encryptedContent, err := ioutil.ReadFile(encryptedFilePath)
 	assert.Nil(t, err, "Couldn't read encrypted file")
 	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
@@ -83,12 +87,13 @@ func Test_encryptAndDecrypt_withEmptyPassword(t *testing.T) {
 
 	io.Copy(decryptedFileWriter, decryptedReader)
 
-	decryptedContent, _ := os.ReadFile(decryptedFilePath)
+	decryptedContent, _ := ioutil.ReadFile(decryptedFilePath)
 	assert.Equal(t, content, decryptedContent, "Original and decrypted content should match")
 }
 
 func Test_decryptWithDifferentPassphrase_shouldProduceWrongResult(t *testing.T) {
-	tmpdir := t.TempDir()
+	tmpdir, _ := ioutils.TempDir("", "encrypt")
+	defer os.RemoveAll(tmpdir)
 
 	var (
 		originFilePath    = filepath.Join(tmpdir, "origin")
@@ -97,7 +102,7 @@ func Test_decryptWithDifferentPassphrase_shouldProduceWrongResult(t *testing.T)
 	)
 
 	content := []byte("content")
-	os.WriteFile(originFilePath, content, 0600)
+	ioutil.WriteFile(originFilePath, content, 0600)
 
 	originFile, _ := os.Open(originFilePath)
 	defer originFile.Close()
@@ -107,7 +112,7 @@ func Test_decryptWithDifferentPassphrase_shouldProduceWrongResult(t *testing.T)
 
 	err := AesEncrypt(originFile, encryptedFileWriter, []byte("passphrase"))
 	assert.Nil(t, err, "Failed to encrypt a file")
-	encryptedContent, err := os.ReadFile(encryptedFilePath)
+	encryptedContent, err := ioutil.ReadFile(encryptedFilePath)
 	assert.Nil(t, err, "Couldn't read encrypted file")
 	assert.NotEqual(t, encryptedContent, content, "Content wasn't encrypted")
 
@@ -122,6 +127,6 @@ func Test_decryptWithDifferentPassphrase_shouldProduceWrongResult(t *testing.T)
 
 	io.Copy(decryptedFileWriter, decryptedReader)
 
-	decryptedContent, _ := os.ReadFile(decryptedFilePath)
+	decryptedContent, _ := ioutil.ReadFile(decryptedFilePath)
 	assert.NotEqual(t, content, decryptedContent, "Original and decrypted content should NOT match")
 }

api/crypto/hash.go

@@ -9,11 +9,11 @@ type Service struct{}
 
 // Hash hashes a string using the bcrypt algorithm
 func (*Service) Hash(data string) (string, error) {
-	bytes, err := bcrypt.GenerateFromPassword([]byte(data), bcrypt.DefaultCost)
+	hash, err := bcrypt.GenerateFromPassword([]byte(data), bcrypt.DefaultCost)
 	if err != nil {
-		return "", err
+		return "", nil
 	}
-	return string(bytes), err
+	return string(hash), nil
 }
 
 // CompareHashAndData compares a hash to clear data and returns an error if the comparison fails.

api/crypto/hash_test.go

@@ -1,53 +0,0 @@
-package crypto
-
-import (
-	"testing"
-)
-
-func TestService_Hash(t *testing.T) {
-	var s = &Service{}
-
-	type args struct {
-		hash string
-		data string
-	}
-	tests := []struct {
-		name   string
-		args   args
-		expect bool
-	}{
-		{
-			name: "Empty",
-			args: args{
-				hash: "",
-				data: "",
-			},
-			expect: false,
-		},
-		{
-			name: "Matching",
-			args: args{
-				hash: "$2a$10$6BFGd94oYx8k0bFNO6f33uPUpcpAJyg8UVX.akLe9EthF/ZBTXqcy",
-				data: "Passw0rd!",
-			},
-			expect: true,
-		},
-		{
-			name: "Not matching",
-			args: args{
-				hash: "$2a$10$ltKrUZ7492xyutHOb0/XweevU4jyw7QO66rP32jTVOMb3EX3JxA/a",
-				data: "Passw0rd!",
-			},
-			expect: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-
-			err := s.CompareHashAndData(tt.args.hash, tt.args.data)
-			if (err != nil) == tt.expect {
-				t.Errorf("Service.CompareHashAndData() = %v", err)
-			}
-		})
-	}
-}

api/crypto/tls.go

@@ -3,11 +3,11 @@ package crypto
 import (
 	"crypto/tls"
 	"crypto/x509"
-	"os"
+	"io/ioutil"
 )
 
-// CreateTLSConfiguration creates a basic tls.Config with recommended TLS settings
-func CreateTLSConfiguration() *tls.Config {
+// CreateServerTLSConfiguration creates a basic tls.Config to be used by servers with recommended TLS settings
+func CreateServerTLSConfiguration() *tls.Config {
 	return &tls.Config{
 		MinVersion: tls.VersionTLS12,
 		CipherSuites: []uint16{
@@ -27,7 +27,7 @@ func CreateTLSConfiguration() *tls.Config {
 // CreateTLSConfigurationFromBytes initializes a tls.Config using a CA certificate, a certificate and a key
 // loaded from memory.
 func CreateTLSConfigurationFromBytes(caCert, cert, key []byte, skipClientVerification, skipServerVerification bool) (*tls.Config, error) {
-	config := CreateTLSConfiguration()
+	config := &tls.Config{}
 	config.InsecureSkipVerify = skipServerVerification
 
 	if !skipClientVerification {
@@ -50,7 +50,7 @@ func CreateTLSConfigurationFromBytes(caCert, cert, key []byte, skipClientVerific
 // CreateTLSConfigurationFromDisk initializes a tls.Config using a CA certificate, a certificate and a key
 // loaded from disk.
 func CreateTLSConfigurationFromDisk(caCertPath, certPath, keyPath string, skipServerVerification bool) (*tls.Config, error) {
-	config := CreateTLSConfiguration()
+	config := &tls.Config{}
 	config.InsecureSkipVerify = skipServerVerification
 
 	if certPath != "" && keyPath != "" {
@@ -63,7 +63,7 @@ func CreateTLSConfigurationFromDisk(caCertPath, certPath, keyPath string, skipSe
 	}
 
 	if !skipServerVerification && caCertPath != "" {
-		caCert, err := os.ReadFile(caCertPath)
+		caCert, err := ioutil.ReadFile(caCertPath)
 		if err != nil {
 			return nil, err
 		}

api/database/boltdb/db.go

@@ -5,15 +5,14 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"path"
 	"time"
 
-	portainer "github.com/portainer/portainer/api"
+	"github.com/boltdb/bolt"
 	dserrors "github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
-	bolt "go.etcd.io/bbolt"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -121,7 +120,7 @@ func (connection *DbConnection) NeedsEncryptionMigration() (bool, error) {
 // Open opens and initializes the BoltDB database.
 func (connection *DbConnection) Open() error {
 
-	log.Info().Str("filename", connection.GetDatabaseFileName()).Msg("loading PortainerDB")
+	logrus.Infof("Loading PortainerDB: %s", connection.GetDatabaseFileName())
 
 	// Now we open the db
 	databasePath := connection.GetDatabaseFilePath()
@@ -132,11 +131,9 @@ func (connection *DbConnection) Open() error {
 	if err != nil {
 		return err
 	}
-
 	db.MaxBatchSize = connection.MaxBatchSize
 	db.MaxBatchDelay = connection.MaxBatchDelay
 	connection.DB = db
-
 	return nil
 }
 
@@ -146,30 +143,9 @@ func (connection *DbConnection) Close() error {
 	if connection.DB != nil {
 		return connection.DB.Close()
 	}
-
 	return nil
 }
 
-func (connection *DbConnection) txFn(fn func(portainer.Transaction) error) func(*bolt.Tx) error {
-	return func(tx *bolt.Tx) error {
-		return fn(&DbTransaction{conn: connection, tx: tx})
-	}
-}
-
-// UpdateTx executes the given function inside a read-write transaction
-func (connection *DbConnection) UpdateTx(fn func(portainer.Transaction) error) error {
-	if connection.MaxBatchDelay > 0 && connection.MaxBatchSize > 1 {
-		return connection.Batch(connection.txFn(fn))
-	}
-
-	return connection.Update(connection.txFn(fn))
-}
-
-// ViewTx executes the given function inside a read-only transaction
-func (connection *DbConnection) ViewTx(fn func(portainer.Transaction) error) error {
-	return connection.View(connection.txFn(fn))
-}
-
 // BackupTo backs up db to a provided writer.
 // It does hot backup and doesn't block other database reads and writes
 func (connection *DbConnection) BackupTo(w io.Writer) error {
@@ -185,11 +161,11 @@ func (connection *DbConnection) ExportRaw(filename string) error {
 		return fmt.Errorf("stat on %s failed: %s", databasePath, err)
 	}
 
-	b, err := connection.ExportJSON(databasePath, true)
+	b, err := connection.exportJson(databasePath)
 	if err != nil {
 		return err
 	}
-	return os.WriteFile(filename, b, 0600)
+	return ioutil.WriteFile(filename, b, 0600)
 }
 
 // ConvertToKey returns an 8-byte big endian representation of v.
@@ -201,18 +177,39 @@ func (connection *DbConnection) ConvertToKey(v int) []byte {
 	return b
 }
 
-// CreateBucket is a generic function used to create a bucket inside a database.
+// CreateBucket is a generic function used to create a bucket inside a database database.
 func (connection *DbConnection) SetServiceName(bucketName string) error {
-	return connection.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.SetServiceName(bucketName)
+	return connection.Batch(func(tx *bolt.Tx) error {
+		_, err := tx.CreateBucketIfNotExists([]byte(bucketName))
+		if err != nil {
+			return err
+		}
+		return nil
 	})
 }
 
-// GetObject is a generic function used to retrieve an unmarshalled object from a database.
+// GetObject is a generic function used to retrieve an unmarshalled object from a database database.
 func (connection *DbConnection) GetObject(bucketName string, key []byte, object interface{}) error {
-	return connection.ViewTx(func(tx portainer.Transaction) error {
-		return tx.GetObject(bucketName, key, object)
+	var data []byte
+
+	err := connection.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+
+		value := bucket.Get(key)
+		if value == nil {
+			return dserrors.ErrObjectNotFound
+		}
+
+		data = make([]byte, len(value))
+		copy(data, value)
+
+		return nil
 	})
+	if err != nil {
+		return err
+	}
+
+	return connection.UnmarshalObjectWithJsoniter(data, object)
 }
 
 func (connection *DbConnection) getEncryptionKey() []byte {
@@ -223,51 +220,50 @@ func (connection *DbConnection) getEncryptionKey() []byte {
 	return connection.EncryptionKey
 }
 
-// UpdateObject is a generic function used to update an object inside a database.
+// UpdateObject is a generic function used to update an object inside a database database.
 func (connection *DbConnection) UpdateObject(bucketName string, key []byte, object interface{}) error {
-	return connection.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.UpdateObject(bucketName, key, object)
-	})
-}
+	data, err := connection.MarshalObject(object)
+	if err != nil {
+		return err
+	}
 
-// UpdateObjectFunc is a generic function used to update an object safely without race conditions.
-func (connection *DbConnection) UpdateObjectFunc(bucketName string, key []byte, object any, updateFn func()) error {
 	return connection.Batch(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket([]byte(bucketName))
-
-		data := bucket.Get(key)
-		if data == nil {
-			return dserrors.ErrObjectNotFound
-		}
-
-		err := connection.UnmarshalObjectWithJsoniter(data, object)
-		if err != nil {
-			return err
-		}
-
-		updateFn()
-
-		data, err = connection.MarshalObject(object)
-		if err != nil {
-			return err
-		}
-
 		return bucket.Put(key, data)
 	})
 }
 
-// DeleteObject is a generic function used to delete an object inside a database.
+// DeleteObject is a generic function used to delete an object inside a database database.
 func (connection *DbConnection) DeleteObject(bucketName string, key []byte) error {
-	return connection.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.DeleteObject(bucketName, key)
+	return connection.Batch(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+		return bucket.Delete(key)
 	})
 }
 
 // DeleteAllObjects delete all objects where matching() returns (id, ok).
 // TODO: think about how to return the error inside (maybe change ok to type err, and use "notfound"?
-func (connection *DbConnection) DeleteAllObjects(bucketName string, obj interface{}, matching func(o interface{}) (id int, ok bool)) error {
-	return connection.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.DeleteAllObjects(bucketName, obj, matching)
+func (connection *DbConnection) DeleteAllObjects(bucketName string, matching func(o interface{}) (id int, ok bool)) error {
+	return connection.Batch(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+
+		cursor := bucket.Cursor()
+		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
+			var obj interface{}
+			err := connection.UnmarshalObject(v, &obj)
+			if err != nil {
+				return err
+			}
+
+			if id, ok := matching(obj); ok {
+				err := bucket.Delete(connection.ConvertToKey(id))
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
 	})
 }
 
@@ -275,8 +271,13 @@ func (connection *DbConnection) DeleteAllObjects(bucketName string, obj interfac
 func (connection *DbConnection) GetNextIdentifier(bucketName string) int {
 	var identifier int
 
-	_ = connection.UpdateTx(func(tx portainer.Transaction) error {
-		identifier = tx.GetNextIdentifier(bucketName)
+	connection.Batch(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+		id, err := bucket.NextSequence()
+		if err != nil {
+			return err
+		}
+		identifier = int(id)
 		return nil
 	})
 
@@ -285,51 +286,104 @@ func (connection *DbConnection) GetNextIdentifier(bucketName string) int {
 
 // CreateObject creates a new object in the bucket, using the next bucket sequence id
 func (connection *DbConnection) CreateObject(bucketName string, fn func(uint64) (int, interface{})) error {
-	return connection.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.CreateObject(bucketName, fn)
+	return connection.Batch(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+
+		seqId, _ := bucket.NextSequence()
+		id, obj := fn(seqId)
+
+		data, err := connection.MarshalObject(obj)
+		if err != nil {
+			return err
+		}
+
+		return bucket.Put(connection.ConvertToKey(int(id)), data)
 	})
 }
 
 // CreateObjectWithId creates a new object in the bucket, using the specified id
 func (connection *DbConnection) CreateObjectWithId(bucketName string, id int, obj interface{}) error {
-	return connection.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.CreateObjectWithId(bucketName, id, obj)
+	return connection.Batch(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+		data, err := connection.MarshalObject(obj)
+		if err != nil {
+			return err
+		}
+
+		return bucket.Put(connection.ConvertToKey(id), data)
 	})
 }
 
-// CreateObjectWithStringId creates a new object in the bucket, using the specified id
-func (connection *DbConnection) CreateObjectWithStringId(bucketName string, id []byte, obj interface{}) error {
-	return connection.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.CreateObjectWithStringId(bucketName, id, obj)
+// CreateObjectWithSetSequence creates a new object in the bucket, using the specified id, and sets the bucket sequence
+// avoid this :)
+func (connection *DbConnection) CreateObjectWithSetSequence(bucketName string, id int, obj interface{}) error {
+	return connection.Batch(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+
+		// We manually manage sequences for schedules
+		err := bucket.SetSequence(uint64(id))
+		if err != nil {
+			return err
+		}
+
+		data, err := connection.MarshalObject(obj)
+		if err != nil {
+			return err
+		}
+
+		return bucket.Put(connection.ConvertToKey(id), data)
 	})
 }
 
 func (connection *DbConnection) GetAll(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	return connection.ViewTx(func(tx portainer.Transaction) error {
-		return tx.GetAll(bucketName, obj, append)
+	err := connection.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+		cursor := bucket.Cursor()
+		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
+			err := connection.UnmarshalObject(v, obj)
+			if err != nil {
+				return err
+			}
+			obj, err = append(obj)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
 	})
+	return err
 }
 
 // TODO: decide which Unmarshal to use, and use one...
 func (connection *DbConnection) GetAllWithJsoniter(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	return connection.ViewTx(func(tx portainer.Transaction) error {
-		return tx.GetAllWithJsoniter(bucketName, obj, append)
+	err := connection.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(bucketName))
+
+		cursor := bucket.Cursor()
+		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
+			err := connection.UnmarshalObjectWithJsoniter(v, obj)
+			if err != nil {
+				return err
+			}
+			obj, err = append(obj)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
 	})
+	return err
 }
 
-func (connection *DbConnection) GetAllWithKeyPrefix(bucketName string, keyPrefix []byte, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	return connection.ViewTx(func(tx portainer.Transaction) error {
-		return tx.GetAllWithKeyPrefix(bucketName, keyPrefix, obj, append)
-	})
-}
-
-// BackupMetadata will return a copy of the boltdb sequence numbers for all buckets.
 func (connection *DbConnection) BackupMetadata() (map[string]interface{}, error) {
 	buckets := map[string]interface{}{}
 
 	err := connection.View(func(tx *bolt.Tx) error {
 		err := tx.ForEach(func(name []byte, bucket *bolt.Bucket) error {
 			bucketName := string(name)
+			bucket = tx.Bucket([]byte(bucketName))
 			seqId := bucket.Sequence()
 			buckets[bucketName] = int(seqId)
 			return nil
@@ -341,23 +395,18 @@ func (connection *DbConnection) BackupMetadata() (map[string]interface{}, error)
 	return buckets, err
 }
 
-// RestoreMetadata will restore the boltdb sequence numbers for all buckets.
 func (connection *DbConnection) RestoreMetadata(s map[string]interface{}) error {
 	var err error
 
 	for bucketName, v := range s {
 		id, ok := v.(float64) // JSON ints are unmarshalled to interface as float64. See: https://pkg.go.dev/encoding/json#Decoder.Decode
 		if !ok {
-			log.Error().Str("bucket", bucketName).Msg("failed to restore metadata to bucket, skipped")
+			logrus.Errorf("Failed to restore metadata to bucket %s, skipped", bucketName)
 			continue
 		}
 
 		err = connection.Batch(func(tx *bolt.Tx) error {
-			bucket, err := tx.CreateBucketIfNotExists([]byte(bucketName))
-			if err != nil {
-				return err
-			}
-
+			bucket := tx.Bucket([]byte(bucketName))
 			return bucket.SetSequence(uint64(id))
 		})
 	}

api/database/boltdb/export.go

@@ -4,34 +4,14 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/rs/zerolog/log"
-	bolt "go.etcd.io/bbolt"
+	"github.com/boltdb/bolt"
+	"github.com/sirupsen/logrus"
 )
 
-func backupMetadata(connection *bolt.DB) (map[string]interface{}, error) {
-	buckets := map[string]interface{}{}
-
-	err := connection.View(func(tx *bolt.Tx) error {
-		err := tx.ForEach(func(name []byte, bucket *bolt.Bucket) error {
-			bucketName := string(name)
-			seqId := bucket.Sequence()
-			buckets[bucketName] = int(seqId)
-			return nil
-		})
-
-		return err
-	})
-
-	return buckets, err
-}
-
-// ExportJSON creates a JSON representation from a DbConnection. You can include
-// the database's metadata or ignore it. Ensure the database is closed before
-// using this function.
 // inspired by github.com/konoui/boltdb-exporter (which has no license)
 // but very much simplified, based on how we use boltdb
-func (c *DbConnection) ExportJSON(databasePath string, metadata bool) ([]byte, error) {
-	log.Debug().Str("databasePath", databasePath).Msg("exportJson")
+func (c *DbConnection) exportJson(databasePath string) ([]byte, error) {
+	logrus.WithField("databasePath", databasePath).Infof("exportJson")
 
 	connection, err := bolt.Open(databasePath, 0600, &bolt.Options{Timeout: 1 * time.Second, ReadOnly: true})
 	if err != nil {
@@ -40,14 +20,6 @@ func (c *DbConnection) ExportJSON(databasePath string, metadata bool) ([]byte, e
 	defer connection.Close()
 
 	backup := make(map[string]interface{})
-	if metadata {
-		meta, err := backupMetadata(connection)
-		if err != nil {
-			log.Error().Err(err).Msg("failed exporting metadata")
-		}
-
-		backup["__metadata"] = meta
-	}
 
 	err = connection.View(func(tx *bolt.Tx) error {
 		err = tx.ForEach(func(name []byte, bucket *bolt.Bucket) error {
@@ -59,51 +31,35 @@ func (c *DbConnection) ExportJSON(databasePath string, metadata bool) ([]byte, e
 				if v == nil {
 					continue
 				}
-
 				var obj interface{}
 				err := c.UnmarshalObject(v, &obj)
 				if err != nil {
-					log.Error().
-						Str("bucket", bucketName).
-						Str("object", string(v)).
-						Err(err).
-						Msg("failed to unmarshal")
-
+					logrus.WithError(err).Errorf("Failed to unmarshal (bucket %s): %v", bucketName, string(v))
 					obj = v
 				}
-
 				if bucketName == "version" {
 					version[string(k)] = string(v)
 				} else {
 					list = append(list, obj)
 				}
 			}
-
 			if bucketName == "version" {
 				backup[bucketName] = version
-				return nil
 			}
-
 			if len(list) > 0 {
 				if bucketName == "ssl" ||
 					bucketName == "settings" ||
 					bucketName == "tunnel_server" {
-					backup[bucketName] = nil
-					if len(list) > 0 {
-						backup[bucketName] = list[0]
-					}
+					backup[bucketName] = list[0]
 					return nil
 				}
 				backup[bucketName] = list
-				return nil
 			}
 
 			return nil
 		})
-
 		return err
 	})
-
 	if err != nil {
 		return []byte("{}"), err
 	}

api/database/boltdb/json_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 const (
-	jsonobject = `{"LogoURL":"","BlackListedLabels":[],"AuthenticationMethod":1,"InternalAuthSettings": {"RequiredPasswordLength": 12}"LDAPSettings":{"AnonymousMode":true,"ReaderDN":"","URL":"","TLSConfig":{"TLS":false,"TLSSkipVerify":false},"StartTLS":false,"SearchSettings":[{"BaseDN":"","Filter":"","UserNameAttribute":""}],"GroupSearchSettings":[{"GroupBaseDN":"","GroupFilter":"","GroupAttribute":""}],"AutoCreateUsers":true},"OAuthSettings":{"ClientID":"","AccessTokenURI":"","AuthorizationURI":"","ResourceURI":"","RedirectURI":"","UserIdentifier":"","Scopes":"","OAuthAutoCreateUsers":false,"DefaultTeamID":0,"SSO":true,"LogoutURI":"","KubeSecretKey":"j0zLVtY/lAWBk62ByyF0uP80SOXaitsABP0TTJX8MhI="},"OpenAMTConfiguration":{"Enabled":false,"MPSServer":"","MPSUser":"","MPSPassword":"","MPSToken":"","CertFileContent":"","CertFileName":"","CertFilePassword":"","DomainName":""},"FeatureFlagSettings":{},"SnapshotInterval":"5m","TemplatesURL":"https://raw.githubusercontent.com/portainer/templates/master/templates-2.0.json","EdgeAgentCheckinInterval":5,"EnableEdgeComputeFeatures":false,"UserSessionTimeout":"8h","KubeconfigExpiry":"0","EnableTelemetry":true,"HelmRepositoryURL":"https://charts.bitnami.com/bitnami","KubectlShellImage":"portainer/kubectl-shell","DisplayDonationHeader":false,"DisplayExternalContributors":false,"EnableHostManagementFeatures":false,"AllowVolumeBrowserForRegularUsers":false,"AllowBindMountsForRegularUsers":false,"AllowPrivilegedModeForRegularUsers":false,"AllowHostNamespaceForRegularUsers":false,"AllowStackManagementForRegularUsers":false,"AllowDeviceMappingForRegularUsers":false,"AllowContainerCapabilitiesForRegularUsers":false}`
+	jsonobject = `{"LogoURL":"","BlackListedLabels":[],"AuthenticationMethod":1,"LDAPSettings":{"AnonymousMode":true,"ReaderDN":"","URL":"","TLSConfig":{"TLS":false,"TLSSkipVerify":false},"StartTLS":false,"SearchSettings":[{"BaseDN":"","Filter":"","UserNameAttribute":""}],"GroupSearchSettings":[{"GroupBaseDN":"","GroupFilter":"","GroupAttribute":""}],"AutoCreateUsers":true},"OAuthSettings":{"ClientID":"","AccessTokenURI":"","AuthorizationURI":"","ResourceURI":"","RedirectURI":"","UserIdentifier":"","Scopes":"","OAuthAutoCreateUsers":false,"DefaultTeamID":0,"SSO":true,"LogoutURI":"","KubeSecretKey":"j0zLVtY/lAWBk62ByyF0uP80SOXaitsABP0TTJX8MhI="},"OpenAMTConfiguration":{"Enabled":false,"MPSServer":"","MPSUser":"","MPSPassword":"","MPSToken":"","CertFileContent":"","CertFileName":"","CertFilePassword":"","DomainName":""},"FeatureFlagSettings":{},"SnapshotInterval":"5m","TemplatesURL":"https://raw.githubusercontent.com/portainer/templates/master/templates-2.0.json","EdgeAgentCheckinInterval":5,"EnableEdgeComputeFeatures":false,"UserSessionTimeout":"8h","KubeconfigExpiry":"0","EnableTelemetry":true,"HelmRepositoryURL":"https://charts.bitnami.com/bitnami","KubectlShellImage":"portainer/kubectl-shell","DisplayDonationHeader":false,"DisplayExternalContributors":false,"EnableHostManagementFeatures":false,"AllowVolumeBrowserForRegularUsers":false,"AllowBindMountsForRegularUsers":false,"AllowPrivilegedModeForRegularUsers":false,"AllowHostNamespaceForRegularUsers":false,"AllowStackManagementForRegularUsers":false,"AllowDeviceMappingForRegularUsers":false,"AllowContainerCapabilitiesForRegularUsers":false}`
 	passphrase = "my secret key"
 )
 

api/database/boltdb/tx.go

@@ -1,172 +0,0 @@
-package boltdb
-
-import (
-	"bytes"
-
-	dserrors "github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
-	bolt "go.etcd.io/bbolt"
-)
-
-type DbTransaction struct {
-	conn *DbConnection
-	tx   *bolt.Tx
-}
-
-func (tx *DbTransaction) SetServiceName(bucketName string) error {
-	_, err := tx.tx.CreateBucketIfNotExists([]byte(bucketName))
-	return err
-}
-
-func (tx *DbTransaction) GetObject(bucketName string, key []byte, object interface{}) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-
-	value := bucket.Get(key)
-	if value == nil {
-		return dserrors.ErrObjectNotFound
-	}
-
-	data := make([]byte, len(value))
-	copy(data, value)
-
-	return tx.conn.UnmarshalObjectWithJsoniter(data, object)
-}
-
-func (tx *DbTransaction) UpdateObject(bucketName string, key []byte, object interface{}) error {
-	data, err := tx.conn.MarshalObject(object)
-	if err != nil {
-		return err
-	}
-
-	bucket := tx.tx.Bucket([]byte(bucketName))
-	return bucket.Put(key, data)
-}
-
-func (tx *DbTransaction) DeleteObject(bucketName string, key []byte) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-	return bucket.Delete(key)
-}
-
-func (tx *DbTransaction) DeleteAllObjects(bucketName string, obj interface{}, matching func(o interface{}) (id int, ok bool)) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-
-	cursor := bucket.Cursor()
-	for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-		err := tx.conn.UnmarshalObject(v, &obj)
-		if err != nil {
-			return err
-		}
-
-		if id, ok := matching(obj); ok {
-			err := bucket.Delete(tx.conn.ConvertToKey(id))
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func (tx *DbTransaction) GetNextIdentifier(bucketName string) int {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-	id, err := bucket.NextSequence()
-	if err != nil {
-		log.Error().Err(err).Str("bucket", bucketName).Msg("failed to get the next identifer")
-
-		return 0
-	}
-
-	return int(id)
-}
-
-func (tx *DbTransaction) CreateObject(bucketName string, fn func(uint64) (int, interface{})) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-
-	seqId, _ := bucket.NextSequence()
-	id, obj := fn(seqId)
-
-	data, err := tx.conn.MarshalObject(obj)
-	if err != nil {
-		return err
-	}
-
-	return bucket.Put(tx.conn.ConvertToKey(int(id)), data)
-}
-
-func (tx *DbTransaction) CreateObjectWithId(bucketName string, id int, obj interface{}) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-	data, err := tx.conn.MarshalObject(obj)
-	if err != nil {
-		return err
-	}
-
-	return bucket.Put(tx.conn.ConvertToKey(id), data)
-}
-
-func (tx *DbTransaction) CreateObjectWithStringId(bucketName string, id []byte, obj interface{}) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-	data, err := tx.conn.MarshalObject(obj)
-	if err != nil {
-		return err
-	}
-
-	return bucket.Put(id, data)
-}
-
-func (tx *DbTransaction) GetAll(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-
-	cursor := bucket.Cursor()
-	for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-		err := tx.conn.UnmarshalObject(v, obj)
-		if err != nil {
-			return err
-		}
-
-		obj, err = append(obj)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (tx *DbTransaction) GetAllWithJsoniter(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	bucket := tx.tx.Bucket([]byte(bucketName))
-
-	cursor := bucket.Cursor()
-	for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-		err := tx.conn.UnmarshalObjectWithJsoniter(v, obj)
-		if err != nil {
-			return err
-		}
-
-		obj, err = append(obj)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (tx *DbTransaction) GetAllWithKeyPrefix(bucketName string, keyPrefix []byte, obj interface{}, append func(o interface{}) (interface{}, error)) error {
-	cursor := tx.tx.Bucket([]byte(bucketName)).Cursor()
-
-	for k, v := cursor.Seek(keyPrefix); k != nil && bytes.HasPrefix(k, keyPrefix); k, v = cursor.Next() {
-		err := tx.conn.UnmarshalObjectWithJsoniter(v, obj)
-		if err != nil {
-			return err
-		}
-
-		obj, err = append(obj)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/database/boltdb/tx_test.go

@@ -1,126 +0,0 @@
-package boltdb
-
-import (
-	"errors"
-	"testing"
-
-	portainer "github.com/portainer/portainer/api"
-	dserrors "github.com/portainer/portainer/api/dataservices/errors"
-)
-
-const testBucketName = "test-bucket"
-const testId = 1234
-
-type testStruct struct {
-	Key   string
-	Value string
-}
-
-func TestTxs(t *testing.T) {
-	conn := DbConnection{
-		Path: t.TempDir(),
-	}
-
-	err := conn.Open()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer conn.Close()
-
-	// Error propagation
-	err = conn.UpdateTx(func(tx portainer.Transaction) error {
-		return errors.New("this is an error")
-	})
-	if err == nil {
-		t.Fatal("an error was expected, got nil instead")
-	}
-
-	// Create an object
-	newObj := testStruct{
-		Key:   "key",
-		Value: "value",
-	}
-
-	err = conn.UpdateTx(func(tx portainer.Transaction) error {
-		err = tx.SetServiceName(testBucketName)
-		if err != nil {
-			return err
-		}
-
-		return tx.CreateObjectWithId(testBucketName, testId, newObj)
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	obj := testStruct{}
-	err = conn.ViewTx(func(tx portainer.Transaction) error {
-		return tx.GetObject(testBucketName, conn.ConvertToKey(testId), &obj)
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if obj.Key != newObj.Key || obj.Value != newObj.Value {
-		t.Fatalf("expected %s:%s, got %s:%s instead", newObj.Key, newObj.Value, obj.Key, obj.Value)
-	}
-
-	// Update an object
-	updatedObj := testStruct{
-		Key:   "updated-key",
-		Value: "updated-value",
-	}
-
-	err = conn.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.UpdateObject(testBucketName, conn.ConvertToKey(testId), &updatedObj)
-	})
-
-	err = conn.ViewTx(func(tx portainer.Transaction) error {
-		return tx.GetObject(testBucketName, conn.ConvertToKey(testId), &obj)
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if obj.Key != updatedObj.Key || obj.Value != updatedObj.Value {
-		t.Fatalf("expected %s:%s, got %s:%s instead", updatedObj.Key, updatedObj.Value, obj.Key, obj.Value)
-	}
-
-	// Delete an object
-	err = conn.UpdateTx(func(tx portainer.Transaction) error {
-		return tx.DeleteObject(testBucketName, conn.ConvertToKey(testId))
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = conn.ViewTx(func(tx portainer.Transaction) error {
-		return tx.GetObject(testBucketName, conn.ConvertToKey(testId), &obj)
-	})
-	if err != dserrors.ErrObjectNotFound {
-		t.Fatal(err)
-	}
-
-	// Get next identifier
-	err = conn.UpdateTx(func(tx portainer.Transaction) error {
-		id1 := tx.GetNextIdentifier(testBucketName)
-		id2 := tx.GetNextIdentifier(testBucketName)
-
-		if id1+1 != id2 {
-			return errors.New("unexpected identifier sequence")
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Try to write in a read transaction
-	err = conn.ViewTx(func(tx portainer.Transaction) error {
-		return tx.CreateObjectWithId(testBucketName, testId, newObj)
-	})
-	if err == nil {
-		t.Fatal("an error was expected, got nil instead")
-	}
-}

api/database/connection.go

@@ -1,38 +1,13 @@
-package portainer
+package database
 
 import (
 	"io"
 )
 
-type ReadTransaction interface {
-	GetObject(bucketName string, key []byte, object interface{}) error
-	GetAll(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error
-	GetAllWithJsoniter(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error
-	GetAllWithKeyPrefix(bucketName string, keyPrefix []byte, obj interface{}, append func(o interface{}) (interface{}, error)) error
-}
-
-type Transaction interface {
-	ReadTransaction
-
-	SetServiceName(bucketName string) error
-	UpdateObject(bucketName string, key []byte, object interface{}) error
-	DeleteObject(bucketName string, key []byte) error
-	CreateObject(bucketName string, fn func(uint64) (int, interface{})) error
-	CreateObjectWithId(bucketName string, id int, obj interface{}) error
-	CreateObjectWithStringId(bucketName string, id []byte, obj interface{}) error
-	DeleteAllObjects(bucketName string, obj interface{}, matching func(o interface{}) (id int, ok bool)) error
-	GetNextIdentifier(bucketName string) int
-}
-
 type Connection interface {
-	Transaction
-
 	Open() error
 	Close() error
 
-	UpdateTx(fn func(Transaction) error) error
-	ViewTx(fn func(Transaction) error) error
-
 	// write the db contents to filename as json (the schema needs defining)
 	ExportRaw(filename string) error
 
@@ -46,9 +21,19 @@ type Connection interface {
 	NeedsEncryptionMigration() (bool, error)
 	SetEncrypted(encrypted bool)
 
+	SetServiceName(bucketName string) error
+	GetObject(bucketName string, key []byte, object interface{}) error
+	UpdateObject(bucketName string, key []byte, object interface{}) error
+	DeleteObject(bucketName string, key []byte) error
+	DeleteAllObjects(bucketName string, matching func(o interface{}) (id int, ok bool)) error
+	GetNextIdentifier(bucketName string) int
+	CreateObject(bucketName string, fn func(uint64) (int, interface{})) error
+	CreateObjectWithId(bucketName string, id int, obj interface{}) error
+	CreateObjectWithSetSequence(bucketName string, id int, obj interface{}) error
+	GetAll(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error
+	GetAllWithJsoniter(bucketName string, obj interface{}, append func(o interface{}) (interface{}, error)) error
+	ConvertToKey(v int) []byte
+
 	BackupMetadata() (map[string]interface{}, error)
 	RestoreMetadata(s map[string]interface{}) error
-
-	UpdateObjectFunc(bucketName string, key []byte, object any, updateFn func()) error
-	ConvertToKey(v int) []byte
 }

api/database/database.go

@@ -3,12 +3,11 @@ package database
 import (
 	"fmt"
 
-	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/database/boltdb"
 )
 
 // NewDatabase should use config options to return a connection to the requested database
-func NewDatabase(storeType, storePath string, encryptionKey []byte) (connection portainer.Connection, err error) {
+func NewDatabase(storeType, storePath string, encryptionKey []byte) (connection Connection, err error) {
 	switch storeType {
 	case "boltdb":
 		return &boltdb.DbConnection{
@@ -16,6 +15,5 @@ func NewDatabase(storeType, storePath string, encryptionKey []byte) (connection
 			EncryptionKey: encryptionKey,
 		}, nil
 	}
-
-	return nil, fmt.Errorf("Unknown storage database: %s", storeType)
+	return nil, fmt.Errorf("unknown storage database: %s", storeType)
 }

api/database/models/version.go

@@ -1,8 +0,0 @@
-package models
-
-type Version struct {
-	SchemaVersion string
-	MigratorCount int
-	Edition       int
-	InstanceID    string
-}

api/database/types.go

@@ -0,0 +1,41 @@
+package database
+
+//TODO: as the dependencies get simpler, these should move to their respective dataservices
+
+// EndpointID represents an environment(endpoint) identifier
+type EndpointID int
+
+// UserAccessPolicies represent the association of an access policy and a user
+type UserAccessPolicies map[UserID]AccessPolicy
+
+// TeamAccessPolicies represent the association of an access policy and a team
+type TeamAccessPolicies map[TeamID]AccessPolicy
+
+// TLSConfiguration represents a TLS configuration
+type TLSConfiguration struct {
+	// Use TLS
+	TLS bool `json:"TLS" example:"true"`
+	// Skip the verification of the server TLS certificate
+	TLSSkipVerify bool `json:"TLSSkipVerify" example:"false"`
+	// Path to the TLS CA certificate file
+	TLSCACertPath string `json:"TLSCACert,omitempty" example:"/data/tls/ca.pem"`
+	// Path to the TLS client certificate file
+	TLSCertPath string `json:"TLSCert,omitempty" example:"/data/tls/cert.pem"`
+	// Path to the TLS client key file
+	TLSKeyPath string `json:"TLSKey,omitempty" example:"/data/tls/key.pem"`
+}
+
+// TeamID represents a team identifier
+type TeamID int
+
+// UserID represents a user identifier
+type UserID int
+
+// AccessPolicy represent a policy that can be associated to a user or team
+type AccessPolicy struct {
+	// Role identifier. Reference the role that will be associated to this access policy
+	RoleID RoleID `json:"RoleId" example:"1"`
+}
+
+// RoleID represents a role identifier
+type RoleID int

api/dataservices/apikeyrepository/apikeyrepository.go

@@ -3,11 +3,11 @@ package apikeyrepository
 import (
 	"bytes"
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -17,11 +17,11 @@ const (
 
 // Service represents a service for managing api-key data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -33,7 +33,7 @@ func NewService(connection portainer.Connection) (*Service, error) {
 }
 
 // GetAPIKeysByUserID returns a slice containing all the APIKeys a user has access to.
-func (service *Service) GetAPIKeysByUserID(userID portainer.UserID) ([]portainer.APIKey, error) {
+func (service *Service) GetAPIKeysByUserID(userID database.UserID) ([]portainer.APIKey, error) {
 	var result = make([]portainer.APIKey, 0)
 
 	err := service.connection.GetAll(
@@ -42,14 +42,12 @@ func (service *Service) GetAPIKeysByUserID(userID portainer.UserID) ([]portainer
 		func(obj interface{}) (interface{}, error) {
 			record, ok := obj.(*portainer.APIKey)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to APIKey object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to APIKey object")
 				return nil, fmt.Errorf("Failed to convert to APIKey object: %s", obj)
 			}
-
 			if record.UserID == userID {
 				result = append(result, *record)
 			}
-
 			return &portainer.APIKey{}, nil
 		})
 
@@ -67,21 +65,18 @@ func (service *Service) GetAPIKeyByDigest(digest []byte) (*portainer.APIKey, err
 		func(obj interface{}) (interface{}, error) {
 			key, ok := obj.(*portainer.APIKey)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to APIKey object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to APIKey object")
 				return nil, fmt.Errorf("Failed to convert to APIKey object: %s", obj)
 			}
 			if bytes.Equal(key.Digest, digest) {
 				k = key
 				return nil, stop
 			}
-
 			return &portainer.APIKey{}, nil
 		})
-
 	if err == stop {
 		return k, nil
 	}
-
 	if err == nil {
 		return nil, errors.ErrObjectNotFound
 	}

api/dataservices/customtemplate/customtemplate.go

@@ -2,10 +2,10 @@ package customtemplate
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing custom template data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -45,11 +45,10 @@ func (service *Service) CustomTemplates() ([]portainer.CustomTemplate, error) {
 			//var tag portainer.Tag
 			customTemplate, ok := obj.(*portainer.CustomTemplate)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to CustomTemplate object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to CustomTemplate object")
 				return nil, fmt.Errorf("Failed to convert to CustomTemplate object: %s", obj)
 			}
 			customTemplates = append(customTemplates, *customTemplate)
-
 			return &portainer.CustomTemplate{}, nil
 		})
 

api/dataservices/dockerhub/dockerhub.go

@@ -1,7 +1,7 @@
 package dockerhub
 
 import (
-	portainer "github.com/portainer/portainer/api"
+	portainer "github.com/portainer/portainer/api/database"
 )
 
 const (
@@ -10,6 +10,8 @@ const (
 	dockerHubKey = "DOCKERHUB"
 )
 
+// TODO: does this get used anymore?
+
 // Service represents a service for managing Dockerhub data.
 type Service struct {
 	connection portainer.Connection
@@ -32,8 +34,8 @@ func NewService(connection portainer.Connection) (*Service, error) {
 }
 
 // DockerHub returns the DockerHub object.
-func (service *Service) DockerHub() (*portainer.DockerHub, error) {
-	var dockerhub portainer.DockerHub
+func (service *Service) DockerHub() (*DockerHub, error) {
+	var dockerhub DockerHub
 
 	err := service.connection.GetObject(BucketName, []byte(dockerHubKey), &dockerhub)
 	if err != nil {
@@ -44,6 +46,16 @@ func (service *Service) DockerHub() (*portainer.DockerHub, error) {
 }
 
 // UpdateDockerHub updates a DockerHub object.
-func (service *Service) UpdateDockerHub(dockerhub *portainer.DockerHub) error {
+func (service *Service) UpdateDockerHub(dockerhub *DockerHub) error {
 	return service.connection.UpdateObject(BucketName, []byte(dockerHubKey), dockerhub)
 }
+
+// DockerHub represents all the required information to connect and use the Docker Hub
+type DockerHub struct {
+	// Is authentication against DockerHub enabled
+	Authentication bool `json:"Authentication" example:"true"`
+	// Username used to authenticate against the DockerHub
+	Username string `json:"Username" example:"user"`
+	// Password used to authenticate against the DockerHub
+	Password string `json:"Password,omitempty" example:"passwd"`
+}

api/dataservices/edgegroup/edgegroup.go

@@ -1,15 +1,21 @@
 package edgegroup
 
 import (
+	"fmt"
+	"github.com/portainer/portainer/api/database"
+
 	portainer "github.com/portainer/portainer/api"
+	"github.com/sirupsen/logrus"
 )
 
-// BucketName represents the name of the bucket where this service stores data.
-const BucketName = "edgegroups"
+const (
+	// BucketName represents the name of the bucket where this service stores data.
+	BucketName = "edgegroups"
+)
 
 // Service represents a service for managing Edge group data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -17,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -28,65 +34,58 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
-}
-
-// EdgeGroups return a slice containing all the Edge groups.
+// EdgeGroups return an array containing all the Edge groups.
 func (service *Service) EdgeGroups() ([]portainer.EdgeGroup, error) {
-	var groups []portainer.EdgeGroup
-	var err error
+	var groups = make([]portainer.EdgeGroup, 0)
 
-	err = service.connection.ViewTx(func(tx portainer.Transaction) error {
-		groups, err = service.Tx(tx).EdgeGroups()
-		return err
-	})
+	err := service.connection.GetAllWithJsoniter(
+		BucketName,
+		&portainer.EdgeGroup{},
+		func(obj interface{}) (interface{}, error) {
+			group, ok := obj.(*portainer.EdgeGroup)
+			if !ok {
+				logrus.WithField("obj", obj).Errorf("Failed to convert to EdgeGroup object")
+				return nil, fmt.Errorf("Failed to convert to EdgeGroup object: %s", obj)
+			}
+			groups = append(groups, *group)
+			return &portainer.EdgeGroup{}, nil
+		})
 
 	return groups, err
 }
 
 // EdgeGroup returns an Edge group by ID.
 func (service *Service) EdgeGroup(ID portainer.EdgeGroupID) (*portainer.EdgeGroup, error) {
-	var group *portainer.EdgeGroup
-	var err error
+	var group portainer.EdgeGroup
+	identifier := service.connection.ConvertToKey(int(ID))
 
-	err = service.connection.ViewTx(func(tx portainer.Transaction) error {
-		group, err = service.Tx(tx).EdgeGroup(ID)
-		return err
-	})
+	err := service.connection.GetObject(BucketName, identifier, &group)
+	if err != nil {
+		return nil, err
+	}
 
-	return group, err
+	return &group, nil
 }
 
-// UpdateEdgeGroup updates an edge group.
+// UpdateEdgeGroup updates an Edge group.
 func (service *Service) UpdateEdgeGroup(ID portainer.EdgeGroupID, group *portainer.EdgeGroup) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.UpdateObject(BucketName, identifier, group)
 }
 
-// Deprecated: UpdateEdgeGroupFunc updates an edge group inside a transaction avoiding data races.
-func (service *Service) UpdateEdgeGroupFunc(ID portainer.EdgeGroupID, updateFunc func(edgeGroup *portainer.EdgeGroup)) error {
-	id := service.connection.ConvertToKey(int(ID))
-	edgeGroup := &portainer.EdgeGroup{}
-
-	return service.connection.UpdateObjectFunc(BucketName, id, edgeGroup, func() {
-		updateFunc(edgeGroup)
-	})
-}
-
 // DeleteEdgeGroup deletes an Edge group.
 func (service *Service) DeleteEdgeGroup(ID portainer.EdgeGroupID) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).DeleteEdgeGroup(ID)
-	})
+	identifier := service.connection.ConvertToKey(int(ID))
+	return service.connection.DeleteObject(BucketName, identifier)
 }
 
 // CreateEdgeGroup assign an ID to a new Edge group and saves it.
 func (service *Service) Create(group *portainer.EdgeGroup) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).Create(group)
-	})
+	return service.connection.CreateObject(
+		BucketName,
+		func(id uint64) (int, interface{}) {
+			group.ID = portainer.EdgeGroupID(id)
+			return int(group.ID), group
+		},
+	)
 }

api/dataservices/edgegroup/tx.go

@@ -1,80 +0,0 @@
-package edgegroup
-
-import (
-	"errors"
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-// EdgeGroups return a slice containing all the Edge groups.
-func (service ServiceTx) EdgeGroups() ([]portainer.EdgeGroup, error) {
-	var groups = make([]portainer.EdgeGroup, 0)
-
-	err := service.tx.GetAllWithJsoniter(
-		BucketName,
-		&portainer.EdgeGroup{},
-		func(obj interface{}) (interface{}, error) {
-			group, ok := obj.(*portainer.EdgeGroup)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeGroup object")
-				return nil, fmt.Errorf("Failed to convert to EdgeGroup object: %s", obj)
-			}
-			groups = append(groups, *group)
-
-			return &portainer.EdgeGroup{}, nil
-		})
-
-	return groups, err
-}
-
-// EdgeGroup returns an Edge group by ID.
-func (service ServiceTx) EdgeGroup(ID portainer.EdgeGroupID) (*portainer.EdgeGroup, error) {
-	var group portainer.EdgeGroup
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.GetObject(BucketName, identifier, &group)
-	if err != nil {
-		return nil, err
-	}
-
-	return &group, nil
-}
-
-// UpdateEdgeGroup updates an edge group.
-func (service ServiceTx) UpdateEdgeGroup(ID portainer.EdgeGroupID, group *portainer.EdgeGroup) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-	return service.tx.UpdateObject(BucketName, identifier, group)
-}
-
-// UpdateEdgeGroupFunc is a no-op inside a transaction.
-func (service ServiceTx) UpdateEdgeGroupFunc(ID portainer.EdgeGroupID, updateFunc func(edgeGroup *portainer.EdgeGroup)) error {
-	return errors.New("cannot be called inside a transaction")
-}
-
-// DeleteEdgeGroup deletes an Edge group.
-func (service ServiceTx) DeleteEdgeGroup(ID portainer.EdgeGroupID) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-	return service.tx.DeleteObject(BucketName, identifier)
-}
-
-func (service ServiceTx) Create(group *portainer.EdgeGroup) error {
-	return service.tx.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			group.ID = portainer.EdgeGroupID(id)
-			return int(group.ID), group
-		},
-	)
-}

api/dataservices/edgejob/edgejob.go

@@ -2,18 +2,18 @@ package edgejob
 
 import (
 	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/portainer/portainer/api/database"
+	"github.com/sirupsen/logrus"
 )
 
-// BucketName represents the name of the bucket where this service stores data.
-const BucketName = "edgejobs"
+const (
+	// BucketName represents the name of the bucket where this service stores data.
+	BucketName = "edgejobs"
+)
 
 // Service represents a service for managing edge jobs data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -21,7 +21,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -32,38 +32,30 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
-}
-
 // EdgeJobs returns a list of Edge jobs
-func (service *Service) EdgeJobs() ([]portainer.EdgeJob, error) {
-	var edgeJobs = make([]portainer.EdgeJob, 0)
+func (service *Service) EdgeJobs() ([]EdgeJob, error) {
+	var edgeJobs = make([]EdgeJob, 0)
 
 	err := service.connection.GetAll(
 		BucketName,
-		&portainer.EdgeJob{},
+		&EdgeJob{},
 		func(obj interface{}) (interface{}, error) {
-			job, ok := obj.(*portainer.EdgeJob)
+			//var tag portainer.Tag
+			job, ok := obj.(*EdgeJob)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeJob object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to EdgeJob object")
 				return nil, fmt.Errorf("Failed to convert to EdgeJob object: %s", obj)
 			}
-
 			edgeJobs = append(edgeJobs, *job)
-
-			return &portainer.EdgeJob{}, nil
+			return &EdgeJob{}, nil
 		})
 
 	return edgeJobs, err
 }
 
 // EdgeJob returns an Edge job by ID
-func (service *Service) EdgeJob(ID portainer.EdgeJobID) (*portainer.EdgeJob, error) {
-	var edgeJob portainer.EdgeJob
+func (service *Service) EdgeJob(ID EdgeJobID) (*EdgeJob, error) {
+	var edgeJob EdgeJob
 	identifier := service.connection.ConvertToKey(int(ID))
 
 	err := service.connection.GetObject(BucketName, identifier, &edgeJob)
@@ -74,35 +66,25 @@ func (service *Service) EdgeJob(ID portainer.EdgeJobID) (*portainer.EdgeJob, err
 	return &edgeJob, nil
 }
 
-// Create creates a new EdgeJob
-func (service *Service) Create(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error {
-	edgeJob.ID = ID
-
-	return service.connection.CreateObjectWithId(
+// CreateEdgeJob creates a new Edge job
+func (service *Service) Create(edgeJob *EdgeJob) error {
+	return service.connection.CreateObject(
 		BucketName,
-		int(edgeJob.ID),
-		edgeJob,
+		func(id uint64) (int, interface{}) {
+			edgeJob.ID = EdgeJobID(id)
+			return int(edgeJob.ID), edgeJob
+		},
 	)
 }
 
-// Deprecated: use UpdateEdgeJobFunc instead
-func (service *Service) UpdateEdgeJob(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error {
+// UpdateEdgeJob updates an Edge job by ID
+func (service *Service) UpdateEdgeJob(ID EdgeJobID, edgeJob *EdgeJob) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.UpdateObject(BucketName, identifier, edgeJob)
 }
 
-// UpdateEdgeJobFunc updates an edge job inside a transaction avoiding data races.
-func (service *Service) UpdateEdgeJobFunc(ID portainer.EdgeJobID, updateFunc func(edgeJob *portainer.EdgeJob)) error {
-	id := service.connection.ConvertToKey(int(ID))
-	edgeJob := &portainer.EdgeJob{}
-
-	return service.connection.UpdateObjectFunc(BucketName, id, edgeJob, func() {
-		updateFunc(edgeJob)
-	})
-}
-
 // DeleteEdgeJob deletes an Edge job
-func (service *Service) DeleteEdgeJob(ID portainer.EdgeJobID) error {
+func (service *Service) DeleteEdgeJob(ID EdgeJobID) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.DeleteObject(BucketName, identifier)
 }
@@ -111,3 +93,28 @@ func (service *Service) DeleteEdgeJob(ID portainer.EdgeJobID) error {
 func (service *Service) GetNextIdentifier() int {
 	return service.connection.GetNextIdentifier(BucketName)
 }
+
+// EdgeJob represents a job that can run on Edge environments(endpoints).
+type EdgeJob struct {
+	// EdgeJob Identifier
+	ID             EdgeJobID                                   `json:"Id" example:"1"`
+	Created        int64                                       `json:"Created"`
+	CronExpression string                                      `json:"CronExpression"`
+	Endpoints      map[database.EndpointID]EdgeJobEndpointMeta `json:"Endpoints"`
+	Name           string                                      `json:"Name"`
+	ScriptPath     string                                      `json:"ScriptPath"`
+	Recurring      bool                                        `json:"Recurring"`
+	Version        int                                         `json:"Version"`
+}
+
+// EdgeJobEndpointMeta represents a meta data object for an Edge job and Environment(Endpoint) relation
+type EdgeJobEndpointMeta struct {
+	LogsStatus  EdgeJobLogsStatus
+	CollectLogs bool
+}
+
+// EdgeJobID represents an Edge job identifier
+type EdgeJobID int
+
+// EdgeJobLogsStatus represent status of logs collection job
+type EdgeJobLogsStatus int

api/dataservices/edgejob/tx.go

@@ -1,84 +0,0 @@
-package edgejob
-
-import (
-	"errors"
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-// EdgeJobs returns a list of Edge jobs
-func (service ServiceTx) EdgeJobs() ([]portainer.EdgeJob, error) {
-	var edgeJobs = make([]portainer.EdgeJob, 0)
-
-	err := service.tx.GetAll(
-		BucketName,
-		&portainer.EdgeJob{},
-		func(obj interface{}) (interface{}, error) {
-			job, ok := obj.(*portainer.EdgeJob)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeJob object")
-				return nil, fmt.Errorf("failed to convert to EdgeJob object: %s", obj)
-			}
-
-			edgeJobs = append(edgeJobs, *job)
-
-			return &portainer.EdgeJob{}, nil
-		})
-
-	return edgeJobs, err
-}
-
-// EdgeJob returns an Edge job by ID
-func (service ServiceTx) EdgeJob(ID portainer.EdgeJobID) (*portainer.EdgeJob, error) {
-	var edgeJob portainer.EdgeJob
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.GetObject(BucketName, identifier, &edgeJob)
-	if err != nil {
-		return nil, err
-	}
-
-	return &edgeJob, nil
-}
-
-// Create creates a new EdgeJob
-func (service ServiceTx) Create(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error {
-	edgeJob.ID = ID
-
-	return service.tx.CreateObjectWithId(BucketName, int(edgeJob.ID), edgeJob)
-}
-
-// UpdateEdgeJob updates an edge job
-func (service ServiceTx) UpdateEdgeJob(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-	return service.tx.UpdateObject(BucketName, identifier, edgeJob)
-}
-
-// UpdateEdgeJobFunc is a no-op inside a transaction.
-func (service ServiceTx) UpdateEdgeJobFunc(ID portainer.EdgeJobID, updateFunc func(edgeJob *portainer.EdgeJob)) error {
-	return errors.New("cannot be called inside a transaction")
-}
-
-// DeleteEdgeJob deletes an Edge job
-func (service ServiceTx) DeleteEdgeJob(ID portainer.EdgeJobID) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	return service.tx.DeleteObject(BucketName, identifier)
-}
-
-// GetNextIdentifier returns the next identifier for an environment(endpoint).
-func (service ServiceTx) GetNextIdentifier() int {
-	return service.tx.GetNextIdentifier(BucketName)
-}

api/dataservices/edgestack/edgestack.go

@@ -2,22 +2,20 @@ package edgestack
 
 import (
 	"fmt"
-	"sync"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
-// BucketName represents the name of the bucket where this service stores data.
-const BucketName = "edge_stack"
+const (
+	// BucketName represents the name of the bucket where this service stores data.
+	BucketName = "edge_stack"
+)
 
 // Service represents a service for managing Edge stack data.
 type Service struct {
-	connection          portainer.Connection
-	idxVersion          map[portainer.EdgeStackID]int
-	mu                  sync.RWMutex
-	cacheInvalidationFn func(portainer.EdgeStackID)
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -25,39 +23,15 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection, cacheInvalidationFn func(portainer.EdgeStackID)) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
 	}
 
-	s := &Service{
-		connection:          connection,
-		idxVersion:          make(map[portainer.EdgeStackID]int),
-		cacheInvalidationFn: cacheInvalidationFn,
-	}
-
-	if s.cacheInvalidationFn == nil {
-		s.cacheInvalidationFn = func(portainer.EdgeStackID) {}
-	}
-
-	es, err := s.EdgeStacks()
-	if err != nil {
-		return nil, err
-	}
-
-	for _, e := range es {
-		s.idxVersion[e.ID] = e.Version
-	}
-
-	return s, nil
-}
-
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
+	return &Service{
+		connection: connection,
+	}, nil
 }
 
 // EdgeStacks returns an array containing all edge stacks
@@ -68,14 +42,13 @@ func (service *Service) EdgeStacks() ([]portainer.EdgeStack, error) {
 		BucketName,
 		&portainer.EdgeStack{},
 		func(obj interface{}) (interface{}, error) {
+			//var tag portainer.Tag
 			stack, ok := obj.(*portainer.EdgeStack)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeStack object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to EdgeStack object")
 				return nil, fmt.Errorf("Failed to convert to EdgeStack object: %s", obj)
 			}
-
 			stacks = append(stacks, *stack)
-
 			return &portainer.EdgeStack{}, nil
 		})
 
@@ -95,87 +68,28 @@ func (service *Service) EdgeStack(ID portainer.EdgeStackID) (*portainer.EdgeStac
 	return &stack, nil
 }
 
-// EdgeStackVersion returns the version of the given edge stack ID directly from an in-memory index
-func (service *Service) EdgeStackVersion(ID portainer.EdgeStackID) (int, bool) {
-	service.mu.RLock()
-	v, ok := service.idxVersion[ID]
-	service.mu.RUnlock()
-
-	return v, ok
-}
-
 // CreateEdgeStack saves an Edge stack object to db.
 func (service *Service) Create(id portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error {
+
 	edgeStack.ID = id
 
-	err := service.connection.CreateObjectWithId(
+	return service.connection.CreateObjectWithId(
 		BucketName,
 		int(edgeStack.ID),
 		edgeStack,
 	)
-	if err != nil {
-		return err
-	}
-
-	service.mu.Lock()
-	service.idxVersion[id] = edgeStack.Version
-	service.cacheInvalidationFn(id)
-	service.mu.Unlock()
-
-	return nil
 }
 
-// Deprecated: Use UpdateEdgeStackFunc instead.
+// UpdateEdgeStack updates an Edge stack.
 func (service *Service) UpdateEdgeStack(ID portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error {
-	service.mu.Lock()
-	defer service.mu.Unlock()
-
 	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.UpdateObject(BucketName, identifier, edgeStack)
-	if err != nil {
-		return err
-	}
-
-	service.idxVersion[ID] = edgeStack.Version
-	service.cacheInvalidationFn(ID)
-
-	return nil
-}
-
-// UpdateEdgeStackFunc updates an Edge stack inside a transaction avoiding data races.
-func (service *Service) UpdateEdgeStackFunc(ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error {
-	id := service.connection.ConvertToKey(int(ID))
-	edgeStack := &portainer.EdgeStack{}
-
-	service.mu.Lock()
-	defer service.mu.Unlock()
-
-	return service.connection.UpdateObjectFunc(BucketName, id, edgeStack, func() {
-		updateFunc(edgeStack)
-
-		service.idxVersion[ID] = edgeStack.Version
-		service.cacheInvalidationFn(ID)
-	})
+	return service.connection.UpdateObject(BucketName, identifier, edgeStack)
 }
 
 // DeleteEdgeStack deletes an Edge stack.
 func (service *Service) DeleteEdgeStack(ID portainer.EdgeStackID) error {
-	service.mu.Lock()
-	defer service.mu.Unlock()
-
 	identifier := service.connection.ConvertToKey(int(ID))
-
-	err := service.connection.DeleteObject(BucketName, identifier)
-	if err != nil {
-		return err
-	}
-
-	delete(service.idxVersion, ID)
-
-	service.cacheInvalidationFn(ID)
-
-	return nil
+	return service.connection.DeleteObject(BucketName, identifier)
 }
 
 // GetNextIdentifier returns the next identifier for an environment(endpoint).

api/dataservices/edgestack/tx.go

@@ -1,131 +0,0 @@
-package edgestack
-
-import (
-	"errors"
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-// EdgeStacks returns an array containing all edge stacks
-func (service ServiceTx) EdgeStacks() ([]portainer.EdgeStack, error) {
-	var stacks = make([]portainer.EdgeStack, 0)
-
-	err := service.tx.GetAll(
-		BucketName,
-		&portainer.EdgeStack{},
-		func(obj interface{}) (interface{}, error) {
-			stack, ok := obj.(*portainer.EdgeStack)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EdgeStack object")
-				return nil, fmt.Errorf("Failed to convert to EdgeStack object: %s", obj)
-			}
-
-			stacks = append(stacks, *stack)
-
-			return &portainer.EdgeStack{}, nil
-		})
-
-	return stacks, err
-}
-
-// EdgeStack returns an Edge stack by ID.
-func (service ServiceTx) EdgeStack(ID portainer.EdgeStackID) (*portainer.EdgeStack, error) {
-	var stack portainer.EdgeStack
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.GetObject(BucketName, identifier, &stack)
-	if err != nil {
-		return nil, err
-	}
-
-	return &stack, nil
-}
-
-// EdgeStackVersion returns the version of the given edge stack ID directly from an in-memory index
-func (service ServiceTx) EdgeStackVersion(ID portainer.EdgeStackID) (int, bool) {
-	service.service.mu.RLock()
-	v, ok := service.service.idxVersion[ID]
-	service.service.mu.RUnlock()
-
-	return v, ok
-}
-
-// CreateEdgeStack saves an Edge stack object to db.
-func (service ServiceTx) Create(id portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error {
-	edgeStack.ID = id
-
-	err := service.tx.CreateObjectWithId(
-		BucketName,
-		int(edgeStack.ID),
-		edgeStack,
-	)
-	if err != nil {
-		return err
-	}
-
-	service.service.mu.Lock()
-	service.service.idxVersion[id] = edgeStack.Version
-	service.service.cacheInvalidationFn(id)
-	service.service.mu.Unlock()
-
-	return nil
-}
-
-// UpdateEdgeStack updates an Edge stack.
-func (service ServiceTx) UpdateEdgeStack(ID portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error {
-	service.service.mu.Lock()
-	defer service.service.mu.Unlock()
-
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.UpdateObject(BucketName, identifier, edgeStack)
-	if err != nil {
-		return err
-	}
-
-	service.service.idxVersion[ID] = edgeStack.Version
-	service.service.cacheInvalidationFn(ID)
-
-	return nil
-}
-
-// UpdateEdgeStackFunc is a no-op inside a transaction.
-func (service ServiceTx) UpdateEdgeStackFunc(ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error {
-	return errors.New("cannot be called inside a transaction")
-}
-
-// DeleteEdgeStack deletes an Edge stack.
-func (service ServiceTx) DeleteEdgeStack(ID portainer.EdgeStackID) error {
-	service.service.mu.Lock()
-	defer service.service.mu.Unlock()
-
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.DeleteObject(BucketName, identifier)
-	if err != nil {
-		return err
-	}
-
-	delete(service.service.idxVersion, ID)
-
-	service.service.cacheInvalidationFn(ID)
-
-	return nil
-}
-
-// GetNextIdentifier returns the next identifier for an environment(endpoint).
-func (service ServiceTx) GetNextIdentifier() int {
-	return service.tx.GetNextIdentifier(BucketName)
-}

api/dataservices/endpoint/endpoint.go

@@ -1,21 +1,20 @@
 package endpoint
 
 import (
-	"sync"
-	"time"
-
+	"fmt"
 	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/database"
+	"github.com/sirupsen/logrus"
 )
 
-// BucketName represents the name of the bucket where this service stores data.
-const BucketName = "endpoints"
+const (
+	// BucketName represents the name of the bucket where this service stores data.
+	BucketName = "endpoints"
+)
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
-	mu         sync.RWMutex
-	idxEdgeID  map[string]portainer.EndpointID
-	heartbeats sync.Map
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,131 +22,116 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
 	}
 
-	s := &Service{
+	return &Service{
 		connection: connection,
-		idxEdgeID:  make(map[string]portainer.EndpointID),
-	}
-
-	es, err := s.Endpoints()
-	if err != nil {
-		return nil, err
-	}
-
-	for _, e := range es {
-		if len(e.EdgeID) > 0 {
-			s.idxEdgeID[e.EdgeID] = e.ID
-		}
-
-		s.heartbeats.Store(e.ID, e.LastCheckInDate)
-	}
-
-	return s, nil
-}
-
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
+	}, nil
 }
 
 // Endpoint returns an environment(endpoint) by ID.
-func (service *Service) Endpoint(ID portainer.EndpointID) (*portainer.Endpoint, error) {
-	var endpoint *portainer.Endpoint
-	var err error
+func (service *Service) Endpoint(ID database.EndpointID) (*portainer.Endpoint, error) {
+	var endpoint portainer.Endpoint
+	identifier := service.connection.ConvertToKey(int(ID))
 
-	err = service.connection.ViewTx(func(tx portainer.Transaction) error {
-		endpoint, err = service.Tx(tx).Endpoint(ID)
-		return err
-	})
+	err := service.connection.GetObject(BucketName, identifier, &endpoint)
 	if err != nil {
 		return nil, err
 	}
 
-	endpoint.LastCheckInDate, _ = service.Heartbeat(ID)
-
-	return endpoint, nil
+	return &endpoint, nil
 }
 
 // UpdateEndpoint updates an environment(endpoint).
-func (service *Service) UpdateEndpoint(ID portainer.EndpointID, endpoint *portainer.Endpoint) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).UpdateEndpoint(ID, endpoint)
-	})
+func (service *Service) UpdateEndpoint(ID database.EndpointID, endpoint *portainer.Endpoint) error {
+	identifier := service.connection.ConvertToKey(int(ID))
+	return service.connection.UpdateObject(BucketName, identifier, endpoint)
 }
 
 // DeleteEndpoint deletes an environment(endpoint).
-func (service *Service) DeleteEndpoint(ID portainer.EndpointID) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).DeleteEndpoint(ID)
-	})
+func (service *Service) DeleteEndpoint(ID database.EndpointID) error {
+	identifier := service.connection.ConvertToKey(int(ID))
+	return service.connection.DeleteObject(BucketName, identifier)
 }
 
 // Endpoints return an array containing all the environments(endpoints).
 func (service *Service) Endpoints() ([]portainer.Endpoint, error) {
-	var endpoints []portainer.Endpoint
-	var err error
+	var endpoints = make([]portainer.Endpoint, 0)
 
-	err = service.connection.ViewTx(func(tx portainer.Transaction) error {
-		endpoints, err = service.Tx(tx).Endpoints()
-		return err
-	})
+	err := service.connection.GetAllWithJsoniter(
+		BucketName,
+		&portainer.Endpoint{},
+		func(obj interface{}) (interface{}, error) {
+			endpoint, ok := obj.(*portainer.Endpoint)
+			if !ok {
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Endpoint object")
+				return nil, fmt.Errorf("failed to convert to Endpoint object: %s", obj)
+			}
+			endpoints = append(endpoints, *endpoint)
+			return &portainer.Endpoint{}, nil
+		})
 
-	if err != nil {
-		return endpoints, err
-	}
-
-	for i, e := range endpoints {
-		t, _ := service.Heartbeat(e.ID)
-		endpoints[i].LastCheckInDate = t
-	}
-
-	return endpoints, nil
-}
-
-// EndpointIDByEdgeID returns the EndpointID from the given EdgeID using an in-memory index
-func (service *Service) EndpointIDByEdgeID(edgeID string) (portainer.EndpointID, bool) {
-	service.mu.RLock()
-	endpointID, ok := service.idxEdgeID[edgeID]
-	service.mu.RUnlock()
-
-	return endpointID, ok
-}
-
-func (service *Service) Heartbeat(endpointID portainer.EndpointID) (int64, bool) {
-	if t, ok := service.heartbeats.Load(endpointID); ok {
-		return t.(int64), true
-	}
-
-	return 0, false
-}
-
-func (service *Service) UpdateHeartbeat(endpointID portainer.EndpointID) {
-	service.heartbeats.Store(endpointID, time.Now().Unix())
+	return endpoints, err
 }
 
 // CreateEndpoint assign an ID to a new environment(endpoint) and saves it.
 func (service *Service) Create(endpoint *portainer.Endpoint) error {
-	return service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		return service.Tx(tx).Create(endpoint)
-	})
+	if int(endpoint.ID) == 0 {
+		// TODO: hopefully this can become the only path
+		endpoint.ID = database.EndpointID(service.getNextIdentifier())
+	}
+	return service.connection.CreateObjectWithSetSequence(BucketName, int(endpoint.ID), endpoint)
 }
 
 // GetNextIdentifier returns the next identifier for an environment(endpoint).
-func (service *Service) GetNextIdentifier() int {
-	var identifier int
-
-	service.connection.UpdateTx(func(tx portainer.Transaction) error {
-		identifier = service.Tx(tx).GetNextIdentifier()
-
-		return nil
-	})
-
-	return identifier
+func (service *Service) getNextIdentifier() int {
+	return service.connection.GetNextIdentifier(BucketName)
+}
+
+func (service *Service) NewDefault() *portainer.Endpoint {
+	return &portainer.Endpoint{
+		//ID:                 0,
+		//Name:               "primary",
+		//URL:                *flags.EndpointURL,
+		//GroupID:            portainer.EndpointGroupID(1),
+		//Type:               portainer.DockerEnvironment,
+		TLSConfig: database.TLSConfiguration{
+			TLS: false,
+		},
+		UserAccessPolicies: database.UserAccessPolicies{},
+		TeamAccessPolicies: database.TeamAccessPolicies{},
+		TagIDs:             []portainer.TagID{},
+		Status:             portainer.EndpointStatusUp,
+		Snapshots:          []portainer.DockerSnapshot{},
+		Kubernetes:         kubernetesDefault(),
+
+		SecuritySettings: portainer.EndpointSecuritySettings{
+			AllowVolumeBrowserForRegularUsers: false,
+			EnableHostManagementFeatures:      false,
+
+			AllowSysctlSettingForRegularUsers:         true,
+			AllowBindMountsForRegularUsers:            true,
+			AllowPrivilegedModeForRegularUsers:        true,
+			AllowHostNamespaceForRegularUsers:         true,
+			AllowContainerCapabilitiesForRegularUsers: true,
+			AllowDeviceMappingForRegularUsers:         true,
+			AllowStackManagementForRegularUsers:       true,
+		},
+	}
+}
+
+func kubernetesDefault() portainer.KubernetesData {
+	return portainer.KubernetesData{
+		Configuration: portainer.KubernetesConfiguration{
+			UseLoadBalancer:  false,
+			UseServerMetrics: false,
+			StorageClasses:   []portainer.KubernetesStorageClassConfig{},
+			IngressClasses:   []portainer.KubernetesIngressClassConfig{},
+		},
+		Snapshots: []portainer.KubernetesSnapshot{},
+	}
 }

api/dataservices/endpoint/tx.go

@@ -1,137 +0,0 @@
-package endpoint
-
-import (
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/edge/cache"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-// Endpoint returns an environment(endpoint) by ID.
-func (service ServiceTx) Endpoint(ID portainer.EndpointID) (*portainer.Endpoint, error) {
-	var endpoint portainer.Endpoint
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.GetObject(BucketName, identifier, &endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	return &endpoint, nil
-}
-
-// UpdateEndpoint updates an environment(endpoint).
-func (service ServiceTx) UpdateEndpoint(ID portainer.EndpointID, endpoint *portainer.Endpoint) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.UpdateObject(BucketName, identifier, endpoint)
-	if err != nil {
-		return err
-	}
-
-	service.service.mu.Lock()
-	if len(endpoint.EdgeID) > 0 {
-		service.service.idxEdgeID[endpoint.EdgeID] = ID
-	}
-	service.service.heartbeats.Store(ID, endpoint.LastCheckInDate)
-	service.service.mu.Unlock()
-
-	cache.Del(endpoint.ID)
-
-	return nil
-}
-
-// DeleteEndpoint deletes an environment(endpoint).
-func (service ServiceTx) DeleteEndpoint(ID portainer.EndpointID) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.DeleteObject(BucketName, identifier)
-	if err != nil {
-		return err
-	}
-
-	service.service.mu.Lock()
-	for edgeID, endpointID := range service.service.idxEdgeID {
-		if endpointID == ID {
-			delete(service.service.idxEdgeID, edgeID)
-			break
-		}
-	}
-	service.service.heartbeats.Delete(ID)
-	service.service.mu.Unlock()
-
-	cache.Del(ID)
-
-	return nil
-}
-
-// Endpoints return an array containing all the environments(endpoints).
-func (service ServiceTx) Endpoints() ([]portainer.Endpoint, error) {
-	var endpoints = make([]portainer.Endpoint, 0)
-
-	err := service.tx.GetAllWithJsoniter(
-		BucketName,
-		&portainer.Endpoint{},
-		func(obj interface{}) (interface{}, error) {
-			endpoint, ok := obj.(*portainer.Endpoint)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Endpoint object")
-				return nil, fmt.Errorf("failed to convert to Endpoint object: %s", obj)
-			}
-
-			endpoints = append(endpoints, *endpoint)
-
-			return &portainer.Endpoint{}, nil
-		})
-
-	return endpoints, err
-}
-
-func (service ServiceTx) EndpointIDByEdgeID(edgeID string) (portainer.EndpointID, bool) {
-	log.Error().Str("func", "EndpointIDByEdgeID").Msg("cannot be called inside a transaction")
-
-	return 0, false
-}
-
-func (service ServiceTx) Heartbeat(endpointID portainer.EndpointID) (int64, bool) {
-	log.Error().Str("func", "Heartbeat").Msg("cannot be called inside a transaction")
-
-	return 0, false
-}
-
-func (service ServiceTx) UpdateHeartbeat(endpointID portainer.EndpointID) {
-	log.Error().Str("func", "UpdateHeartbeat").Msg("cannot be called inside a transaction")
-}
-
-// CreateEndpoint assign an ID to a new environment(endpoint) and saves it.
-func (service ServiceTx) Create(endpoint *portainer.Endpoint) error {
-	err := service.tx.CreateObjectWithId(BucketName, int(endpoint.ID), endpoint)
-	if err != nil {
-		return err
-	}
-
-	service.service.mu.Lock()
-	if len(endpoint.EdgeID) > 0 {
-		service.service.idxEdgeID[endpoint.EdgeID] = endpoint.ID
-	}
-	service.service.heartbeats.Store(endpoint.ID, endpoint.LastCheckInDate)
-	service.service.mu.Unlock()
-
-	return nil
-}
-
-// GetNextIdentifier returns the next identifier for an environment(endpoint).
-func (service ServiceTx) GetNextIdentifier() int {
-	return service.tx.GetNextIdentifier(BucketName)
-}

api/dataservices/endpointgroup/endpointgroup.go

@@ -2,10 +2,10 @@ package endpointgroup
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -34,13 +34,6 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
-}
-
 // EndpointGroup returns an environment(endpoint) group by ID.
 func (service *Service) EndpointGroup(ID portainer.EndpointGroupID) (*portainer.EndpointGroup, error) {
 	var endpointGroup portainer.EndpointGroup
@@ -74,14 +67,13 @@ func (service *Service) EndpointGroups() ([]portainer.EndpointGroup, error) {
 		BucketName,
 		&portainer.EndpointGroup{},
 		func(obj interface{}) (interface{}, error) {
+			//var tag portainer.Tag
 			endpointGroup, ok := obj.(*portainer.EndpointGroup)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointGroup object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to EndpointGroup object")
 				return nil, fmt.Errorf("Failed to convert to EndpointGroup object: %s", obj)
 			}
-
 			endpointGroups = append(endpointGroups, *endpointGroup)
-
 			return &portainer.EndpointGroup{}, nil
 		})
 

api/dataservices/endpointgroup/tx.go

@@ -1,76 +0,0 @@
-package endpointgroup
-
-import (
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-// EndpointGroup returns an environment(endpoint) group by ID.
-func (service ServiceTx) EndpointGroup(ID portainer.EndpointGroupID) (*portainer.EndpointGroup, error) {
-	var endpointGroup portainer.EndpointGroup
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.GetObject(BucketName, identifier, &endpointGroup)
-	if err != nil {
-		return nil, err
-	}
-
-	return &endpointGroup, nil
-}
-
-// UpdateEndpointGroup updates an environment(endpoint) group.
-func (service ServiceTx) UpdateEndpointGroup(ID portainer.EndpointGroupID, endpointGroup *portainer.EndpointGroup) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-	return service.tx.UpdateObject(BucketName, identifier, endpointGroup)
-}
-
-// DeleteEndpointGroup deletes an environment(endpoint) group.
-func (service ServiceTx) DeleteEndpointGroup(ID portainer.EndpointGroupID) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-	return service.tx.DeleteObject(BucketName, identifier)
-}
-
-// EndpointGroups return an array containing all the environment(endpoint) groups.
-func (service ServiceTx) EndpointGroups() ([]portainer.EndpointGroup, error) {
-	var endpointGroups = make([]portainer.EndpointGroup, 0)
-
-	err := service.tx.GetAll(
-		BucketName,
-		&portainer.EndpointGroup{},
-		func(obj interface{}) (interface{}, error) {
-			endpointGroup, ok := obj.(*portainer.EndpointGroup)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointGroup object")
-				return nil, fmt.Errorf("failed to convert to EndpointGroup object: %s", obj)
-			}
-
-			endpointGroups = append(endpointGroups, *endpointGroup)
-
-			return &portainer.EndpointGroup{}, nil
-		})
-
-	return endpointGroups, err
-}
-
-// CreateEndpointGroup assign an ID to a new environment(endpoint) group and saves it.
-func (service ServiceTx) Create(endpointGroup *portainer.EndpointGroup) error {
-	return service.tx.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			endpointGroup.ID = portainer.EndpointGroupID(id)
-			return int(endpointGroup.ID), endpointGroup
-		},
-	)
-}

api/dataservices/endpointrelation/endpointrelation.go

@@ -2,32 +2,27 @@ package endpointrelation
 
 import (
 	"fmt"
-
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/edge/cache"
-
-	"github.com/rs/zerolog/log"
+	"github.com/portainer/portainer/api/database"
+	"github.com/sirupsen/logrus"
 )
 
-// BucketName represents the name of the bucket where this service stores data.
-const BucketName = "endpoint_relations"
+const (
+	// BucketName represents the name of the bucket where this service stores data.
+	BucketName = "endpoint_relations"
+)
 
 // Service represents a service for managing environment(endpoint) relation data.
 type Service struct {
-	connection    portainer.Connection
-	updateStackFn func(ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
 	return BucketName
 }
 
-func (service *Service) RegisterUpdateStackFunction(updateFunc func(ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error) {
-	service.updateStackFn = updateFunc
-}
-
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -38,14 +33,7 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
-}
-
-// EndpointRelations returns an array of all EndpointRelations
+//EndpointRelations returns an array of all EndpointRelations
 func (service *Service) EndpointRelations() ([]portainer.EndpointRelation, error) {
 	var all = make([]portainer.EndpointRelation, 0)
 
@@ -55,12 +43,10 @@ func (service *Service) EndpointRelations() ([]portainer.EndpointRelation, error
 		func(obj interface{}) (interface{}, error) {
 			r, ok := obj.(*portainer.EndpointRelation)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointRelation object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to EndpointRelation object")
 				return nil, fmt.Errorf("Failed to convert to EndpointRelation object: %s", obj)
 			}
-
 			all = append(all, *r)
-
 			return &portainer.EndpointRelation{}, nil
 		})
 
@@ -68,7 +54,7 @@ func (service *Service) EndpointRelations() ([]portainer.EndpointRelation, error
 }
 
 // EndpointRelation returns a Environment(Endpoint) relation object by EndpointID
-func (service *Service) EndpointRelation(endpointID portainer.EndpointID) (*portainer.EndpointRelation, error) {
+func (service *Service) EndpointRelation(endpointID database.EndpointID) (*portainer.EndpointRelation, error) {
 	var endpointRelation portainer.EndpointRelation
 	identifier := service.connection.ConvertToKey(int(endpointID))
 
@@ -82,105 +68,17 @@ func (service *Service) EndpointRelation(endpointID portainer.EndpointID) (*port
 
 // CreateEndpointRelation saves endpointRelation
 func (service *Service) Create(endpointRelation *portainer.EndpointRelation) error {
-	err := service.connection.CreateObjectWithId(BucketName, int(endpointRelation.EndpointID), endpointRelation)
-	cache.Del(endpointRelation.EndpointID)
-
-	return err
+	return service.connection.CreateObjectWithId(BucketName, int(endpointRelation.EndpointID), endpointRelation)
 }
 
 // UpdateEndpointRelation updates an Environment(Endpoint) relation object
-func (service *Service) UpdateEndpointRelation(endpointID portainer.EndpointID, endpointRelation *portainer.EndpointRelation) error {
-	previousRelationState, _ := service.EndpointRelation(endpointID)
-
-	identifier := service.connection.ConvertToKey(int(endpointID))
-	err := service.connection.UpdateObject(BucketName, identifier, endpointRelation)
-	cache.Del(endpointID)
-	if err != nil {
-		return err
-	}
-
-	updatedRelationState, _ := service.EndpointRelation(endpointID)
-
-	service.updateEdgeStacksAfterRelationChange(previousRelationState, updatedRelationState)
-
-	return nil
+func (service *Service) UpdateEndpointRelation(EndpointID database.EndpointID, endpointRelation *portainer.EndpointRelation) error {
+	identifier := service.connection.ConvertToKey(int(EndpointID))
+	return service.connection.UpdateObject(BucketName, identifier, endpointRelation)
 }
 
 // DeleteEndpointRelation deletes an Environment(Endpoint) relation object
-func (service *Service) DeleteEndpointRelation(endpointID portainer.EndpointID) error {
-	deletedRelation, _ := service.EndpointRelation(endpointID)
-
-	identifier := service.connection.ConvertToKey(int(endpointID))
-	err := service.connection.DeleteObject(BucketName, identifier)
-	cache.Del(endpointID)
-	if err != nil {
-		return err
-	}
-
-	service.updateEdgeStacksAfterRelationChange(deletedRelation, nil)
-
-	return nil
-}
-
-func (service *Service) InvalidateEdgeCacheForEdgeStack(edgeStackID portainer.EdgeStackID) {
-	rels, err := service.EndpointRelations()
-	if err != nil {
-		log.Error().Err(err).Msg("cannot retrieve endpoint relations")
-		return
-	}
-
-	for _, rel := range rels {
-		for id := range rel.EdgeStacks {
-			if edgeStackID == id {
-				cache.Del(rel.EndpointID)
-			}
-		}
-	}
-}
-
-func (service *Service) updateEdgeStacksAfterRelationChange(previousRelationState *portainer.EndpointRelation, updatedRelationState *portainer.EndpointRelation) {
-	relations, _ := service.EndpointRelations()
-
-	stacksToUpdate := map[portainer.EdgeStackID]bool{}
-
-	if previousRelationState != nil {
-		for stackId, enabled := range previousRelationState.EdgeStacks {
-			// flag stack for update if stack is not in the updated relation state
-			// = stack has been removed for this relation
-			// or this relation has been deleted
-			if enabled && (updatedRelationState == nil || !updatedRelationState.EdgeStacks[stackId]) {
-				stacksToUpdate[stackId] = true
-			}
-		}
-	}
-
-	if updatedRelationState != nil {
-		for stackId, enabled := range updatedRelationState.EdgeStacks {
-			// flag stack for update if stack is not in the previous relation state
-			// = stack has been added for this relation
-			if enabled && (previousRelationState == nil || !previousRelationState.EdgeStacks[stackId]) {
-				stacksToUpdate[stackId] = true
-			}
-		}
-	}
-
-	// for each stack referenced by the updated relation
-	// list how many time this stack is referenced in all relations
-	// in order to update the stack deployments count
-	for refStackId, refStackEnabled := range stacksToUpdate {
-		if refStackEnabled {
-			numDeployments := 0
-			for _, r := range relations {
-				for sId, enabled := range r.EdgeStacks {
-					if enabled && sId == refStackId {
-						numDeployments += 1
-					}
-				}
-			}
-
-			service.updateStackFn(refStackId, func(edgeStack *portainer.EdgeStack) {
-				edgeStack.NumDeployments = numDeployments
-			})
-		}
-	}
+func (service *Service) DeleteEndpointRelation(EndpointID database.EndpointID) error {
+	identifier := service.connection.ConvertToKey(int(EndpointID))
+	return service.connection.DeleteObject(BucketName, identifier)
 }

api/dataservices/endpointrelation/tx.go

@@ -1,159 +0,0 @@
-package endpointrelation
-
-import (
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/internal/edge/cache"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-// EndpointRelations returns an array of all EndpointRelations
-func (service ServiceTx) EndpointRelations() ([]portainer.EndpointRelation, error) {
-	var all = make([]portainer.EndpointRelation, 0)
-
-	err := service.tx.GetAll(
-		BucketName,
-		&portainer.EndpointRelation{},
-		func(obj interface{}) (interface{}, error) {
-			r, ok := obj.(*portainer.EndpointRelation)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to EndpointRelation object")
-				return nil, fmt.Errorf("failed to convert to EndpointRelation object: %s", obj)
-			}
-
-			all = append(all, *r)
-
-			return &portainer.EndpointRelation{}, nil
-		})
-
-	return all, err
-}
-
-// EndpointRelation returns an Environment(Endpoint) relation object by EndpointID
-func (service ServiceTx) EndpointRelation(endpointID portainer.EndpointID) (*portainer.EndpointRelation, error) {
-	var endpointRelation portainer.EndpointRelation
-	identifier := service.service.connection.ConvertToKey(int(endpointID))
-
-	err := service.tx.GetObject(BucketName, identifier, &endpointRelation)
-	if err != nil {
-		return nil, err
-	}
-
-	return &endpointRelation, nil
-}
-
-// CreateEndpointRelation saves endpointRelation
-func (service ServiceTx) Create(endpointRelation *portainer.EndpointRelation) error {
-	err := service.tx.CreateObjectWithId(BucketName, int(endpointRelation.EndpointID), endpointRelation)
-	cache.Del(endpointRelation.EndpointID)
-
-	return err
-}
-
-// UpdateEndpointRelation updates an Environment(Endpoint) relation object
-func (service ServiceTx) UpdateEndpointRelation(endpointID portainer.EndpointID, endpointRelation *portainer.EndpointRelation) error {
-	previousRelationState, _ := service.EndpointRelation(endpointID)
-
-	identifier := service.service.connection.ConvertToKey(int(endpointID))
-	err := service.tx.UpdateObject(BucketName, identifier, endpointRelation)
-	cache.Del(endpointID)
-	if err != nil {
-		return err
-	}
-
-	updatedRelationState, _ := service.EndpointRelation(endpointID)
-
-	service.updateEdgeStacksAfterRelationChange(previousRelationState, updatedRelationState)
-
-	return nil
-}
-
-// DeleteEndpointRelation deletes an Environment(Endpoint) relation object
-func (service ServiceTx) DeleteEndpointRelation(endpointID portainer.EndpointID) error {
-	deletedRelation, _ := service.EndpointRelation(endpointID)
-
-	identifier := service.service.connection.ConvertToKey(int(endpointID))
-	err := service.tx.DeleteObject(BucketName, identifier)
-	cache.Del(endpointID)
-	if err != nil {
-		return err
-	}
-
-	service.updateEdgeStacksAfterRelationChange(deletedRelation, nil)
-
-	return nil
-}
-
-func (service ServiceTx) InvalidateEdgeCacheForEdgeStack(edgeStackID portainer.EdgeStackID) {
-	rels, err := service.EndpointRelations()
-	if err != nil {
-		log.Error().Err(err).Msg("cannot retrieve endpoint relations")
-		return
-	}
-
-	for _, rel := range rels {
-		for id := range rel.EdgeStacks {
-			if edgeStackID == id {
-				cache.Del(rel.EndpointID)
-			}
-		}
-	}
-}
-
-func (service ServiceTx) updateEdgeStacksAfterRelationChange(previousRelationState *portainer.EndpointRelation, updatedRelationState *portainer.EndpointRelation) {
-	relations, _ := service.EndpointRelations()
-
-	stacksToUpdate := map[portainer.EdgeStackID]bool{}
-
-	if previousRelationState != nil {
-		for stackId, enabled := range previousRelationState.EdgeStacks {
-			// flag stack for update if stack is not in the updated relation state
-			// = stack has been removed for this relation
-			// or this relation has been deleted
-			if enabled && (updatedRelationState == nil || !updatedRelationState.EdgeStacks[stackId]) {
-				stacksToUpdate[stackId] = true
-			}
-		}
-	}
-
-	if updatedRelationState != nil {
-		for stackId, enabled := range updatedRelationState.EdgeStacks {
-			// flag stack for update if stack is not in the previous relation state
-			// = stack has been added for this relation
-			if enabled && (previousRelationState == nil || !previousRelationState.EdgeStacks[stackId]) {
-				stacksToUpdate[stackId] = true
-			}
-		}
-	}
-
-	// for each stack referenced by the updated relation
-	// list how many time this stack is referenced in all relations
-	// in order to update the stack deployments count
-	for refStackId, refStackEnabled := range stacksToUpdate {
-		if refStackEnabled {
-			numDeployments := 0
-			for _, r := range relations {
-				for sId, enabled := range r.EdgeStacks {
-					if enabled && sId == refStackId {
-						numDeployments += 1
-					}
-				}
-			}
-
-			service.service.updateStackFn(refStackId, func(edgeStack *portainer.EdgeStack) {
-				edgeStack.NumDeployments = numDeployments
-			})
-		}
-	}
-}

api/dataservices/errors/errors.go

@@ -4,8 +4,7 @@ import "errors"
 
 var (
 	// TODO: i'm pretty sure this needs wrapping at several levels
-	ErrObjectNotFound     = errors.New("object not found inside the database")
-	ErrWrongDBEdition     = errors.New("the Portainer database is set for Portainer Business Edition, please follow the instructions in our documentation to downgrade it: https://documentation.portainer.io/v2.0-be/downgrade/be-to-ce/")
-	ErrDBImportFailed     = errors.New("importing backup failed")
-	ErrDatabaseIsUpdating = errors.New("database is currently in updating state. Failed prior upgrade. Please restore from backup or delete the database and restart Portainer")
+	ErrObjectNotFound = errors.New("object not found inside the database")
+	ErrWrongDBEdition = errors.New("the Portainer database is set for Portainer Business Edition, please follow the instructions in our documentation to downgrade it: https://documentation.portainer.io/v2.0-be/downgrade/be-to-ce/")
+	ErrDBImportFailed = errors.New("importing backup failed")
 )

api/dataservices/extension/extension.go

@@ -2,10 +2,10 @@ package extension
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -57,12 +57,10 @@ func (service *Service) Extensions() ([]portainer.Extension, error) {
 		func(obj interface{}) (interface{}, error) {
 			extension, ok := obj.(*portainer.Extension)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Extension object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Extension object")
 				return nil, fmt.Errorf("Failed to convert to Extension object: %s", obj)
 			}
-
 			extensions = append(extensions, *extension)
-
 			return &portainer.Extension{}, nil
 		})
 

api/dataservices/fdoprofile/fdoprofile.go

@@ -2,10 +2,10 @@ package fdoprofile
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managingFDO Profiles data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -44,9 +44,8 @@ func (service *Service) FDOProfiles() ([]portainer.FDOProfile, error) {
 		func(obj interface{}) (interface{}, error) {
 			fdoProfile, ok := obj.(*portainer.FDOProfile)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to FDOProfile object")
-
-				return nil, fmt.Errorf("Failed to convert to FDOProfile object: %s", obj)
+				logrus.WithField("obj", obj).Errorf("Failed to convert to FDOProfile object")
+				return nil, fmt.Errorf("failed to convert to FDOProfile object: %s", obj)
 			}
 			fdoProfiles = append(fdoProfiles, *fdoProfile)
 			return &portainer.FDOProfile{}, nil

api/dataservices/helmuserrepository/helmuserrepository.go

@@ -2,10 +2,10 @@ package helmuserrepository
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -34,7 +34,7 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-// HelmUserRepository returns an array of all HelmUserRepository
+//HelmUserRepository returns an array of all HelmUserRepository
 func (service *Service) HelmUserRepositories() ([]portainer.HelmUserRepository, error) {
 	var repos = make([]portainer.HelmUserRepository, 0)
 
@@ -44,12 +44,10 @@ func (service *Service) HelmUserRepositories() ([]portainer.HelmUserRepository,
 		func(obj interface{}) (interface{}, error) {
 			r, ok := obj.(*portainer.HelmUserRepository)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to HelmUserRepository object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to HelmUserRepository object")
 				return nil, fmt.Errorf("Failed to convert to HelmUserRepository object: %s", obj)
 			}
-
 			repos = append(repos, *r)
-
 			return &portainer.HelmUserRepository{}, nil
 		})
 
@@ -57,7 +55,7 @@ func (service *Service) HelmUserRepositories() ([]portainer.HelmUserRepository,
 }
 
 // HelmUserRepositoryByUserID return an array containing all the HelmUserRepository objects where the specified userID is present.
-func (service *Service) HelmUserRepositoryByUserID(userID portainer.UserID) ([]portainer.HelmUserRepository, error) {
+func (service *Service) HelmUserRepositoryByUserID(userID database.UserID) ([]portainer.HelmUserRepository, error) {
 	var result = make([]portainer.HelmUserRepository, 0)
 
 	err := service.connection.GetAll(
@@ -66,14 +64,12 @@ func (service *Service) HelmUserRepositoryByUserID(userID portainer.UserID) ([]p
 		func(obj interface{}) (interface{}, error) {
 			record, ok := obj.(*portainer.HelmUserRepository)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to HelmUserRepository object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to HelmUserRepository object")
 				return nil, fmt.Errorf("Failed to convert to HelmUserRepository object: %s", obj)
 			}
-
 			if record.UserID == userID {
 				result = append(result, *record)
 			}
-
 			return &portainer.HelmUserRepository{}, nil
 		})
 

api/dataservices/interface.go

@@ -3,18 +3,30 @@ package dataservices
 // 	"github.com/portainer/portainer/api/dataservices"
 
 import (
+	"github.com/portainer/portainer/api/database"
+	"github.com/portainer/portainer/api/dataservices/edgejob"
+	"github.com/portainer/portainer/api/dataservices/registry"
 	"io"
 	"time"
 
-	"github.com/portainer/portainer/api/database/models"
 	"github.com/portainer/portainer/api/dataservices/errors"
 
 	portainer "github.com/portainer/portainer/api"
 )
 
 type (
-	DataStoreTx interface {
+	// DataStore defines the interface to manage the data
+	DataStore interface {
+		Open() (newStore bool, err error)
+		Init() error
+		Close() error
+		MigrateData() error
+		Rollback(force bool) error
+		CheckCurrentEdition() error
+		BackupTo(w io.Writer) error
+		Export(filename string) (err error)
 		IsErrObjectNotFound(err error) bool
+
 		CustomTemplate() CustomTemplateService
 		EdgeGroup() EdgeGroupService
 		EdgeJob() EdgeJobService
@@ -29,7 +41,6 @@ type (
 		Role() RoleService
 		APIKeyRepository() APIKeyRepository
 		Settings() SettingsService
-		Snapshot() SnapshotService
 		SSLSettings() SSLSettingsService
 		Stack() StackService
 		Tag() TagService
@@ -41,22 +52,6 @@ type (
 		Webhook() WebhookService
 	}
 
-	// DataStore defines the interface to manage the data
-	DataStore interface {
-		Open() (newStore bool, err error)
-		Init() error
-		Close() error
-		UpdateTx(func(DataStoreTx) error) error
-		ViewTx(func(DataStoreTx) error) error
-		MigrateData() error
-		Rollback(force bool) error
-		CheckCurrentEdition() error
-		BackupTo(w io.Writer) error
-		Export(filename string) (err error)
-
-		DataStoreTx
-	}
-
 	// CustomTemplateService represents a service to manage custom templates
 	CustomTemplateService interface {
 		GetNextIdentifier() int
@@ -74,19 +69,17 @@ type (
 		EdgeGroup(ID portainer.EdgeGroupID) (*portainer.EdgeGroup, error)
 		Create(group *portainer.EdgeGroup) error
 		UpdateEdgeGroup(ID portainer.EdgeGroupID, group *portainer.EdgeGroup) error
-		UpdateEdgeGroupFunc(ID portainer.EdgeGroupID, updateFunc func(group *portainer.EdgeGroup)) error
 		DeleteEdgeGroup(ID portainer.EdgeGroupID) error
 		BucketName() string
 	}
 
 	// EdgeJobService represents a service to manage Edge jobs
 	EdgeJobService interface {
-		EdgeJobs() ([]portainer.EdgeJob, error)
-		EdgeJob(ID portainer.EdgeJobID) (*portainer.EdgeJob, error)
-		Create(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error
-		UpdateEdgeJob(ID portainer.EdgeJobID, edgeJob *portainer.EdgeJob) error
-		UpdateEdgeJobFunc(ID portainer.EdgeJobID, updateFunc func(edgeJob *portainer.EdgeJob)) error
-		DeleteEdgeJob(ID portainer.EdgeJobID) error
+		EdgeJobs() ([]edgejob.EdgeJob, error)
+		EdgeJob(ID edgejob.EdgeJobID) (*edgejob.EdgeJob, error)
+		Create(edgeJob *edgejob.EdgeJob) error
+		UpdateEdgeJob(ID edgejob.EdgeJobID, edgeJob *edgejob.EdgeJob) error
+		DeleteEdgeJob(ID edgejob.EdgeJobID) error
 		GetNextIdentifier() int
 		BucketName() string
 	}
@@ -95,10 +88,8 @@ type (
 	EdgeStackService interface {
 		EdgeStacks() ([]portainer.EdgeStack, error)
 		EdgeStack(ID portainer.EdgeStackID) (*portainer.EdgeStack, error)
-		EdgeStackVersion(ID portainer.EdgeStackID) (int, bool)
 		Create(id portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error
 		UpdateEdgeStack(ID portainer.EdgeStackID, edgeStack *portainer.EdgeStack) error
-		UpdateEdgeStackFunc(ID portainer.EdgeStackID, updateFunc func(edgeStack *portainer.EdgeStack)) error
 		DeleteEdgeStack(ID portainer.EdgeStackID) error
 		GetNextIdentifier() int
 		BucketName() string
@@ -106,15 +97,13 @@ type (
 
 	// EndpointService represents a service for managing environment(endpoint) data
 	EndpointService interface {
-		Endpoint(ID portainer.EndpointID) (*portainer.Endpoint, error)
-		EndpointIDByEdgeID(edgeID string) (portainer.EndpointID, bool)
-		Heartbeat(endpointID portainer.EndpointID) (int64, bool)
-		UpdateHeartbeat(endpointID portainer.EndpointID)
+		Endpoint(ID database.EndpointID) (*portainer.Endpoint, error)
 		Endpoints() ([]portainer.Endpoint, error)
 		Create(endpoint *portainer.Endpoint) error
-		UpdateEndpoint(ID portainer.EndpointID, endpoint *portainer.Endpoint) error
-		DeleteEndpoint(ID portainer.EndpointID) error
-		GetNextIdentifier() int
+		UpdateEndpoint(ID database.EndpointID, endpoint *portainer.Endpoint) error
+		DeleteEndpoint(ID database.EndpointID) error
+		//GetNextIdentifier() int
+		NewDefault() *portainer.Endpoint
 		BucketName() string
 	}
 
@@ -131,10 +120,10 @@ type (
 	// EndpointRelationService represents a service for managing environment(endpoint) relations data
 	EndpointRelationService interface {
 		EndpointRelations() ([]portainer.EndpointRelation, error)
-		EndpointRelation(EndpointID portainer.EndpointID) (*portainer.EndpointRelation, error)
+		EndpointRelation(EndpointID database.EndpointID) (*portainer.EndpointRelation, error)
 		Create(endpointRelation *portainer.EndpointRelation) error
-		UpdateEndpointRelation(EndpointID portainer.EndpointID, endpointRelation *portainer.EndpointRelation) error
-		DeleteEndpointRelation(EndpointID portainer.EndpointID) error
+		UpdateEndpointRelation(EndpointID database.EndpointID, endpointRelation *portainer.EndpointRelation) error
+		DeleteEndpointRelation(EndpointID database.EndpointID) error
 		BucketName() string
 	}
 
@@ -152,7 +141,7 @@ type (
 	// HelmUserRepositoryService represents a service to manage HelmUserRepositories
 	HelmUserRepositoryService interface {
 		HelmUserRepositories() ([]portainer.HelmUserRepository, error)
-		HelmUserRepositoryByUserID(userID portainer.UserID) ([]portainer.HelmUserRepository, error)
+		HelmUserRepositoryByUserID(userID database.UserID) ([]portainer.HelmUserRepository, error)
 		Create(record *portainer.HelmUserRepository) error
 		UpdateHelmUserRepository(ID portainer.HelmUserRepositoryID, repository *portainer.HelmUserRepository) error
 		DeleteHelmUserRepository(ID portainer.HelmUserRepositoryID) error
@@ -170,11 +159,11 @@ type (
 
 	// RegistryService represents a service for managing registry data
 	RegistryService interface {
-		Registry(ID portainer.RegistryID) (*portainer.Registry, error)
-		Registries() ([]portainer.Registry, error)
-		Create(registry *portainer.Registry) error
-		UpdateRegistry(ID portainer.RegistryID, registry *portainer.Registry) error
-		DeleteRegistry(ID portainer.RegistryID) error
+		Registry(ID registry.RegistryID) (*registry.Registry, error)
+		Registries() ([]registry.Registry, error)
+		Create(registry *registry.Registry) error
+		UpdateRegistry(ID registry.RegistryID, registry *registry.Registry) error
+		DeleteRegistry(ID registry.RegistryID) error
 		BucketName() string
 	}
 
@@ -191,10 +180,10 @@ type (
 
 	// RoleService represents a service for managing user roles
 	RoleService interface {
-		Role(ID portainer.RoleID) (*portainer.Role, error)
+		Role(ID database.RoleID) (*portainer.Role, error)
 		Roles() ([]portainer.Role, error)
 		Create(role *portainer.Role) error
-		UpdateRole(ID portainer.RoleID, role *portainer.Role) error
+		UpdateRole(ID database.RoleID, role *portainer.Role) error
 		BucketName() string
 	}
 
@@ -204,7 +193,7 @@ type (
 		GetAPIKey(keyID portainer.APIKeyID) (*portainer.APIKey, error)
 		UpdateAPIKey(key *portainer.APIKey) error
 		DeleteAPIKey(ID portainer.APIKeyID) error
-		GetAPIKeysByUserID(userID portainer.UserID) ([]portainer.APIKey, error)
+		GetAPIKeysByUserID(userID database.UserID) ([]portainer.APIKey, error)
 		GetAPIKeyByDigest(digest []byte) (*portainer.APIKey, error)
 	}
 
@@ -212,15 +201,7 @@ type (
 	SettingsService interface {
 		Settings() (*portainer.Settings, error)
 		UpdateSettings(settings *portainer.Settings) error
-		BucketName() string
-	}
-
-	SnapshotService interface {
-		Snapshot(endpointID portainer.EndpointID) (*portainer.Snapshot, error)
-		Snapshots() ([]portainer.Snapshot, error)
-		UpdateSnapshot(snapshot *portainer.Snapshot) error
-		DeleteSnapshot(endpointID portainer.EndpointID) error
-		Create(snapshot *portainer.Snapshot) error
+		IsFeatureFlagEnabled(feature portainer.Feature) bool
 		BucketName() string
 	}
 
@@ -252,19 +233,18 @@ type (
 		Tag(ID portainer.TagID) (*portainer.Tag, error)
 		Create(tag *portainer.Tag) error
 		UpdateTag(ID portainer.TagID, tag *portainer.Tag) error
-		UpdateTagFunc(ID portainer.TagID, updateFunc func(tag *portainer.Tag)) error
 		DeleteTag(ID portainer.TagID) error
 		BucketName() string
 	}
 
 	// TeamService represents a service for managing user data
 	TeamService interface {
-		Team(ID portainer.TeamID) (*portainer.Team, error)
+		Team(ID database.TeamID) (*portainer.Team, error)
 		TeamByName(name string) (*portainer.Team, error)
 		Teams() ([]portainer.Team, error)
 		Create(team *portainer.Team) error
-		UpdateTeam(ID portainer.TeamID, team *portainer.Team) error
-		DeleteTeam(ID portainer.TeamID) error
+		UpdateTeam(ID database.TeamID, team *portainer.Team) error
+		DeleteTeam(ID database.TeamID) error
 		BucketName() string
 	}
 
@@ -272,15 +252,14 @@ type (
 	TeamMembershipService interface {
 		TeamMembership(ID portainer.TeamMembershipID) (*portainer.TeamMembership, error)
 		TeamMemberships() ([]portainer.TeamMembership, error)
-		TeamMembershipsByUserID(userID portainer.UserID) ([]portainer.TeamMembership, error)
-		TeamMembershipsByTeamID(teamID portainer.TeamID) ([]portainer.TeamMembership, error)
+		TeamMembershipsByUserID(userID database.UserID) ([]portainer.TeamMembership, error)
+		TeamMembershipsByTeamID(teamID database.TeamID) ([]portainer.TeamMembership, error)
 		Create(membership *portainer.TeamMembership) error
 		UpdateTeamMembership(ID portainer.TeamMembershipID, membership *portainer.TeamMembership) error
 		DeleteTeamMembership(ID portainer.TeamMembershipID) error
-		DeleteTeamMembershipByUserID(userID portainer.UserID) error
-		DeleteTeamMembershipByTeamID(teamID portainer.TeamID) error
+		DeleteTeamMembershipByUserID(userID database.UserID) error
+		DeleteTeamMembershipByTeamID(teamID database.TeamID) error
 		BucketName() string
-		DeleteTeamMembershipByTeamIDAndUserID(teamID portainer.TeamID, userID portainer.UserID) error
 	}
 
 	// TunnelServerService represents a service for managing data associated to the tunnel server
@@ -292,23 +271,24 @@ type (
 
 	// UserService represents a service for managing user data
 	UserService interface {
-		User(ID portainer.UserID) (*portainer.User, error)
+		User(ID database.UserID) (*portainer.User, error)
 		UserByUsername(username string) (*portainer.User, error)
 		Users() ([]portainer.User, error)
 		UsersByRole(role portainer.UserRole) ([]portainer.User, error)
 		Create(user *portainer.User) error
-		UpdateUser(ID portainer.UserID, user *portainer.User) error
-		DeleteUser(ID portainer.UserID) error
+		UpdateUser(ID database.UserID, user *portainer.User) error
+		DeleteUser(ID database.UserID) error
 		BucketName() string
 	}
 
 	// VersionService represents a service for managing version data
 	VersionService interface {
+		DBVersion() (int, error)
 		Edition() (portainer.SoftwareEdition, error)
 		InstanceID() (string, error)
-		UpdateInstanceID(ID string) error
-		Version() (*models.Version, error)
-		UpdateVersion(*models.Version) error
+		StoreDBVersion(version int) error
+		StoreInstanceID(ID string) error
+		BucketName() string
 	}
 
 	// WebhookService represents a service for managing webhook data.

api/dataservices/registry/registry.go

@@ -2,10 +2,9 @@ package registry
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +14,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +22,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -35,8 +34,8 @@ func NewService(connection portainer.Connection) (*Service, error) {
 }
 
 // Registry returns an registry by ID.
-func (service *Service) Registry(ID portainer.RegistryID) (*portainer.Registry, error) {
-	var registry portainer.Registry
+func (service *Service) Registry(ID RegistryID) (*Registry, error) {
+	var registry Registry
 	identifier := service.connection.ConvertToKey(int(ID))
 
 	err := service.connection.GetObject(BucketName, identifier, &registry)
@@ -48,46 +47,128 @@ func (service *Service) Registry(ID portainer.RegistryID) (*portainer.Registry,
 }
 
 // Registries returns an array containing all the registries.
-func (service *Service) Registries() ([]portainer.Registry, error) {
-	var registries = make([]portainer.Registry, 0)
+func (service *Service) Registries() ([]Registry, error) {
+	var registries = make([]Registry, 0)
 
 	err := service.connection.GetAll(
 		BucketName,
-		&portainer.Registry{},
+		&Registry{},
 		func(obj interface{}) (interface{}, error) {
-			registry, ok := obj.(*portainer.Registry)
+			registry, ok := obj.(*Registry)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Registry object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Registry object")
 				return nil, fmt.Errorf("Failed to convert to Registry object: %s", obj)
 			}
-
 			registries = append(registries, *registry)
-
-			return &portainer.Registry{}, nil
+			return &Registry{}, nil
 		})
 
 	return registries, err
 }
 
 // CreateRegistry creates a new registry.
-func (service *Service) Create(registry *portainer.Registry) error {
+func (service *Service) Create(registry *Registry) error {
 	return service.connection.CreateObject(
 		BucketName,
 		func(id uint64) (int, interface{}) {
-			registry.ID = portainer.RegistryID(id)
+			registry.ID = RegistryID(id)
 			return int(registry.ID), registry
 		},
 	)
 }
 
 // UpdateRegistry updates an registry.
-func (service *Service) UpdateRegistry(ID portainer.RegistryID, registry *portainer.Registry) error {
+func (service *Service) UpdateRegistry(ID RegistryID, registry *Registry) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.UpdateObject(BucketName, identifier, registry)
 }
 
 // DeleteRegistry deletes an registry.
-func (service *Service) DeleteRegistry(ID portainer.RegistryID) error {
+func (service *Service) DeleteRegistry(ID RegistryID) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.DeleteObject(BucketName, identifier)
 }
+
+// Registry represents a Docker registry with all the info required to connect to it
+type Registry struct {
+	// Registry Identifier
+	ID RegistryID `json:"Id" example:"1"`
+	// Registry Type (1 - Quay, 2 - Azure, 3 - Custom, 4 - Gitlab, 5 - ProGet, 6 - DockerHub, 7 - ECR)
+	Type RegistryType `json:"Type" enums:"1,2,3,4,5,6,7"`
+	// Registry Name
+	Name string `json:"Name" example:"my-registry"`
+	// URL or IP address of the Docker registry
+	URL string `json:"URL" example:"registry.mydomain.tld:2375"`
+	// Base URL, introduced for ProGet registry
+	BaseURL string `json:"BaseURL" example:"registry.mydomain.tld:2375"`
+	// Is authentication against this registry enabled
+	Authentication bool `json:"Authentication" example:"true"`
+	// Username or AccessKeyID used to authenticate against this registry
+	Username string `json:"Username" example:"registry user"`
+	// Password or SecretAccessKey used to authenticate against this registry
+	Password                string                           `json:"Password,omitempty" example:"registry_password"`
+	ManagementConfiguration *RegistryManagementConfiguration `json:"ManagementConfiguration"`
+	Gitlab                  GitlabRegistryData               `json:"Gitlab"`
+	Quay                    QuayRegistryData                 `json:"Quay"`
+	Ecr                     EcrData                          `json:"Ecr"`
+	RegistryAccesses        RegistryAccesses                 `json:"RegistryAccesses"`
+
+	// Deprecated fields
+	// Deprecated in DBVersion == 31
+	UserAccessPolicies database.UserAccessPolicies `json:"UserAccessPolicies"`
+	// Deprecated in DBVersion == 31
+	TeamAccessPolicies database.TeamAccessPolicies `json:"TeamAccessPolicies"`
+
+	// Deprecated in DBVersion == 18
+	AuthorizedUsers []database.UserID `json:"AuthorizedUsers"`
+	// Deprecated in DBVersion == 18
+	AuthorizedTeams []database.TeamID `json:"AuthorizedTeams"`
+
+	// Stores temporary access token
+	AccessToken       string `json:"AccessToken,omitempty"`
+	AccessTokenExpiry int64  `json:"AccessTokenExpiry,omitempty"`
+}
+
+type RegistryAccesses map[database.EndpointID]RegistryAccessPolicies
+
+type RegistryAccessPolicies struct {
+	UserAccessPolicies database.UserAccessPolicies `json:"UserAccessPolicies"`
+	TeamAccessPolicies database.TeamAccessPolicies `json:"TeamAccessPolicies"`
+	Namespaces         []string                    `json:"Namespaces"`
+}
+
+// RegistryID represents a registry identifier
+type RegistryID int
+
+// RegistryManagementConfiguration represents a configuration that can be used to query the registry API via the registry management extension.
+type RegistryManagementConfiguration struct {
+	Type              RegistryType              `json:"Type"`
+	Authentication    bool                      `json:"Authentication"`
+	Username          string                    `json:"Username"`
+	Password          string                    `json:"Password"`
+	TLSConfig         database.TLSConfiguration `json:"TLSConfig"`
+	Ecr               EcrData                   `json:"Ecr"`
+	AccessToken       string                    `json:"AccessToken,omitempty"`
+	AccessTokenExpiry int64                     `json:"AccessTokenExpiry,omitempty"`
+}
+
+// RegistryType represents a type of registry
+type RegistryType int
+
+// GitlabRegistryData represents data required for gitlab registry to work
+type GitlabRegistryData struct {
+	ProjectID   int    `json:"ProjectId"`
+	InstanceURL string `json:"InstanceURL"`
+	ProjectPath string `json:"ProjectPath"`
+}
+
+// QuayRegistryData represents data required for Quay registry to work
+type QuayRegistryData struct {
+	UseOrganisation  bool   `json:"UseOrganisation"`
+	OrganisationName string `json:"OrganisationName"`
+}
+
+// EcrData represents data required for ECR registry
+type EcrData struct {
+	Region string `json:"Region" example:"ap-southeast-2"`
+}

api/dataservices/resourcecontrol/resourcecontrol.go

@@ -2,10 +2,10 @@ package resourcecontrol
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -59,7 +59,7 @@ func (service *Service) ResourceControlByResourceIDAndType(resourceID string, re
 		func(obj interface{}) (interface{}, error) {
 			rc, ok := obj.(*portainer.ResourceControl)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to ResourceControl object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to ResourceControl object")
 				return nil, fmt.Errorf("Failed to convert to ResourceControl object: %s", obj)
 			}
 
@@ -74,7 +74,6 @@ func (service *Service) ResourceControlByResourceIDAndType(resourceID string, re
 					return nil, stop
 				}
 			}
-
 			return &portainer.ResourceControl{}, nil
 		})
 	if err == stop {
@@ -94,12 +93,10 @@ func (service *Service) ResourceControls() ([]portainer.ResourceControl, error)
 		func(obj interface{}) (interface{}, error) {
 			rc, ok := obj.(*portainer.ResourceControl)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to ResourceControl object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to ResourceControl object")
 				return nil, fmt.Errorf("Failed to convert to ResourceControl object: %s", obj)
 			}
-
 			rcs = append(rcs, *rc)
-
 			return &portainer.ResourceControl{}, nil
 		})
 

api/dataservices/role/role.go

@@ -2,10 +2,10 @@ package role
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -35,7 +35,7 @@ func NewService(connection portainer.Connection) (*Service, error) {
 }
 
 // Role returns a Role by ID
-func (service *Service) Role(ID portainer.RoleID) (*portainer.Role, error) {
+func (service *Service) Role(ID database.RoleID) (*portainer.Role, error) {
 	var set portainer.Role
 	identifier := service.connection.ConvertToKey(int(ID))
 
@@ -57,12 +57,10 @@ func (service *Service) Roles() ([]portainer.Role, error) {
 		func(obj interface{}) (interface{}, error) {
 			set, ok := obj.(*portainer.Role)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Role object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Role object")
 				return nil, fmt.Errorf("Failed to convert to Role object: %s", obj)
 			}
-
 			sets = append(sets, *set)
-
 			return &portainer.Role{}, nil
 		})
 
@@ -74,14 +72,14 @@ func (service *Service) Create(role *portainer.Role) error {
 	return service.connection.CreateObject(
 		BucketName,
 		func(id uint64) (int, interface{}) {
-			role.ID = portainer.RoleID(id)
+			role.ID = database.RoleID(id)
 			return int(role.ID), role
 		},
 	)
 }
 
 // UpdateRole updates a role.
-func (service *Service) UpdateRole(ID portainer.RoleID, role *portainer.Role) error {
+func (service *Service) UpdateRole(ID database.RoleID, role *portainer.Role) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.UpdateObject(BucketName, identifier, role)
 }

api/dataservices/schedule/schedule.go

@@ -2,10 +2,9 @@ package schedule
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +14,7 @@ const (
 
 // Service represents a service for managing schedule data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +22,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -35,8 +34,8 @@ func NewService(connection portainer.Connection) (*Service, error) {
 }
 
 // Schedule returns a schedule by ID.
-func (service *Service) Schedule(ID portainer.ScheduleID) (*portainer.Schedule, error) {
-	var schedule portainer.Schedule
+func (service *Service) Schedule(ID ScheduleID) (*Schedule, error) {
+	var schedule Schedule
 	identifier := service.connection.ConvertToKey(int(ID))
 
 	err := service.connection.GetObject(BucketName, identifier, &schedule)
@@ -48,34 +47,32 @@ func (service *Service) Schedule(ID portainer.ScheduleID) (*portainer.Schedule,
 }
 
 // UpdateSchedule updates a schedule.
-func (service *Service) UpdateSchedule(ID portainer.ScheduleID, schedule *portainer.Schedule) error {
+func (service *Service) UpdateSchedule(ID ScheduleID, schedule *Schedule) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.UpdateObject(BucketName, identifier, schedule)
 }
 
 // DeleteSchedule deletes a schedule.
-func (service *Service) DeleteSchedule(ID portainer.ScheduleID) error {
+func (service *Service) DeleteSchedule(ID ScheduleID) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.DeleteObject(BucketName, identifier)
 }
 
 // Schedules return a array containing all the schedules.
-func (service *Service) Schedules() ([]portainer.Schedule, error) {
-	var schedules = make([]portainer.Schedule, 0)
+func (service *Service) Schedules() ([]Schedule, error) {
+	var schedules = make([]Schedule, 0)
 
 	err := service.connection.GetAll(
 		BucketName,
-		&portainer.Schedule{},
+		&Schedule{},
 		func(obj interface{}) (interface{}, error) {
-			schedule, ok := obj.(*portainer.Schedule)
+			schedule, ok := obj.(*Schedule)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Schedule object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Schedule object")
 				return nil, fmt.Errorf("Failed to convert to Schedule object: %s", obj)
 			}
-
 			schedules = append(schedules, *schedule)
-
-			return &portainer.Schedule{}, nil
+			return &Schedule{}, nil
 		})
 
 	return schedules, err
@@ -83,35 +80,73 @@ func (service *Service) Schedules() ([]portainer.Schedule, error) {
 
 // SchedulesByJobType return a array containing all the schedules
 // with the specified JobType.
-func (service *Service) SchedulesByJobType(jobType portainer.JobType) ([]portainer.Schedule, error) {
-	var schedules = make([]portainer.Schedule, 0)
+func (service *Service) SchedulesByJobType(jobType JobType) ([]Schedule, error) {
+	var schedules = make([]Schedule, 0)
 
 	err := service.connection.GetAll(
 		BucketName,
-		&portainer.Schedule{},
+		&Schedule{},
 		func(obj interface{}) (interface{}, error) {
-			schedule, ok := obj.(*portainer.Schedule)
+			schedule, ok := obj.(*Schedule)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Schedule object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Schedule object")
 				return nil, fmt.Errorf("Failed to convert to Schedule object: %s", obj)
 			}
-
 			if schedule.JobType == jobType {
 				schedules = append(schedules, *schedule)
 			}
-
-			return &portainer.Schedule{}, nil
+			return &Schedule{}, nil
 		})
 
 	return schedules, err
 }
 
 // Create assign an ID to a new schedule and saves it.
-func (service *Service) CreateSchedule(schedule *portainer.Schedule) error {
-	return service.connection.CreateObjectWithId(BucketName, int(schedule.ID), schedule)
+func (service *Service) CreateSchedule(schedule *Schedule) error {
+	return service.connection.CreateObjectWithSetSequence(BucketName, int(schedule.ID), schedule)
 }
 
 // GetNextIdentifier returns the next identifier for a schedule.
 func (service *Service) GetNextIdentifier() int {
 	return service.connection.GetNextIdentifier(BucketName)
 }
+
+// Schedule represents a scheduled job.
+// It only contains a pointer to one of the JobRunner implementations
+// based on the JobType.
+// NOTE: The Recurring option is only used by ScriptExecutionJob at the moment
+// Deprecated in favor of EdgeJob
+type Schedule struct {
+	// Schedule Identifier
+	ID             ScheduleID `json:"Id" example:"1"`
+	Name           string
+	CronExpression string
+	Recurring      bool
+	Created        int64
+	JobType        JobType
+	EdgeSchedule   *EdgeSchedule
+}
+
+// EdgeSchedule represents a scheduled job that can run on Edge environments(endpoints).
+// Deprecated in favor of EdgeJob
+type EdgeSchedule struct {
+	// EdgeSchedule Identifier
+	ID             ScheduleID            `json:"Id" example:"1"`
+	CronExpression string                `json:"CronExpression"`
+	Script         string                `json:"Script"`
+	Version        int                   `json:"Version"`
+	Endpoints      []database.EndpointID `json:"Endpoints"`
+}
+
+// ScheduleID represents a schedule identifier.
+// Deprecated in favor of EdgeJob
+type ScheduleID int
+
+// JobType represents a job type
+type JobType int
+
+const (
+	_ JobType = iota
+	// SnapshotJobType is a system job used to create environment(endpoint) snapshots
+	SnapshotJobType = 2
+)

api/dataservices/settings/settings.go

@@ -2,6 +2,7 @@ package settings
 
 import (
 	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/database"
 )
 
 const (
@@ -12,7 +13,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -20,7 +21,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -47,3 +48,17 @@ func (service *Service) Settings() (*portainer.Settings, error) {
 func (service *Service) UpdateSettings(settings *portainer.Settings) error {
 	return service.connection.UpdateObject(BucketName, []byte(settingsKey), settings)
 }
+
+func (service *Service) IsFeatureFlagEnabled(feature portainer.Feature) bool {
+	settings, err := service.Settings()
+	if err != nil {
+		return false
+	}
+
+	featureFlagSetting, ok := settings.FeatureFlagSettings[feature]
+	if ok {
+		return featureFlagSetting
+	}
+
+	return false
+}

api/dataservices/snapshot/snapshot.go

@@ -1,84 +0,0 @@
-package snapshot
-
-import (
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-const (
-	BucketName = "snapshots"
-)
-
-type Service struct {
-	connection portainer.Connection
-}
-
-func (service *Service) BucketName() string {
-	return BucketName
-}
-
-func NewService(connection portainer.Connection) (*Service, error) {
-	err := connection.SetServiceName(BucketName)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Service{
-		connection: connection,
-	}, nil
-}
-
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
-}
-
-func (service *Service) Snapshot(endpointID portainer.EndpointID) (*portainer.Snapshot, error) {
-	var snapshot portainer.Snapshot
-	identifier := service.connection.ConvertToKey(int(endpointID))
-
-	err := service.connection.GetObject(BucketName, identifier, &snapshot)
-	if err != nil {
-		return nil, err
-	}
-
-	return &snapshot, nil
-}
-
-func (service *Service) Snapshots() ([]portainer.Snapshot, error) {
-	var snapshots = make([]portainer.Snapshot, 0)
-
-	err := service.connection.GetAllWithJsoniter(
-		BucketName,
-		&portainer.Snapshot{},
-		func(obj interface{}) (interface{}, error) {
-			snapshot, ok := obj.(*portainer.Snapshot)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Snapshot object")
-				return nil, fmt.Errorf("failed to convert to Snapshot object: %s", obj)
-			}
-			snapshots = append(snapshots, *snapshot)
-			return &portainer.Snapshot{}, nil
-		})
-
-	return snapshots, err
-}
-
-func (service *Service) UpdateSnapshot(snapshot *portainer.Snapshot) error {
-	identifier := service.connection.ConvertToKey(int(snapshot.EndpointID))
-	return service.connection.UpdateObject(BucketName, identifier, snapshot)
-}
-
-func (service *Service) DeleteSnapshot(endpointID portainer.EndpointID) error {
-	identifier := service.connection.ConvertToKey(int(endpointID))
-	return service.connection.DeleteObject(BucketName, identifier)
-}
-
-func (service *Service) Create(snapshot *portainer.Snapshot) error {
-	return service.connection.CreateObjectWithId(BucketName, int(snapshot.EndpointID), snapshot)
-}

api/dataservices/snapshot/tx.go

@@ -1,63 +0,0 @@
-package snapshot
-
-import (
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-func (service ServiceTx) Snapshot(endpointID portainer.EndpointID) (*portainer.Snapshot, error) {
-	var snapshot portainer.Snapshot
-	identifier := service.service.connection.ConvertToKey(int(endpointID))
-
-	err := service.tx.GetObject(BucketName, identifier, &snapshot)
-	if err != nil {
-		return nil, err
-	}
-
-	return &snapshot, nil
-}
-
-func (service ServiceTx) Snapshots() ([]portainer.Snapshot, error) {
-	var snapshots = make([]portainer.Snapshot, 0)
-
-	err := service.tx.GetAllWithJsoniter(
-		BucketName,
-		&portainer.Snapshot{},
-		func(obj interface{}) (interface{}, error) {
-			snapshot, ok := obj.(*portainer.Snapshot)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Snapshot object")
-				return nil, fmt.Errorf("failed to convert to Snapshot object: %s", obj)
-			}
-			snapshots = append(snapshots, *snapshot)
-			return &portainer.Snapshot{}, nil
-		})
-
-	return snapshots, err
-}
-
-func (service ServiceTx) UpdateSnapshot(snapshot *portainer.Snapshot) error {
-	identifier := service.service.connection.ConvertToKey(int(snapshot.EndpointID))
-	return service.tx.UpdateObject(BucketName, identifier, snapshot)
-}
-
-func (service ServiceTx) DeleteSnapshot(endpointID portainer.EndpointID) error {
-	identifier := service.service.connection.ConvertToKey(int(endpointID))
-	return service.tx.DeleteObject(BucketName, identifier)
-}
-
-func (service ServiceTx) Create(snapshot *portainer.Snapshot) error {
-	return service.tx.CreateObjectWithId(BucketName, int(snapshot.EndpointID), snapshot)
-}

api/dataservices/ssl/ssl.go

@@ -2,6 +2,7 @@ package ssl
 
 import (
 	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/database"
 )
 
 const (
@@ -12,7 +13,7 @@ const (
 
 // Service represents a service for managing ssl data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -20,7 +21,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err

api/dataservices/stack/stack.go

@@ -2,12 +2,13 @@ package stack
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 	"strings"
 
+	"github.com/sirupsen/logrus"
+
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -17,7 +18,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -25,7 +26,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -60,15 +61,13 @@ func (service *Service) StackByName(name string) (*portainer.Stack, error) {
 		func(obj interface{}) (interface{}, error) {
 			stack, ok := obj.(*portainer.Stack)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Stack object")
 				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
 			}
-
 			if stack.Name == name {
 				s = stack
 				return nil, stop
 			}
-
 			return &portainer.Stack{}, nil
 		})
 	if err == stop {
@@ -91,14 +90,12 @@ func (service *Service) StacksByName(name string) ([]portainer.Stack, error) {
 		func(obj interface{}) (interface{}, error) {
 			stack, ok := obj.(portainer.Stack)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Stack object")
 				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
 			}
-
 			if stack.Name == name {
 				stacks = append(stacks, stack)
 			}
-
 			return &portainer.Stack{}, nil
 		})
 
@@ -115,12 +112,10 @@ func (service *Service) Stacks() ([]portainer.Stack, error) {
 		func(obj interface{}) (interface{}, error) {
 			stack, ok := obj.(*portainer.Stack)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Stack object")
 				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
 			}
-
 			stacks = append(stacks, *stack)
-
 			return &portainer.Stack{}, nil
 		})
 
@@ -134,7 +129,7 @@ func (service *Service) GetNextIdentifier() int {
 
 // CreateStack creates a new stack.
 func (service *Service) Create(stack *portainer.Stack) error {
-	return service.connection.CreateObjectWithId(BucketName, int(stack.ID), stack)
+	return service.connection.CreateObjectWithSetSequence(BucketName, int(stack.ID), stack)
 }
 
 // UpdateStack updates a stack.
@@ -162,15 +157,13 @@ func (service *Service) StackByWebhookID(id string) (*portainer.Stack, error) {
 			s, ok = obj.(*portainer.Stack)
 
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
-
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Stack object")
 				return &portainer.Stack{}, nil
 			}
 
 			if s.AutoUpdate != nil && strings.EqualFold(s.AutoUpdate.Webhook, id) {
 				return nil, stop
 			}
-
 			return &portainer.Stack{}, nil
 		})
 	if err == stop {
@@ -194,14 +187,12 @@ func (service *Service) RefreshableStacks() ([]portainer.Stack, error) {
 		func(obj interface{}) (interface{}, error) {
 			stack, ok := obj.(*portainer.Stack)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Stack object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Stack object")
 				return nil, fmt.Errorf("Failed to convert to Stack object: %s", obj)
 			}
-
 			if stack.AutoUpdate != nil && stack.AutoUpdate.Interval != "" {
 				stacks = append(stacks, *stack)
 			}
-
 			return &portainer.Stack{}, nil
 		})
 

api/dataservices/stack/tests/stack_test.go

@@ -29,7 +29,7 @@ func TestService_StackByWebhookID(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping test in short mode. Normally takes ~1s to run.")
 	}
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	b := stackBuilder{t: t, store: store}
@@ -68,13 +68,13 @@ func (b *stackBuilder) createNewStack(webhookID string) portainer.Stack {
 
 	if webhookID == "" {
 		if b.count%2 == 0 {
-			stack.AutoUpdate = &portainer.AutoUpdateSettings{
+			stack.AutoUpdate = &portainer.StackAutoUpdate{
 				Interval: "",
 				Webhook:  "",
 			}
 		} // else keep AutoUpdate nil
 	} else {
-		stack.AutoUpdate = &portainer.AutoUpdateSettings{Webhook: webhookID}
+		stack.AutoUpdate = &portainer.StackAutoUpdate{Webhook: webhookID}
 	}
 
 	err := b.store.StackService.Create(&stack)
@@ -87,12 +87,12 @@ func Test_RefreshableStacks(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping test in short mode. Normally takes ~1s to run.")
 	}
-	_, store, teardown := datastore.MustNewTestStore(t, true, true)
+	_, store, teardown := datastore.MustNewTestStore(true)
 	defer teardown()
 
 	staticStack := portainer.Stack{ID: 1}
-	stackWithWebhook := portainer.Stack{ID: 2, AutoUpdate: &portainer.AutoUpdateSettings{Webhook: "webhook"}}
-	refreshableStack := portainer.Stack{ID: 3, AutoUpdate: &portainer.AutoUpdateSettings{Interval: "1m"}}
+	stackWithWebhook := portainer.Stack{ID: 2, AutoUpdate: &portainer.StackAutoUpdate{Webhook: "webhook"}}
+	refreshableStack := portainer.Stack{ID: 3, AutoUpdate: &portainer.StackAutoUpdate{Interval: "1m"}}
 
 	for _, stack := range []*portainer.Stack{&staticStack, &stackWithWebhook, &refreshableStack} {
 		err := store.Stack().Create(stack)

api/dataservices/tag/tag.go

@@ -2,10 +2,10 @@ package tag
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -34,13 +34,6 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-func (service *Service) Tx(tx portainer.Transaction) ServiceTx {
-	return ServiceTx{
-		service: service,
-		tx:      tx,
-	}
-}
-
 // Tags return an array containing all the tags.
 func (service *Service) Tags() ([]portainer.Tag, error) {
 	var tags = make([]portainer.Tag, 0)
@@ -51,12 +44,10 @@ func (service *Service) Tags() ([]portainer.Tag, error) {
 		func(obj interface{}) (interface{}, error) {
 			tag, ok := obj.(*portainer.Tag)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Tag object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Tag object")
 				return nil, fmt.Errorf("Failed to convert to Tag object: %s", obj)
 			}
-
 			tags = append(tags, *tag)
-
 			return &portainer.Tag{}, nil
 		})
 
@@ -87,22 +78,12 @@ func (service *Service) Create(tag *portainer.Tag) error {
 	)
 }
 
-// Deprecated: Use UpdateTagFunc instead.
+// UpdateTag updates a tag.
 func (service *Service) UpdateTag(ID portainer.TagID, tag *portainer.Tag) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.UpdateObject(BucketName, identifier, tag)
 }
 
-// UpdateTagFunc updates a tag inside a transaction avoiding data races.
-func (service *Service) UpdateTagFunc(ID portainer.TagID, updateFunc func(tag *portainer.Tag)) error {
-	id := service.connection.ConvertToKey(int(ID))
-	tag := &portainer.Tag{}
-
-	return service.connection.UpdateObjectFunc(BucketName, id, tag, func() {
-		updateFunc(tag)
-	})
-}
-
 // DeleteTag deletes a tag.
 func (service *Service) DeleteTag(ID portainer.TagID) error {
 	identifier := service.connection.ConvertToKey(int(ID))

api/dataservices/tag/tx.go

@@ -1,82 +0,0 @@
-package tag
-
-import (
-	"errors"
-	"fmt"
-
-	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
-)
-
-type ServiceTx struct {
-	service *Service
-	tx      portainer.Transaction
-}
-
-func (service ServiceTx) BucketName() string {
-	return BucketName
-}
-
-// Tags return an array containing all the tags.
-func (service ServiceTx) Tags() ([]portainer.Tag, error) {
-	var tags = make([]portainer.Tag, 0)
-
-	err := service.tx.GetAll(
-		BucketName,
-		&portainer.Tag{},
-		func(obj interface{}) (interface{}, error) {
-			tag, ok := obj.(*portainer.Tag)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Tag object")
-				return nil, fmt.Errorf("failed to convert to Tag object: %s", obj)
-			}
-
-			tags = append(tags, *tag)
-
-			return &portainer.Tag{}, nil
-		})
-
-	return tags, err
-}
-
-// Tag returns a tag by ID.
-func (service ServiceTx) Tag(ID portainer.TagID) (*portainer.Tag, error) {
-	var tag portainer.Tag
-	identifier := service.service.connection.ConvertToKey(int(ID))
-
-	err := service.tx.GetObject(BucketName, identifier, &tag)
-	if err != nil {
-		return nil, err
-	}
-
-	return &tag, nil
-}
-
-// CreateTag creates a new tag.
-func (service ServiceTx) Create(tag *portainer.Tag) error {
-	return service.tx.CreateObject(
-		BucketName,
-		func(id uint64) (int, interface{}) {
-			tag.ID = portainer.TagID(id)
-			return int(tag.ID), tag
-		},
-	)
-}
-
-// UpdateTag updates a tag
-func (service ServiceTx) UpdateTag(ID portainer.TagID, tag *portainer.Tag) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-	return service.tx.UpdateObject(BucketName, identifier, tag)
-}
-
-// UpdateTagFunc is a no-op inside a transaction
-func (service ServiceTx) UpdateTagFunc(ID portainer.TagID, updateFunc func(tag *portainer.Tag)) error {
-	return errors.New("cannot be called inside a transaction")
-}
-
-// DeleteTag deletes a tag.
-func (service ServiceTx) DeleteTag(ID portainer.TagID) error {
-	identifier := service.service.connection.ConvertToKey(int(ID))
-	return service.tx.DeleteObject(BucketName, identifier)
-}

api/dataservices/team/team.go

@@ -2,12 +2,13 @@ package team
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 	"strings"
 
-	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices/errors"
+	"github.com/sirupsen/logrus"
 
-	"github.com/rs/zerolog/log"
+	portainer "github.com/portainer/portainer/api"
 )
 
 const (
@@ -17,7 +18,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -25,7 +26,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -37,7 +38,7 @@ func NewService(connection portainer.Connection) (*Service, error) {
 }
 
 // Team returns a Team by ID
-func (service *Service) Team(ID portainer.TeamID) (*portainer.Team, error) {
+func (service *Service) Team(ID database.TeamID) (*portainer.Team, error) {
 	var team portainer.Team
 	identifier := service.connection.ConvertToKey(int(ID))
 
@@ -60,15 +61,13 @@ func (service *Service) TeamByName(name string) (*portainer.Team, error) {
 		func(obj interface{}) (interface{}, error) {
 			team, ok := obj.(*portainer.Team)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Team object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Team object")
 				return nil, fmt.Errorf("Failed to convert to Team object: %s", obj)
 			}
-
 			if strings.EqualFold(team.Name, name) {
 				t = team
 				return nil, stop
 			}
-
 			return &portainer.Team{}, nil
 		})
 	if err == stop {
@@ -91,12 +90,10 @@ func (service *Service) Teams() ([]portainer.Team, error) {
 		func(obj interface{}) (interface{}, error) {
 			team, ok := obj.(*portainer.Team)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Team object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Team object")
 				return nil, fmt.Errorf("Failed to convert to Team object: %s", obj)
 			}
-
 			teams = append(teams, *team)
-
 			return &portainer.Team{}, nil
 		})
 
@@ -104,7 +101,7 @@ func (service *Service) Teams() ([]portainer.Team, error) {
 }
 
 // UpdateTeam saves a Team.
-func (service *Service) UpdateTeam(ID portainer.TeamID, team *portainer.Team) error {
+func (service *Service) UpdateTeam(ID database.TeamID, team *portainer.Team) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.UpdateObject(BucketName, identifier, team)
 }
@@ -114,14 +111,14 @@ func (service *Service) Create(team *portainer.Team) error {
 	return service.connection.CreateObject(
 		BucketName,
 		func(id uint64) (int, interface{}) {
-			team.ID = portainer.TeamID(id)
+			team.ID = database.TeamID(id)
 			return int(team.ID), team
 		},
 	)
 }
 
 // DeleteTeam deletes a Team.
-func (service *Service) DeleteTeam(ID portainer.TeamID) error {
+func (service *Service) DeleteTeam(ID database.TeamID) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.DeleteObject(BucketName, identifier)
 }

api/dataservices/team/tests/team_test.go

@@ -10,7 +10,7 @@ import (
 
 func Test_teamByName(t *testing.T) {
 	t.Run("When store is empty should return ErrObjectNotFound", func(t *testing.T) {
-		_, store, teardown := datastore.MustNewTestStore(t, true, true)
+		_, store, teardown := datastore.MustNewTestStore(true)
 		defer teardown()
 
 		_, err := store.Team().TeamByName("name")
@@ -19,7 +19,7 @@ func Test_teamByName(t *testing.T) {
 	})
 
 	t.Run("When there is no object with the same name should return ErrObjectNotFound", func(t *testing.T) {
-		_, store, teardown := datastore.MustNewTestStore(t, true, true)
+		_, store, teardown := datastore.MustNewTestStore(true)
 		defer teardown()
 
 		teamBuilder := teamBuilder{
@@ -35,7 +35,7 @@ func Test_teamByName(t *testing.T) {
 	})
 
 	t.Run("When there is an object with the same name should return the object", func(t *testing.T) {
-		_, store, teardown := datastore.MustNewTestStore(t, true, true)
+		_, store, teardown := datastore.MustNewTestStore(true)
 		defer teardown()
 
 		teamBuilder := teamBuilder{

api/dataservices/team/tests/utils.go

@@ -1,6 +1,7 @@
 package tests
 
 import (
+	"github.com/portainer/portainer/api/database"
 	"testing"
 
 	portainer "github.com/portainer/portainer/api"
@@ -17,7 +18,7 @@ type teamBuilder struct {
 func (b *teamBuilder) createNew(name string) *portainer.Team {
 	b.count++
 	team := &portainer.Team{
-		ID:   portainer.TeamID(b.count),
+		ID:   database.TeamID(b.count),
 		Name: name,
 	}
 

api/dataservices/teammembership/teammembership.go

@@ -2,10 +2,10 @@ package teammembership
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -23,7 +23,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -57,12 +57,10 @@ func (service *Service) TeamMemberships() ([]portainer.TeamMembership, error) {
 		func(obj interface{}) (interface{}, error) {
 			membership, ok := obj.(*portainer.TeamMembership)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to TeamMembership object")
 				return nil, fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
 			}
-
 			memberships = append(memberships, *membership)
-
 			return &portainer.TeamMembership{}, nil
 		})
 
@@ -70,7 +68,7 @@ func (service *Service) TeamMemberships() ([]portainer.TeamMembership, error) {
 }
 
 // TeamMembershipsByUserID return an array containing all the TeamMembership objects where the specified userID is present.
-func (service *Service) TeamMembershipsByUserID(userID portainer.UserID) ([]portainer.TeamMembership, error) {
+func (service *Service) TeamMembershipsByUserID(userID database.UserID) ([]portainer.TeamMembership, error) {
 	var memberships = make([]portainer.TeamMembership, 0)
 
 	err := service.connection.GetAll(
@@ -79,14 +77,12 @@ func (service *Service) TeamMembershipsByUserID(userID portainer.UserID) ([]port
 		func(obj interface{}) (interface{}, error) {
 			membership, ok := obj.(*portainer.TeamMembership)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to TeamMembership object")
 				return nil, fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
 			}
-
 			if membership.UserID == userID {
 				memberships = append(memberships, *membership)
 			}
-
 			return &portainer.TeamMembership{}, nil
 		})
 
@@ -94,7 +90,7 @@ func (service *Service) TeamMembershipsByUserID(userID portainer.UserID) ([]port
 }
 
 // TeamMembershipsByTeamID return an array containing all the TeamMembership objects where the specified teamID is present.
-func (service *Service) TeamMembershipsByTeamID(teamID portainer.TeamID) ([]portainer.TeamMembership, error) {
+func (service *Service) TeamMembershipsByTeamID(teamID database.TeamID) ([]portainer.TeamMembership, error) {
 	var memberships = make([]portainer.TeamMembership, 0)
 
 	err := service.connection.GetAll(
@@ -103,14 +99,12 @@ func (service *Service) TeamMembershipsByTeamID(teamID portainer.TeamID) ([]port
 		func(obj interface{}) (interface{}, error) {
 			membership, ok := obj.(*portainer.TeamMembership)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to TeamMembership object")
 				return nil, fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
 			}
-
 			if membership.TeamID == teamID {
 				memberships = append(memberships, *membership)
 			}
-
 			return &portainer.TeamMembership{}, nil
 		})
 
@@ -141,63 +135,37 @@ func (service *Service) DeleteTeamMembership(ID portainer.TeamMembershipID) erro
 }
 
 // DeleteTeamMembershipByUserID deletes all the TeamMembership object associated to a UserID.
-func (service *Service) DeleteTeamMembershipByUserID(userID portainer.UserID) error {
+func (service *Service) DeleteTeamMembershipByUserID(userID database.UserID) error {
 	return service.connection.DeleteAllObjects(
 		BucketName,
-		&portainer.TeamMembership{},
 		func(obj interface{}) (id int, ok bool) {
 			membership, ok := obj.(portainer.TeamMembership)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to TeamMembership object")
 				//return fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
 				return -1, false
 			}
-
 			if membership.UserID == userID {
 				return int(membership.ID), true
 			}
-
 			return -1, false
 		})
 }
 
 // DeleteTeamMembershipByTeamID deletes all the TeamMembership object associated to a TeamID.
-func (service *Service) DeleteTeamMembershipByTeamID(teamID portainer.TeamID) error {
+func (service *Service) DeleteTeamMembershipByTeamID(teamID database.TeamID) error {
 	return service.connection.DeleteAllObjects(
 		BucketName,
-		&portainer.TeamMembership{},
 		func(obj interface{}) (id int, ok bool) {
 			membership, ok := obj.(portainer.TeamMembership)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to TeamMembership object")
 				//return fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
 				return -1, false
 			}
-
 			if membership.TeamID == teamID {
 				return int(membership.ID), true
 			}
-
-			return -1, false
-		})
-}
-
-func (service *Service) DeleteTeamMembershipByTeamIDAndUserID(teamID portainer.TeamID, userID portainer.UserID) error {
-	return service.connection.DeleteAllObjects(
-		BucketName,
-		&portainer.TeamMembership{},
-		func(obj interface{}) (id int, ok bool) {
-			membership, ok := obj.(portainer.TeamMembership)
-			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to TeamMembership object")
-				//return fmt.Errorf("Failed to convert to TeamMembership object: %s", obj)
-				return -1, false
-			}
-
-			if membership.TeamID == teamID && membership.UserID == userID {
-				return int(membership.ID), true
-			}
-
 			return -1, false
 		})
 }

api/dataservices/tunnelserver/tunnelserver.go

@@ -2,6 +2,7 @@ package tunnelserver
 
 import (
 	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/database"
 )
 
 const (
@@ -12,7 +13,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -20,7 +21,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err

api/dataservices/user/user.go

@@ -2,12 +2,13 @@ package user
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 	"strings"
 
-	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices/errors"
+	"github.com/sirupsen/logrus"
 
-	"github.com/rs/zerolog/log"
+	portainer "github.com/portainer/portainer/api"
 )
 
 const (
@@ -17,7 +18,7 @@ const (
 
 // Service represents a service for managing environment(endpoint) data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -25,7 +26,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -37,7 +38,7 @@ func NewService(connection portainer.Connection) (*Service, error) {
 }
 
 // User returns a user by ID
-func (service *Service) User(ID portainer.UserID) (*portainer.User, error) {
+func (service *Service) User(ID database.UserID) (*portainer.User, error) {
 	var user portainer.User
 	identifier := service.connection.ConvertToKey(int(ID))
 
@@ -59,23 +60,18 @@ func (service *Service) UserByUsername(username string) (*portainer.User, error)
 		func(obj interface{}) (interface{}, error) {
 			user, ok := obj.(*portainer.User)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to User object")
-
+				logrus.WithField("obj", obj).Errorf("Failed to convert to User object")
 				return nil, fmt.Errorf("Failed to convert to User object: %s", obj)
 			}
-
 			if strings.EqualFold(user.Username, username) {
 				u = user
 				return nil, stop
 			}
-
 			return &portainer.User{}, nil
 		})
-
 	if err == stop {
 		return u, nil
 	}
-
 	if err == nil {
 		return nil, errors.ErrObjectNotFound
 	}
@@ -93,13 +89,10 @@ func (service *Service) Users() ([]portainer.User, error) {
 		func(obj interface{}) (interface{}, error) {
 			user, ok := obj.(*portainer.User)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to User object")
-
+				logrus.WithField("obj", obj).Errorf("Failed to convert to User object")
 				return nil, fmt.Errorf("Failed to convert to User object: %s", obj)
 			}
-
 			users = append(users, *user)
-
 			return &portainer.User{}, nil
 		})
 
@@ -116,15 +109,12 @@ func (service *Service) UsersByRole(role portainer.UserRole) ([]portainer.User,
 		func(obj interface{}) (interface{}, error) {
 			user, ok := obj.(*portainer.User)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to User object")
-
+				logrus.WithField("obj", obj).Errorf("Failed to convert to User object")
 				return nil, fmt.Errorf("Failed to convert to User object: %s", obj)
 			}
-
 			if user.Role == role {
 				users = append(users, *user)
 			}
-
 			return &portainer.User{}, nil
 		})
 
@@ -132,7 +122,7 @@ func (service *Service) UsersByRole(role portainer.UserRole) ([]portainer.User,
 }
 
 // UpdateUser saves a user.
-func (service *Service) UpdateUser(ID portainer.UserID, user *portainer.User) error {
+func (service *Service) UpdateUser(ID database.UserID, user *portainer.User) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	user.Username = strings.ToLower(user.Username)
 	return service.connection.UpdateObject(BucketName, identifier, user)
@@ -143,7 +133,7 @@ func (service *Service) Create(user *portainer.User) error {
 	return service.connection.CreateObject(
 		BucketName,
 		func(id uint64) (int, interface{}) {
-			user.ID = portainer.UserID(id)
+			user.ID = database.UserID(id)
 			user.Username = strings.ToLower(user.Username)
 
 			return int(user.ID), user
@@ -152,7 +142,7 @@ func (service *Service) Create(user *portainer.User) error {
 }
 
 // DeleteUser deletes a user.
-func (service *Service) DeleteUser(ID portainer.UserID) error {
+func (service *Service) DeleteUser(ID database.UserID) error {
 	identifier := service.connection.ConvertToKey(int(ID))
 	return service.connection.DeleteObject(BucketName, identifier)
 }

api/dataservices/version/version.go

@@ -1,28 +1,32 @@
 package version
 
 import (
-	"errors"
+	"github.com/portainer/portainer/api/database"
+	"strconv"
 
 	portainer "github.com/portainer/portainer/api"
-	"github.com/portainer/portainer/api/database/models"
-	"github.com/portainer/portainer/api/dataservices"
-	dserrors "github.com/portainer/portainer/api/dataservices/errors"
 )
 
 const (
 	// BucketName represents the name of the bucket where this service stores data.
 	BucketName  = "version"
-	versionKey  = "VERSION"
+	versionKey  = "DB_VERSION"
+	instanceKey = "INSTANCE_ID"
+	editionKey  = "EDITION"
 	updatingKey = "DB_UPDATING"
 )
 
 // Service represents a service to manage stored versions.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
+}
+
+func (service *Service) BucketName() string {
+	return BucketName
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -33,87 +37,56 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-func (service *Service) SchemaVersion() (string, error) {
-	v, err := service.Version()
-	if err != nil {
-		return "", err
-	}
-
-	return v.SchemaVersion, nil
-}
-
-func (service *Service) UpdateSchemaVersion(version string) error {
-	v, err := service.Version()
-	if err != nil {
-		return err
-	}
-
-	v.SchemaVersion = version
-	return service.UpdateVersion(v)
-}
-
-func (service *Service) Edition() (portainer.SoftwareEdition, error) {
-	v, err := service.Version()
+// DBVersion retrieves the stored database version.
+func (service *Service) DBVersion() (int, error) {
+	var version string
+	err := service.connection.GetObject(BucketName, []byte(versionKey), &version)
 	if err != nil {
 		return 0, err
 	}
+	return strconv.Atoi(version)
+}
 
-	return portainer.SoftwareEdition(v.Edition), nil
+// Edition retrieves the stored portainer edition.
+func (service *Service) Edition() (portainer.SoftwareEdition, error) {
+	var edition string
+	err := service.connection.GetObject(BucketName, []byte(editionKey), &edition)
+	if err != nil {
+		return 0, err
+	}
+	e, err := strconv.Atoi(edition)
+	if err != nil {
+		return 0, err
+	}
+	return portainer.SoftwareEdition(e), nil
+}
+
+// StoreDBVersion store the database version.
+func (service *Service) StoreDBVersion(version int) error {
+	return service.connection.UpdateObject(BucketName, []byte(versionKey), strconv.Itoa(version))
 }
 
 // IsUpdating retrieves the database updating status.
 func (service *Service) IsUpdating() (bool, error) {
 	var isUpdating bool
 	err := service.connection.GetObject(BucketName, []byte(updatingKey), &isUpdating)
-	if err != nil && errors.Is(err, dserrors.ErrObjectNotFound) {
-		return false, nil
-	}
 	return isUpdating, err
 }
 
 // StoreIsUpdating store the database updating status.
 func (service *Service) StoreIsUpdating(isUpdating bool) error {
-	return service.connection.DeleteObject(BucketName, []byte(updatingKey))
+	return service.connection.UpdateObject(BucketName, []byte(updatingKey), isUpdating)
 }
 
 // InstanceID retrieves the stored instance ID.
 func (service *Service) InstanceID() (string, error) {
-	v, err := service.Version()
-	if err != nil {
-		return "", err
-	}
-
-	return v.InstanceID, nil
+	var id string
+	err := service.connection.GetObject(BucketName, []byte(instanceKey), &id)
+	return id, err
 }
 
 // StoreInstanceID store the instance ID.
-func (service *Service) UpdateInstanceID(id string) error {
-	v, err := service.Version()
-	if err != nil {
-		if !dataservices.IsErrObjectNotFound(err) {
-			return err
-		}
+func (service *Service) StoreInstanceID(ID string) error {
+	return service.connection.UpdateObject(BucketName, []byte(instanceKey), ID)
 
-		v = &models.Version{}
-	}
-
-	v.InstanceID = id
-	return service.UpdateVersion(v)
-}
-
-// Version retrieve the version object.
-func (service *Service) Version() (*models.Version, error) {
-	var v models.Version
-
-	err := service.connection.GetObject(BucketName, []byte(versionKey), &v)
-	if err != nil {
-		return nil, err
-	}
-
-	return &v, nil
-}
-
-// UpdateVersion persists a Version object.
-func (service *Service) UpdateVersion(version *models.Version) error {
-	return service.connection.UpdateObject(BucketName, []byte(versionKey), version)
 }

api/dataservices/webhook/webhook.go

@@ -2,11 +2,11 @@ package webhook
 
 import (
 	"fmt"
+	"github.com/portainer/portainer/api/database"
 
 	portainer "github.com/portainer/portainer/api"
 	"github.com/portainer/portainer/api/dataservices/errors"
-
-	"github.com/rs/zerolog/log"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -16,7 +16,7 @@ const (
 
 // Service represents a service for managing webhook data.
 type Service struct {
-	connection portainer.Connection
+	connection database.Connection
 }
 
 func (service *Service) BucketName() string {
@@ -24,7 +24,7 @@ func (service *Service) BucketName() string {
 }
 
 // NewService creates a new instance of a service.
-func NewService(connection portainer.Connection) (*Service, error) {
+func NewService(connection database.Connection) (*Service, error) {
 	err := connection.SetServiceName(BucketName)
 	if err != nil {
 		return nil, err
@@ -35,7 +35,7 @@ func NewService(connection portainer.Connection) (*Service, error) {
 	}, nil
 }
 
-// Webhooks returns an array of all webhooks
+//Webhooks returns an array of all webhooks
 func (service *Service) Webhooks() ([]portainer.Webhook, error) {
 	var webhooks = make([]portainer.Webhook, 0)
 
@@ -45,12 +45,10 @@ func (service *Service) Webhooks() ([]portainer.Webhook, error) {
 		func(obj interface{}) (interface{}, error) {
 			webhook, ok := obj.(*portainer.Webhook)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Webhook object")
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Webhook object")
 				return nil, fmt.Errorf("Failed to convert to Webhook object: %s", obj)
 			}
-
 			webhooks = append(webhooks, *webhook)
-
 			return &portainer.Webhook{}, nil
 		})
 
@@ -80,23 +78,18 @@ func (service *Service) WebhookByResourceID(ID string) (*portainer.Webhook, erro
 		func(obj interface{}) (interface{}, error) {
 			webhook, ok := obj.(*portainer.Webhook)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Webhook object")
-
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Webhook object")
 				return nil, fmt.Errorf("Failed to convert to Webhook object: %s", obj)
 			}
-
 			if webhook.ResourceID == ID {
 				w = webhook
 				return nil, stop
 			}
-
 			return &portainer.Webhook{}, nil
 		})
-
 	if err == stop {
 		return w, nil
 	}
-
 	if err == nil {
 		return nil, errors.ErrObjectNotFound
 	}
@@ -114,23 +107,18 @@ func (service *Service) WebhookByToken(token string) (*portainer.Webhook, error)
 		func(obj interface{}) (interface{}, error) {
 			webhook, ok := obj.(*portainer.Webhook)
 			if !ok {
-				log.Debug().Str("obj", fmt.Sprintf("%#v", obj)).Msg("failed to convert to Webhook object")
-
+				logrus.WithField("obj", obj).Errorf("Failed to convert to Webhook object")
 				return nil, fmt.Errorf("Failed to convert to Webhook object: %s", obj)
 			}
-
 			if webhook.Token == token {
 				w = webhook
 				return nil, stop
 			}
-
 			return &portainer.Webhook{}, nil
 		})
-
 	if err == stop {
 		return w, nil
 	}
-
 	if err == nil {
 		return nil, errors.ErrObjectNotFound
 	}