chore(version): bump version number

This reverts commit 61d7b4f64c.

.codeclimate.yml

@@ -1,29 +0,0 @@
----
-engines:
-  gofmt:
-    enabled: true
-  golint:
-    enabled: true
-  govet:
-    enabled: true
-  csslint:
-    enabled: true
-  duplication:
-    enabled: true
-    config:
-      languages:
-        javascript:
-          mass_threshold: 80
-  eslint:
-    enabled: true
-    config:
-      config: .eslintrc.yml
-  fixme:
-    enabled: true
-ratings:
-  paths:
-  - "**.css"
-  - "**.js"
-  - "**.go"
-exclude_paths:
-- test/

.codefresh/codefresh_develop.yml

@@ -1,50 +0,0 @@
-version: '1.0'
-steps:
-
-  build_backend:
-    image: portainer/golang-builder:ci
-    working_directory: ${{main_clone}}
-    commands:
-      - mkdir -p /go/src/github.com/${{CF_REPO_OWNER}}
-      - ln -s /codefresh/volume/${{CF_REPO_NAME}}/api /go/src/github.com/${{CF_REPO_OWNER}}/${{CF_REPO_NAME}}
-      - /build.sh api/cmd/portainer
-
-  build_frontend:
-    image: portainer/angular-builder:latest
-    working_directory: ${{build_backend}}
-    commands:
-      - yarn
-      - yarn grunt build-webapp
-      - mv api/cmd/portainer/portainer dist/
-
-  get_docker_version:
-    image: alpine
-    working_directory: ${{build_frontend}}
-    commands:
-      - cf_export DOCKER_VERSION=`cat gruntfile.js | grep -m 1 'shippedDockerVersion' | cut -d\' -f2`
-
-  download_docker_binary:
-    image: busybox
-    working_directory: ${{build_frontend}}
-    commands:
-      - echo ${{DOCKER_VERSION}}
-      - wget -O /tmp/docker-binaries.tgz https://download.docker.com/linux/static/stable/x86_64/docker-${{DOCKER_VERSION}}.tgz
-      - tar -xf /tmp/docker-binaries.tgz -C /tmp
-      - mv /tmp/docker/docker dist/
-
-  build_image:
-    type: build
-    working_directory: ${{download_docker_binary}}
-    dockerfile: ./build/linux/Dockerfile
-    image_name: portainer/portainer
-    tag: ${{CF_BRANCH}}
-
-  push_image:
-    type: push
-    candidate: '${{build_image}}'
-    tag: '${{CF_BRANCH}}'
-    registry: dockerhub
-    when:
-      branch:
-        only:
-          - develop

.codefresh/codefresh_pullrequest.yml

@@ -1,46 +0,0 @@
-version: '1.0'
-steps:
-
-  build_backend:
-    image: portainer/golang-builder:ci
-    working_directory: ${{main_clone}}
-    commands:
-      - mkdir -p /go/src/github.com/${{CF_REPO_OWNER}}
-      - ln -s /codefresh/volume/${{CF_REPO_NAME}}/api /go/src/github.com/${{CF_REPO_OWNER}}/${{CF_REPO_NAME}}
-      - /build.sh api/cmd/portainer
-
-  build_frontend:
-    image: portainer/angular-builder:latest
-    working_directory: ${{build_backend}}
-    commands:
-      - yarn
-      - yarn grunt build-webapp
-      - mv api/cmd/portainer/portainer dist/
-
-  get_docker_version:
-    image: alpine
-    working_directory: ${{build_frontend}}
-    commands:
-      - cf_export DOCKER_VERSION=`cat gruntfile.js | grep -m 1 'shippedDockerVersion' | cut -d\' -f2`
-
-  download_docker_binary:
-    image: busybox
-    working_directory: ${{build_frontend}}
-    commands:
-      - echo ${{DOCKER_VERSION}}
-      - wget -O /tmp/docker-binaries.tgz https://download.docker.com/linux/static/stable/x86_64/docker-${{DOCKER_VERSION}}.tgz
-      - tar -xf /tmp/docker-binaries.tgz -C /tmp
-      - mv /tmp/docker/docker dist/
-
-  build_image:
-    type: build
-    working_directory: ${{download_docker_binary}}
-    dockerfile: ./build/linux/Dockerfile
-    image_name: portainer/portainer
-    tag: ${{CF_BRANCH}}
-
-  push_image:
-    type: push
-    candidate: '${{build_image}}'
-    tag: 'pr${{CF_PULL_REQUEST_NUMBER}}'
-    registry: dockerhub

.dockerignore

@@ -1,3 +1,2 @@
 *
 !dist
-!build

.eslintrc.yml

@@ -1,284 +0,0 @@
-env:
-  browser: true
-  jquery: true
-
-# globals:
-#   angular: true
-#   $: true
-#   _: true
-#   moment: true
-#   filesize: true
-#   splitargs: true
-extends:
-  - 'eslint:recommended'
-
-# http://eslint.org/docs/rules/
-rules:
-  # Possible Errors
-  no-await-in-loop: off
-  no-cond-assign: error
-  no-console: off
-  no-constant-condition: error
-  no-control-regex: error
-  no-debugger: error
-  no-dupe-args: error
-  no-dupe-keys: error
-  no-duplicate-case: error
-  no-empty-character-class: error
-  no-empty: error
-  no-ex-assign: error
-  no-extra-boolean-cast: error
-  no-extra-parens: off
-  no-extra-semi: error
-  no-func-assign: error
-  no-inner-declarations:
-    - error
-    - functions
-  no-invalid-regexp: error
-  no-irregular-whitespace: error
-  no-negated-in-lhs: error
-  no-obj-calls: error
-  no-prototype-builtins: off
-  no-regex-spaces: error
-  no-sparse-arrays: error
-  no-template-curly-in-string: off
-  no-unexpected-multiline: error
-  no-unreachable: error
-  no-unsafe-finally: off
-  no-unsafe-negation: off
-  use-isnan: error
-  valid-jsdoc: off
-  valid-typeof: error
-
-  # Best Practices
-  accessor-pairs: error
-  array-callback-return: off
-  block-scoped-var: off
-  class-methods-use-this: off
-  complexity:
-    - error
-    - 6
-  consistent-return: off
-  curly: off
-  default-case: off
-  dot-location: off
-  dot-notation: off
-  eqeqeq: error
-  guard-for-in: error
-  no-alert: error
-  no-caller: error
-  no-case-declarations: error
-  no-div-regex: error
-  no-else-return: off
-  no-empty-function: off
-  no-empty-pattern: error
-  no-eq-null: error
-  no-eval: error
-  no-extend-native: error
-  no-extra-bind: error
-  no-extra-label: off
-  no-fallthrough: error
-  no-floating-decimal: off
-  no-global-assign: off
-  no-implicit-coercion: off
-  no-implied-eval: error
-  no-invalid-this: off
-  no-iterator: error
-  no-labels:
-    - error
-    - allowLoop: true
-      allowSwitch: true
-  no-lone-blocks: error
-  no-loop-func: error
-  no-magic-number: off
-  no-multi-spaces: off
-  no-multi-str: off
-  no-native-reassign: error
-  no-new-func: error
-  no-new-wrappers: error
-  no-new: error
-  no-octal-escape: error
-  no-octal: error
-  no-param-reassign: off
-  no-proto: error
-  no-redeclare: error
-  no-restricted-properties: off
-  no-return-assign: error
-  no-return-await: off
-  no-script-url: error
-  no-self-assign: off
-  no-self-compare: error
-  no-sequences: off
-  no-throw-literal: off
-  no-unmodified-loop-condition: off
-  no-unused-expressions: error
-  no-unused-labels: off
-  no-useless-call: error
-  no-useless-concat: error
-  no-useless-escape: off
-  no-useless-return: off
-  no-void: error
-  no-warning-comments: off
-  no-with: error
-  prefer-promise-reject-errors: off
-  radix: error
-  require-await: off
-  vars-on-top: off
-  wrap-iife: error
-  yoda: off
-
-  # Strict
-  strict: off
-
-  # Variables
-  init-declarations: off
-  no-catch-shadow: error
-  no-delete-var: error
-  no-label-var: error
-  no-restricted-globals: off
-  no-shadow-restricted-names: error
-  no-shadow: off
-  no-undef-init: error
-  no-undef: off
-  no-undefined: off
-  no-unused-vars: off
-  no-use-before-define: off
-
-  # Node.js and CommonJS
-  callback-return: error
-  global-require: error
-  handle-callback-err: error
-  no-mixed-requires: off
-  no-new-require: off
-  no-path-concat: error
-  no-process-env: off
-  no-process-exit: error
-  no-restricted-modules: off
-  no-sync: off
-
-  # Stylistic Issues
-  array-bracket-spacing: off
-  block-spacing: off
-  brace-style: off
-  camelcase: off
-  capitalized-comments: off
-  comma-dangle:
-    - error
-    - never
-  comma-spacing: off
-  comma-style: off
-  computed-property-spacing: off
-  consistent-this: off
-  eol-last: off
-  func-call-spacing: off
-  func-name-matching: off
-  func-names: off
-  func-style: off
-  id-length: off
-  id-match: off
-  indent: off
-  jsx-quotes: off
-  key-spacing: off
-  keyword-spacing: off
-  line-comment-position: off
-  linebreak-style:
-    - error
-    - unix
-  lines-around-comment: off
-  lines-around-directive: off
-  max-depth: off
-  max-len: off
-  max-nested-callbacks: off
-  max-params: off
-  max-statements-per-line: off
-  max-statements:
-    - error
-    - 30
-  multiline-ternary: off
-  new-cap: off
-  new-parens: off
-  newline-after-var: off
-  newline-before-return: off
-  newline-per-chained-call: off
-  no-array-constructor: off
-  no-bitwise: off
-  no-continue: off
-  no-inline-comments: off
-  no-lonely-if: off
-  no-mixed-operators: off
-  no-mixed-spaces-and-tabs: off
-  no-multi-assign: off
-  no-multiple-empty-lines: off
-  no-negated-condition: off
-  no-nested-ternary: off
-  no-new-object: off
-  no-plusplus: off
-  no-restricted-syntax: off
-  no-spaced-func: off
-  no-tabs: off
-  no-ternary: off
-  no-trailing-spaces: off
-  no-underscore-dangle: off
-  no-unneeded-ternary: off
-  object-curly-newline: off
-  object-curly-spacing: off
-  object-property-newline: off
-  one-var-declaration-per-line: off
-  one-var: off
-  operator-assignment: off
-  operator-linebreak: off
-  padded-blocks: off
-  quote-props: off
-  quotes:
-    - error
-    - single
-  require-jsdoc: off
-  semi-spacing: off
-  semi:
-    - error
-    - always
-  sort-keys: off
-  sort-vars: off
-  space-before-blocks: off
-  space-before-function-paren: off
-  space-in-parens: off
-  space-infix-ops: off
-  space-unary-ops: off
-  spaced-comment: off
-  template-tag-spacing: off
-  unicode-bom: off
-  wrap-regex: off
-
-  # ECMAScript 6
-  arrow-body-style: off
-  arrow-parens: off
-  arrow-spacing: off
-  constructor-super: off
-  generator-star-spacing: off
-  no-class-assign: off
-  no-confusing-arrow: off
-  no-const-assign: off
-  no-dupe-class-members: off
-  no-duplicate-imports: off
-  no-new-symbol: off
-  no-restricted-imports: off
-  no-this-before-super: off
-  no-useless-computed-key: off
-  no-useless-constructor: off
-  no-useless-rename: off
-  no-var: off
-  object-shorthand: off
-  prefer-arrow-callback: off
-  prefer-const: off
-  prefer-destructuring: off
-  prefer-numeric-literals: off
-  prefer-rest-params: off
-  prefer-reflect: off
-  prefer-spread: off
-  prefer-template: off
-  require-yield: off
-  rest-spread-spacing: off
-  sort-imports: off
-  symbol-description: off
-  template-curly-spacing: off
-  yield-star-spacing: off

.github/ISSUE_TEMPLATE.md

@@ -1,44 +0,0 @@
-<!--
-
-Thanks for opening an issue on Portainer !
-
-Do you need help or have a question? Come chat with us on Slack http://portainer.io/slack/ or gitter https://gitter.im/portainer/Lobby.
-
-If you are reporting a new issue, make sure that we do not have any duplicates
-already open. You can ensure this by searching the issue list for this
-repository. If there is a duplicate, please close your issue and add a comment
-to the existing issue instead.
-
-Also, be sure to check our FAQ and documentation first: https://portainer.readthedocs.io
-
-If you suspect your issue is a bug, please edit your issue description to
-include the BUG REPORT INFORMATION shown below.
-
----------------------------------------------------
-BUG REPORT INFORMATION
----------------------------------------------------
-You do NOT have to include this information if this is a FEATURE REQUEST
--->
-
-**Description**
-
-<!--
-Briefly describe the problem you are having in a few paragraphs.
--->
-
-**Steps to reproduce the issue:**
-
-1.
-2.
-3.
-
-Any other info e.g. Why do you consider this to be a bug? What did you expect to happen instead?
-
-**Technical details:**
-
-* Portainer version:
-* Target Docker version (the host/cluster you manage):
-* Platform (windows/linux):
-* Command used to start Portainer (`docker run -p 9000:9000 portainer/portainer`):
-* Target Swarm version (if applicable):
-* Browser:

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -1,47 +0,0 @@
----
-name: Bug report
-about: Create a bug report
-
----
-
-<!--
-
-Thanks for reporting a bug for Portainer !
-
-Do you need help or have a question? Come chat with us on Slack http://portainer.io/slack/ or gitter https://gitter.im/portainer/Lobby.
-
-Before opening a new issue, make sure that we do not have any duplicates
-already open. You can ensure this by searching the issue list for this
-repository. If there is a duplicate, please close your issue and add a comment
-to the existing issue instead.
-
-Also, be sure to check our FAQ and documentation first: https://portainer.readthedocs.io
--->
-
-**Bug description**
-
-A clear and concise description of what the bug is.
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-Briefly describe what you were expecting.
-
-**Steps to reproduce the issue:**
-
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Technical details:**
-
-* Portainer version:
-* Docker version (managed by Portainer):
-* Platform (windows/linux):
-* Command used to start Portainer (`docker run -p 9000:9000 portainer/portainer`):
-* Browser:
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/Custom.md

@@ -1,15 +0,0 @@
----
-name: Question
-about: Ask us a question about Portainer usage or deployment
-
----
-
-<!--
-
-Do you need help or have a question? Come chat with us on Slack http://portainer.io/slack/ or gitter https://gitter.im/portainer/Lobby.
-
-Also, be sure to check our FAQ and documentation first: https://portainer.readthedocs.io
--->
-
-**Question**:
-How can I deploy Portainer on... ?

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -1,31 +0,0 @@
----
-name: Feature request
-about: Suggest a feature/enhancement that should be added in Portainer
-
----
-
-<!--
-
-Thanks for opening a feature request for Portainer !
-
-Do you need help or have a question? Come chat with us on Slack http://portainer.io/slack/ or gitter https://gitter.im/portainer/Lobby.
-
-Before opening a new issue, make sure that we do not have any duplicates
-already open. You can ensure this by searching the issue list for this
-repository. If there is a duplicate, please close your issue and add a comment
-to the existing issue instead.
-
-Also, be sure to check our FAQ and documentation first: https://portainer.readthedocs.io
--->
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.gitignore

@@ -1,6 +1,10 @@
+logs/*
+!.gitkeep
+*.esproj/*
 node_modules
 bower_components
+.idea
+*.iml
 dist
-portainer-checksum.txt
-api/cmd/portainer/portainer*
-.tmp
+dist/*
+ui-for-docker-checksum.txt

.godir

@@ -1 +1 @@
-portainer
+dockerui

CODE_OF_CONDUCT.md

@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at anthony.lapenna@portainer.io. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -1,76 +0,0 @@
-# Contributing Guidelines
-
-Some basic conventions for contributing to this project.
-
-### General
-
-Please make sure that there aren't existing pull requests attempting to address the issue mentioned. Likewise, please check for issues related to update, as someone else may be working on the issue in a branch or fork.
-
-* Please open a discussion in a new issue / existing issue to talk about the changes you'd like to bring
-* Develop in a topic branch, not master/develop
-
-When creating a new branch, prefix it with the *type* of the change (see section **Commit Message Format** below), the associated opened issue number, a dash and some text describing the issue (using dash as a separator).
-
-For example, if you work on a bugfix for the issue #361, you could name the branch `fix361-template-selection`.
-
-### Issues open to contribution
-
-Want to contribute but don't know where to start?
-
-Some of the open issues are labeled with prefix `exp/`, this is used to mark them as available for contributors to work on. All of these have an attributed difficulty level:
-
-* **beginner**: a task that should be accessible with users not familiar with the codebase
-* **intermediate**: a task that require some understanding of the project codebase or some experience in
-either AngularJS or Golang
-* **advanced**: a task that require a deep understanding of the project codebase
-
-You can have a use Github filters to list these issues:
-
-* beginner labeled issues: https://github.com/portainer/portainer/labels/exp%2Fbeginner
-* intermediate labeled issues: https://github.com/portainer/portainer/labels/exp%2Fintermediate
-* advanced labeled issues: https://github.com/portainer/portainer/labels/exp%2Fadvanced
-
-
-### Commit Message Format
-
-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:
-
-```
- #271 feat(containers): add exposed ports in the containers view
- #270 fix(templates): fix a display issue in the templates view
- #269 style(dashboard): update dashboard with new layout
-```
-
-#### Type
-
-Must be one of the following:
-
-* **feat**: A new feature
-* **fix**: A bug fix
-* **docs**: Documentation only changes
-* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
-  semi-colons, etc)
-* **refactor**: A code change that neither fixes a bug or adds a feature
-* **test**: Adding missing tests
-* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
-  generation
-
-#### Scope
-
-The scope could be anything specifying place of the commit change. For example `networks`,
-`containers`, `images` etc...
-You can use the **area** label tag associated on the issue here (for `area/containers` use `containers` as a scope...)
-
-#### Subject
-
-The subject contains succinct description of the change:
-
-* use the imperative, present tense: "change" not "changed" nor "changes"
-* don't capitalize first letter
-* no dot (.) at the end

Dockerfile

@@ -0,0 +1,8 @@
+FROM scratch
+
+COPY dist /
+
+VOLUME /data
+
+EXPOSE 9000
+ENTRYPOINT ["/ui-for-docker"]

LICENSE

@@ -1,24 +1,24 @@
-Portainer: Copyright (c) 2016 Portainer.io
+Cloudinovasi-ui: Copyright (c) 2016 Cloudinovasi
 
-This software is provided 'as-is', without any express or implied
-warranty.  In no event will the authors be held liable for any damages
-arising from the use of this software.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-1. The origin of this software must not be misrepresented; you must not
-   claim that you wrote the original software. If you use this software
-   in a product, an acknowledgment in the product documentation would be
-   appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 
 
-Portainer contains code which was originally under this license:
-
-UI For Docker: Copyright (c) 2013-2016 Michael Crosby (crosbymichael.com), Kevan Ahlquist (kevanahlquist.com), Anthony Lapenna (portainer.io)
+UI For Docker: Copyright (c) 2013-2016 Michael Crosby (crosbymichael.com), Kevan Ahlquist (kevanahlquist.com), Anthony Lapenna (anthonylapenna at cloudinovasi dot id)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Procfile

@@ -0,0 +1 @@
+web: dockerui -p ":$PORT" -e "$DOCKER_ENDPOINT"

README.md

@@ -1,63 +1,171 @@
+# Cloudinovasi UI for Docker
 
-<p align="center">
-  <img title="portainer" src='https://portainer.io/images/logo_alt.png' />
-</p>
+This UI is dedicated to CloudInovasi internal usage.
 
-[![Docker Pulls](https://img.shields.io/docker/pulls/portainer/portainer.svg)](https://hub.docker.com/r/portainer/portainer/)
-[![Microbadger](https://images.microbadger.com/badges/image/portainer/portainer.svg)](http://microbadger.com/images/portainer/portainer "Image size")
-[![Documentation Status](https://readthedocs.org/projects/portainer/badge/?version=stable)](http://portainer.readthedocs.io/en/stable/?badge=stable)
-[![Codefresh build status]( https://g.codefresh.io/api/badges/build?repoOwner=portainer&repoName=portainer&branch=develop&pipelineName=portainer-ci&accountName=deviantony&type=cf-1)]( https://g.codefresh.io/repositories/portainer/portainer/builds?filter=trigger:build;branch:develop;service:5922a08a3a1aab000116fcc6~portainer-ci)
-[![Code Climate](https://codeclimate.com/github/portainer/portainer/badges/gpa.svg)](https://codeclimate.com/github/portainer/portainer)
-[![Slack](https://portainer.io/slack/badge.svg)](https://portainer.io/slack/)
-[![Gitter](https://badges.gitter.im/portainer/Lobby.svg)](https://gitter.im/portainer/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=YHXZJQNJQ36H6)
+A fork of the amazing UI for Docker by Michael Crosby and Kevan Ahlquist (https://github.com/kevana/ui-for-docker) using the rdash-angular theme (https://github.com/rdash/rdash-angular).
 
-**_Portainer_** is a lightweight management UI which allows you to **easily** manage your different Docker environments (Docker hosts or Swarm clusters).
+![Dashboard](/dashboard.png)
 
-**_Portainer_** is meant to be as **simple** to deploy as it is to use. It consists of a single container that can run on any Docker engine (can be deployed as Linux container or a Windows native container).
+UI For Docker is a web interface for the Docker Remote API.  The goal is to provide a pure client side implementation so it is effortless to connect and manage docker.
 
-**_Portainer_** allows you to manage your Docker containers, images, volumes, networks and more ! It is compatible with the *standalone Docker* engine and with *Docker Swarm mode*.
+## Goals
+* Minimal dependencies - I really want to keep this project a pure html/js app.
+* Consistency - The web UI should be consistent with the commands found on the docker CLI.
 
-## Demo
+## Supported Docker versions
 
-<img src="https://portainer.io/images/screenshots/portainer.gif" width="77%"/>
+The current Docker version support policy is the following: `N` to `N-2` included where `N` is the latest version.
 
-You can try out the public demo instance: http://demo.portainer.io/ (login with the username **admin** and the password **tryportainer**).
+At the moment, the following versions are supported: 1.9, 1.10 & 1.11.
 
-Please note that the public demo cluster is **reset every 15min**.
+## Run
 
-Alternatively, you can deploy a copy of the demo stack inside a [play-with-docker (PWD)](https://labs.play-with-docker.com) playground:
+### Quickstart
 
-- Browse [PWD/?stack=portainer-demo/play-with-docker/docker-stack.yml](http://play-with-docker.com/?stack=https://raw.githubusercontent.com/portainer/portainer-demo/master/play-with-docker/docker-stack.yml)
-- Sign in with your [Docker ID](https://docs.docker.com/docker-id)
-- Follow [these](https://github.com/portainer/portainer-demo/blob/master/play-with-docker/docker-stack.yml#L5-L8) steps.
+1. Run: `docker run -d -p 9000:9000 --privileged -v /var/run/docker.sock:/var/run/docker.sock cloudinovasi/cloudinovasi-ui`
 
-Unlike the public demo, the playground sessions are deleted after 4 hours. Apart from that, all the settings are same, including default credentials.
+2. Open your browser to `http://<dockerd host ip>:9000`
 
-## Getting started
+Bind mounting the Unix socket into the UI For Docker container is much more secure than exposing your docker daemon over TCP.
 
-* [Deploy Portainer](https://portainer.readthedocs.io/en/latest/deployment.html)
-* [Documentation](https://portainer.readthedocs.io)
+The `--privileged` flag is required for hosts using SELinux.
 
-## Getting help
+### Specify socket to connect to Docker daemon
 
-* Issues: https://github.com/portainer/portainer/issues
-* FAQ: https://portainer.readthedocs.io/en/latest/faq.html
-* Slack (chat): https://portainer.io/slack/
-* Gitter (chat): https://gitter.im/portainer/Lobby
+By default UI For Docker connects to the Docker daemon with`/var/run/docker.sock`. For this to work you need to bind mount the unix socket into the container with `-v /var/run/docker.sock:/var/run/docker.sock`.
 
-## Reporting bugs and contributing
+You can use the `--host`, `-H` flags to change this socket:
 
-* Want to report a bug or request a feature? Please open [an issue](https://github.com/portainer/portainer/issues/new).
-* Want to help us build **_portainer_**? Follow our [contribution guidelines](https://portainer.readthedocs.io/en/latest/contribute.html) to build it  locally and make a pull request. We need all the help we can get!
+```
+# Connect to a tcp socket:
+$ docker run -d -p 9000:9000 cloudinovasi/cloudinovasi-ui -H tcp://127.0.0.1:2375
+```
 
-## Limitations
+```
+# Connect to another unix socket:
+$ docker run -d -p 9000:9000 cloudinovasi/cloudinovasi-ui -H unix:///path/to/docker.sock
+```
 
-**_Portainer_** has full support for the following Docker versions:
+### Swarm support
 
-* Docker 1.10 to the latest version
-* Docker Swarm >= 1.2.3
+**Supported Swarm version: 1.2.3**
 
-Partial support for the following Docker versions (some features may not be available):
+You can access a specific view for you Swarm cluster by defining the `--swarm` flag:
 
-* Docker 1.9
+```
+# Connect to a tcp socket and enable Swarm:
+$ docker run -d -p 9000:9000 cloudinovasi/cloudinovasi-ui -H tcp://<SWARM_HOST>:<SWARM_PORT> --swarm
+```
+
+*NOTE*: Due to Swarm not exposing information in a machine readable way, the app is bound to a specific version of Swarm at the moment.
+
+### Change address/port UI For Docker is served on
+UI For Docker listens on port 9000 by default. If you run UI For Docker inside a container then you can bind the container's internal port to any external address and port:
+
+```
+# Expose UI For Docker on 10.20.30.1:80
+$ docker run -d -p 10.20.30.1:80:9000 --privileged -v /var/run/docker.sock:/var/run/docker.sock cloudinovasi/cloudinovasi-ui
+```
+
+### Access a Docker engine protected via TLS
+
+Ensure that you have access to the CA, the cert and the public key used to access your Docker engine.  
+
+These files will need to be named `ca.pem`, `cert.pem` and `key.pem` respectively. Store them somewhere on your disk and mount a volume containing these files inside the UI container:
+
+```
+$ docker run -d -p 9000:9000 cloudinovasi/cloudinovasi-ui -v /path/to/certs:/certs -H https://my-docker-host.domain:2376 --tlsverify
+```
+
+You can also use the `--tlscacert`, `--tlscert` and `--tlskey` flags if you want to change the default path to the CA, certificate and key file respectively:
+
+```
+$ docker run -d -p 9000:9000 cloudinovasi/cloudinovasi-ui -v /path/to/certs:/certs -H https://my-docker-host.domain:2376 --tlsverify --tlscacert /certs/myCa.pem --tlscert /certs/myCert.pem --tlskey /certs/myKey.pem
+```
+
+*Note*: Replace `/path/to/certs` to the path to the certificate files on your disk.
+
+### Use your own logo
+
+You can use the `--logo` flag to specify an URL to your own logo.
+
+For example, using the Docker logo:
+
+```
+$ docker run -d -p 9000:9000 --privileged -v /var/run/docker.sock:/var/run/docker.sock cloudinovasi/cloudinovasi-ui --logo "https://www.docker.com/sites/all/themes/docker/assets/images/brand-full.svg"
+```
+
+The custom logo will replace the CloudInovasi logo in the UI.
+
+### Hide containers with specific labels
+
+You can hide specific containers in the containers view by using the `--hide-label` or `-l` options and specifying a label.
+
+For example, take a container started with the label `owner=acme`:
+
+```
+$ docker run -d --label owner=acme nginx
+```
+
+You can hide it in the view by starting the ui with:
+
+```
+$ docker run -d -p 9000:9000 --privileged -v /var/run/docker.sock:/var/run/docker.sock cloudinovasi/cloudinovasi-ui -l owner=acme
+```
+
+### Custom Docker registries support
+
+You can specify the support of others registries than DockerHub by using the `--registries` or `-r` options and specifying a registry using the format *REGISTRY_NAME=REGISTRY_ADDRESS*.
+
+For example, if I want the registry 'myCustomRegistry' pointing to *myregistry.domain.com:5000* available in the UI:
+
+```
+$ docker run -d -p 9000:9000 --privileged -v /var/run/docker.sock:/var/run/docker.sock cloudinovasi/cloudinovasi-ui -r myCustomRegistry=myregistry.domain.com:5000
+```
+
+### Reverse proxy configuration
+
+Has been tested with Nginx 1.11.
+
+Use the following configuration to host the UI at `myhost.mydomain.com/dockerui`:
+
+```nginx
+upstream cloudinovasi-ui {
+    server ADDRESS:PORT;
+}
+
+server {
+  listen 80;
+
+  location /dockerui/ {
+      proxy_http_version 1.1;
+      proxy_set_header Connection "";
+      proxy_pass http://cloudinovasi-ui/;
+  }
+  location /dockerui/ws/ {
+      proxy_set_header Upgrade $http_upgrade;
+      proxy_set_header Connection "upgrade";
+      proxy_http_version 1.1;
+      proxy_pass http://cloudinovasi-ui/ws/;
+  }
+}
+```
+
+Replace `ADDRESS:PORT` with the CloudInovasi UI container details.
+
+### Available options
+
+The following options are available for the `ui-for-docker` binary:
+
+* `--host`, `-H`: Docker daemon endpoint (default: `"unix:///var/run/docker.sock"`)
+* `--bind`, `-p`: Address and port to serve UI For Docker (default: `":9000"`)
+* `--data`, `-d`: Path to the data folder (default: `"."`)
+* `--assets`, `-a`: Path to the assets (default: `"."`)
+* `--swarm`, `-s`: Swarm cluster support (default: `false`)
+* `--registries`, `-r`: Available registries in the UI (format *REGISTRY_NAME=REGISTRY_ADDRESS*)
+* `--tlsverify`: TLS support (default: `false`)
+* `--tlscacert`: Path to the CA (default `/certs/ca.pem`)
+* `--tlscert`: Path to the TLS certificate file (default `/certs/cert.pem`)
+* `--tlskey`: Path to the TLS key (default `/certs/key.pem`)
+* `--hide-label`, `-l`: Hide containers with a specific label in the UI
+* `--logo`: URL to a picture to be displayed as a logo in the UI

api/api.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"crypto/tls"
+	"log"
+	"net/http"
+	"net/url"
+)
+
+type (
+	api struct {
+		endpoint    *url.URL
+		bindAddress string
+		assetPath   string
+		dataPath    string
+		tlsConfig   *tls.Config
+	}
+
+	apiConfig struct {
+		Endpoint      string
+		BindAddress   string
+		AssetPath     string
+		DataPath      string
+		SwarmSupport  bool
+		TLSEnabled    bool
+		TLSCACertPath string
+		TLSCertPath   string
+		TLSKeyPath    string
+	}
+)
+
+func (a *api) run(settings *Settings) {
+	handler := a.newHandler(settings)
+	if err := http.ListenAndServe(a.bindAddress, handler); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func newAPI(apiConfig apiConfig) *api {
+	endpointURL, err := url.Parse(apiConfig.Endpoint)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var tlsConfig *tls.Config
+	if apiConfig.TLSEnabled {
+		tlsConfig = newTLSConfig(apiConfig.TLSCACertPath, apiConfig.TLSCertPath, apiConfig.TLSKeyPath)
+	}
+
+	return &api{
+		endpoint:    endpointURL,
+		bindAddress: apiConfig.BindAddress,
+		assetPath:   apiConfig.AssetPath,
+		dataPath:    apiConfig.DataPath,
+		tlsConfig:   tlsConfig,
+	}
+}

api/archive/tar.go

@@ -1,36 +0,0 @@
-package archive
-
-import (
-	"archive/tar"
-	"bytes"
-)
-
-// TarFileInBuffer will create a tar archive containing a single file named via fileName and using the content
-// specified in fileContent. Returns the archive as a byte array.
-func TarFileInBuffer(fileContent []byte, fileName string) ([]byte, error) {
-	var buffer bytes.Buffer
-	tarWriter := tar.NewWriter(&buffer)
-
-	header := &tar.Header{
-		Name: fileName,
-		Mode: 0600,
-		Size: int64(len(fileContent)),
-	}
-
-	err := tarWriter.WriteHeader(header)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = tarWriter.Write(fileContent)
-	if err != nil {
-		return nil, err
-	}
-
-	err = tarWriter.Close()
-	if err != nil {
-		return nil, err
-	}
-
-	return buffer.Bytes(), nil
-}

api/bolt/datastore.go

@@ -1,174 +0,0 @@
-package bolt
-
-import (
-	"log"
-	"os"
-	"time"
-
-	"github.com/boltdb/bolt"
-	"github.com/portainer/portainer"
-)
-
-// Store defines the implementation of portainer.DataStore using
-// BoltDB as the storage system.
-type Store struct {
-	// Path where is stored the BoltDB database.
-	Path string
-
-	// Services
-	UserService            *UserService
-	TeamService            *TeamService
-	TeamMembershipService  *TeamMembershipService
-	EndpointService        *EndpointService
-	EndpointGroupService   *EndpointGroupService
-	ResourceControlService *ResourceControlService
-	VersionService         *VersionService
-	SettingsService        *SettingsService
-	RegistryService        *RegistryService
-	DockerHubService       *DockerHubService
-	StackService           *StackService
-
-	db                    *bolt.DB
-	checkForDataMigration bool
-}
-
-const (
-	databaseFileName          = "portainer.db"
-	versionBucketName         = "version"
-	userBucketName            = "users"
-	teamBucketName            = "teams"
-	teamMembershipBucketName  = "team_membership"
-	endpointBucketName        = "endpoints"
-	endpointGroupBucketName   = "endpoint_groups"
-	resourceControlBucketName = "resource_control"
-	settingsBucketName        = "settings"
-	registryBucketName        = "registries"
-	dockerhubBucketName       = "dockerhub"
-	stackBucketName           = "stacks"
-)
-
-// NewStore initializes a new Store and the associated services
-func NewStore(storePath string) (*Store, error) {
-	store := &Store{
-		Path:                   storePath,
-		UserService:            &UserService{},
-		TeamService:            &TeamService{},
-		TeamMembershipService:  &TeamMembershipService{},
-		EndpointService:        &EndpointService{},
-		EndpointGroupService:   &EndpointGroupService{},
-		ResourceControlService: &ResourceControlService{},
-		VersionService:         &VersionService{},
-		SettingsService:        &SettingsService{},
-		RegistryService:        &RegistryService{},
-		DockerHubService:       &DockerHubService{},
-		StackService:           &StackService{},
-	}
-	store.UserService.store = store
-	store.TeamService.store = store
-	store.TeamMembershipService.store = store
-	store.EndpointService.store = store
-	store.EndpointGroupService.store = store
-	store.ResourceControlService.store = store
-	store.VersionService.store = store
-	store.SettingsService.store = store
-	store.RegistryService.store = store
-	store.DockerHubService.store = store
-	store.StackService.store = store
-
-	_, err := os.Stat(storePath + "/" + databaseFileName)
-	if err != nil && os.IsNotExist(err) {
-		store.checkForDataMigration = false
-	} else if err != nil {
-		return nil, err
-	} else {
-		store.checkForDataMigration = true
-	}
-
-	return store, nil
-}
-
-// Open opens and initializes the BoltDB database.
-func (store *Store) Open() error {
-	path := store.Path + "/" + databaseFileName
-
-	db, err := bolt.Open(path, 0600, &bolt.Options{Timeout: 1 * time.Second})
-	if err != nil {
-		return err
-	}
-	store.db = db
-
-	bucketsToCreate := []string{versionBucketName, userBucketName, teamBucketName, endpointBucketName,
-		endpointGroupBucketName, resourceControlBucketName, teamMembershipBucketName, settingsBucketName,
-		registryBucketName, dockerhubBucketName, stackBucketName}
-
-	return db.Update(func(tx *bolt.Tx) error {
-
-		for _, bucket := range bucketsToCreate {
-			_, err := tx.CreateBucketIfNotExists([]byte(bucket))
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-}
-
-// Init creates the default data set.
-func (store *Store) Init() error {
-	groups, err := store.EndpointGroupService.EndpointGroups()
-	if err != nil {
-		return err
-	}
-
-	if len(groups) == 0 {
-		unassignedGroup := &portainer.EndpointGroup{
-			Name:            "Unassigned",
-			Description:     "Unassigned endpoints",
-			Labels:          []portainer.Pair{},
-			AuthorizedUsers: []portainer.UserID{},
-			AuthorizedTeams: []portainer.TeamID{},
-		}
-
-		return store.EndpointGroupService.CreateEndpointGroup(unassignedGroup)
-	}
-
-	return nil
-}
-
-// Close closes the BoltDB database.
-func (store *Store) Close() error {
-	if store.db != nil {
-		return store.db.Close()
-	}
-	return nil
-}
-
-// MigrateData automatically migrate the data based on the DBVersion.
-func (store *Store) MigrateData() error {
-	if !store.checkForDataMigration {
-		err := store.VersionService.StoreDBVersion(portainer.DBVersion)
-		if err != nil {
-			return err
-		}
-		return nil
-	}
-
-	version, err := store.VersionService.DBVersion()
-	if err == portainer.ErrDBVersionNotFound {
-		version = 0
-	} else if err != nil {
-		return err
-	}
-
-	if version < portainer.DBVersion {
-		log.Printf("Migrating database from version %v to %v.\n", version, portainer.DBVersion)
-		migrator := NewMigrator(store, version)
-		err = migrator.Migrate()
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/bolt/dockerhub_service.go

@@ -1,61 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// DockerHubService represents a service for managing registries.
-type DockerHubService struct {
-	store *Store
-}
-
-const (
-	dbDockerHubKey = "DOCKERHUB"
-)
-
-// DockerHub returns the DockerHub object.
-func (service *DockerHubService) DockerHub() (*portainer.DockerHub, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(dockerhubBucketName))
-		value := bucket.Get([]byte(dbDockerHubKey))
-		if value == nil {
-			return portainer.ErrDockerHubNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var dockerhub portainer.DockerHub
-	err = internal.UnmarshalDockerHub(data, &dockerhub)
-	if err != nil {
-		return nil, err
-	}
-	return &dockerhub, nil
-}
-
-// StoreDockerHub persists a DockerHub object.
-func (service *DockerHubService) StoreDockerHub(dockerhub *portainer.DockerHub) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(dockerhubBucketName))
-
-		data, err := internal.MarshalDockerHub(dockerhub)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put([]byte(dbDockerHubKey), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/endpoint_group_service.go

@@ -1,114 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// EndpointGroupService represents a service for managing endpoint groups.
-type EndpointGroupService struct {
-	store *Store
-}
-
-// EndpointGroup returns an endpoint group by ID.
-func (service *EndpointGroupService) EndpointGroup(ID portainer.EndpointGroupID) (*portainer.EndpointGroup, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointGroupBucketName))
-		value := bucket.Get(internal.Itob(int(ID)))
-		if value == nil {
-			return portainer.ErrEndpointGroupNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var endpointGroup portainer.EndpointGroup
-	err = internal.UnmarshalEndpointGroup(data, &endpointGroup)
-	if err != nil {
-		return nil, err
-	}
-	return &endpointGroup, nil
-}
-
-// EndpointGroups return an array containing all the endpoint groups.
-func (service *EndpointGroupService) EndpointGroups() ([]portainer.EndpointGroup, error) {
-	var endpointGroups = make([]portainer.EndpointGroup, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointGroupBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var endpointGroup portainer.EndpointGroup
-			err := internal.UnmarshalEndpointGroup(v, &endpointGroup)
-			if err != nil {
-				return err
-			}
-			endpointGroups = append(endpointGroups, endpointGroup)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return endpointGroups, nil
-}
-
-// CreateEndpointGroup assign an ID to a new endpoint group and saves it.
-func (service *EndpointGroupService) CreateEndpointGroup(endpointGroup *portainer.EndpointGroup) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointGroupBucketName))
-
-		id, _ := bucket.NextSequence()
-		endpointGroup.ID = portainer.EndpointGroupID(id)
-
-		data, err := internal.MarshalEndpointGroup(endpointGroup)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put(internal.Itob(int(endpointGroup.ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// UpdateEndpointGroup updates an endpoint group.
-func (service *EndpointGroupService) UpdateEndpointGroup(ID portainer.EndpointGroupID, endpointGroup *portainer.EndpointGroup) error {
-	data, err := internal.MarshalEndpointGroup(endpointGroup)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointGroupBucketName))
-		err = bucket.Put(internal.Itob(int(ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteEndpointGroup deletes an endpoint group.
-func (service *EndpointGroupService) DeleteEndpointGroup(ID portainer.EndpointGroupID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointGroupBucketName))
-		err := bucket.Delete(internal.Itob(int(ID)))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/endpoint_service.go

@@ -1,154 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// EndpointService represents a service for managing endpoints.
-type EndpointService struct {
-	store *Store
-}
-
-// Endpoint returns an endpoint by ID.
-func (service *EndpointService) Endpoint(ID portainer.EndpointID) (*portainer.Endpoint, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointBucketName))
-		value := bucket.Get(internal.Itob(int(ID)))
-		if value == nil {
-			return portainer.ErrEndpointNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var endpoint portainer.Endpoint
-	err = internal.UnmarshalEndpoint(data, &endpoint)
-	if err != nil {
-		return nil, err
-	}
-	return &endpoint, nil
-}
-
-// Endpoints return an array containing all the endpoints.
-func (service *EndpointService) Endpoints() ([]portainer.Endpoint, error) {
-	var endpoints = make([]portainer.Endpoint, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var endpoint portainer.Endpoint
-			err := internal.UnmarshalEndpoint(v, &endpoint)
-			if err != nil {
-				return err
-			}
-			endpoints = append(endpoints, endpoint)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return endpoints, nil
-}
-
-// Synchronize creates, updates and deletes endpoints inside a single transaction.
-func (service *EndpointService) Synchronize(toCreate, toUpdate, toDelete []*portainer.Endpoint) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointBucketName))
-
-		for _, endpoint := range toCreate {
-			err := storeNewEndpoint(endpoint, bucket)
-			if err != nil {
-				return err
-			}
-		}
-
-		for _, endpoint := range toUpdate {
-			err := marshalAndStoreEndpoint(endpoint, bucket)
-			if err != nil {
-				return err
-			}
-		}
-
-		for _, endpoint := range toDelete {
-			err := bucket.Delete(internal.Itob(int(endpoint.ID)))
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-}
-
-// CreateEndpoint assign an ID to a new endpoint and saves it.
-func (service *EndpointService) CreateEndpoint(endpoint *portainer.Endpoint) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointBucketName))
-		err := storeNewEndpoint(endpoint, bucket)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// UpdateEndpoint updates an endpoint.
-func (service *EndpointService) UpdateEndpoint(ID portainer.EndpointID, endpoint *portainer.Endpoint) error {
-	data, err := internal.MarshalEndpoint(endpoint)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointBucketName))
-		err = bucket.Put(internal.Itob(int(ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteEndpoint deletes an endpoint.
-func (service *EndpointService) DeleteEndpoint(ID portainer.EndpointID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(endpointBucketName))
-		err := bucket.Delete(internal.Itob(int(ID)))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-func marshalAndStoreEndpoint(endpoint *portainer.Endpoint, bucket *bolt.Bucket) error {
-	data, err := internal.MarshalEndpoint(endpoint)
-	if err != nil {
-		return err
-	}
-
-	err = bucket.Put(internal.Itob(int(endpoint.ID)), data)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func storeNewEndpoint(endpoint *portainer.Endpoint, bucket *bolt.Bucket) error {
-	id, _ := bucket.NextSequence()
-	endpoint.ID = portainer.EndpointID(id)
-	return marshalAndStoreEndpoint(endpoint, bucket)
-}

api/bolt/internal/internal.go

@@ -1,117 +0,0 @@
-package internal
-
-import (
-	"github.com/portainer/portainer"
-
-	"encoding/binary"
-	"encoding/json"
-)
-
-// MarshalUser encodes a user to binary format.
-func MarshalUser(user *portainer.User) ([]byte, error) {
-	return json.Marshal(user)
-}
-
-// UnmarshalUser decodes a user from a binary data.
-func UnmarshalUser(data []byte, user *portainer.User) error {
-	return json.Unmarshal(data, user)
-}
-
-// MarshalTeam encodes a team to binary format.
-func MarshalTeam(team *portainer.Team) ([]byte, error) {
-	return json.Marshal(team)
-}
-
-// UnmarshalTeam decodes a team from a binary data.
-func UnmarshalTeam(data []byte, team *portainer.Team) error {
-	return json.Unmarshal(data, team)
-}
-
-// MarshalTeamMembership encodes a team membership to binary format.
-func MarshalTeamMembership(membership *portainer.TeamMembership) ([]byte, error) {
-	return json.Marshal(membership)
-}
-
-// UnmarshalTeamMembership decodes a team membership from a binary data.
-func UnmarshalTeamMembership(data []byte, membership *portainer.TeamMembership) error {
-	return json.Unmarshal(data, membership)
-}
-
-// MarshalEndpoint encodes an endpoint to binary format.
-func MarshalEndpoint(endpoint *portainer.Endpoint) ([]byte, error) {
-	return json.Marshal(endpoint)
-}
-
-// UnmarshalEndpoint decodes an endpoint from a binary data.
-func UnmarshalEndpoint(data []byte, endpoint *portainer.Endpoint) error {
-	return json.Unmarshal(data, endpoint)
-}
-
-// MarshalEndpointGroup encodes an endpoint group to binary format.
-func MarshalEndpointGroup(group *portainer.EndpointGroup) ([]byte, error) {
-	return json.Marshal(group)
-}
-
-// UnmarshalEndpointGroup decodes an endpoint group from a binary data.
-func UnmarshalEndpointGroup(data []byte, group *portainer.EndpointGroup) error {
-	return json.Unmarshal(data, group)
-}
-
-// MarshalStack encodes a stack to binary format.
-func MarshalStack(stack *portainer.Stack) ([]byte, error) {
-	return json.Marshal(stack)
-}
-
-// UnmarshalStack decodes a stack from a binary data.
-func UnmarshalStack(data []byte, stack *portainer.Stack) error {
-	return json.Unmarshal(data, stack)
-}
-
-// MarshalRegistry encodes a registry to binary format.
-func MarshalRegistry(registry *portainer.Registry) ([]byte, error) {
-	return json.Marshal(registry)
-}
-
-// UnmarshalRegistry decodes a registry from a binary data.
-func UnmarshalRegistry(data []byte, registry *portainer.Registry) error {
-	return json.Unmarshal(data, registry)
-}
-
-// MarshalResourceControl encodes a resource control object to binary format.
-func MarshalResourceControl(rc *portainer.ResourceControl) ([]byte, error) {
-	return json.Marshal(rc)
-}
-
-// UnmarshalResourceControl decodes a resource control object from a binary data.
-func UnmarshalResourceControl(data []byte, rc *portainer.ResourceControl) error {
-	return json.Unmarshal(data, rc)
-}
-
-// MarshalSettings encodes a settings object to binary format.
-func MarshalSettings(settings *portainer.Settings) ([]byte, error) {
-	return json.Marshal(settings)
-}
-
-// UnmarshalSettings decodes a settings object from a binary data.
-func UnmarshalSettings(data []byte, settings *portainer.Settings) error {
-	return json.Unmarshal(data, settings)
-}
-
-// MarshalDockerHub encodes a Dockerhub object to binary format.
-func MarshalDockerHub(settings *portainer.DockerHub) ([]byte, error) {
-	return json.Marshal(settings)
-}
-
-// UnmarshalDockerHub decodes a Dockerhub object from a binary data.
-func UnmarshalDockerHub(data []byte, settings *portainer.DockerHub) error {
-	return json.Unmarshal(data, settings)
-}
-
-// Itob returns an 8-byte big endian representation of v.
-// This function is typically used for encoding integer IDs to byte slices
-// so that they can be used as BoltDB keys.
-func Itob(v int) []byte {
-	b := make([]byte, 8)
-	binary.BigEndian.PutUint64(b, uint64(v))
-	return b
-}

api/bolt/migrate_dbversion0.go

@@ -1,39 +0,0 @@
-package bolt
-
-import (
-	"github.com/boltdb/bolt"
-	"github.com/portainer/portainer"
-)
-
-func (m *Migrator) updateAdminUserToDBVersion1() error {
-	u, err := m.UserService.UserByUsername("admin")
-	if err == nil {
-		admin := &portainer.User{
-			Username: "admin",
-			Password: u.Password,
-			Role:     portainer.AdministratorRole,
-		}
-		err = m.UserService.CreateUser(admin)
-		if err != nil {
-			return err
-		}
-		err = m.removeLegacyAdminUser()
-		if err != nil {
-			return err
-		}
-	} else if err != nil && err != portainer.ErrUserNotFound {
-		return err
-	}
-	return nil
-}
-
-func (m *Migrator) removeLegacyAdminUser() error {
-	return m.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-		err := bucket.Delete([]byte("admin"))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/migrate_dbversion1.go

@@ -1,103 +0,0 @@
-package bolt
-
-import (
-	"github.com/boltdb/bolt"
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-)
-
-func (m *Migrator) updateResourceControlsToDBVersion2() error {
-	legacyResourceControls, err := m.retrieveLegacyResourceControls()
-	if err != nil {
-		return err
-	}
-
-	for _, resourceControl := range legacyResourceControls {
-		resourceControl.SubResourceIDs = []string{}
-		resourceControl.TeamAccesses = []portainer.TeamResourceAccess{}
-
-		owner, err := m.UserService.User(resourceControl.OwnerID)
-		if err != nil {
-			return err
-		}
-
-		if owner.Role == portainer.AdministratorRole {
-			resourceControl.AdministratorsOnly = true
-			resourceControl.UserAccesses = []portainer.UserResourceAccess{}
-		} else {
-			resourceControl.AdministratorsOnly = false
-			userAccess := portainer.UserResourceAccess{
-				UserID:      resourceControl.OwnerID,
-				AccessLevel: portainer.ReadWriteAccessLevel,
-			}
-			resourceControl.UserAccesses = []portainer.UserResourceAccess{userAccess}
-		}
-
-		err = m.ResourceControlService.CreateResourceControl(&resourceControl)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) updateEndpointsToDBVersion2() error {
-	legacyEndpoints, err := m.EndpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range legacyEndpoints {
-		endpoint.AuthorizedTeams = []portainer.TeamID{}
-		err = m.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Migrator) retrieveLegacyResourceControls() ([]portainer.ResourceControl, error) {
-	legacyResourceControls := make([]portainer.ResourceControl, 0)
-	err := m.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte("containerResourceControl"))
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var resourceControl portainer.ResourceControl
-			err := internal.UnmarshalResourceControl(v, &resourceControl)
-			if err != nil {
-				return err
-			}
-			resourceControl.Type = portainer.ContainerResourceControl
-			legacyResourceControls = append(legacyResourceControls, resourceControl)
-		}
-
-		bucket = tx.Bucket([]byte("serviceResourceControl"))
-		cursor = bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var resourceControl portainer.ResourceControl
-			err := internal.UnmarshalResourceControl(v, &resourceControl)
-			if err != nil {
-				return err
-			}
-			resourceControl.Type = portainer.ServiceResourceControl
-			legacyResourceControls = append(legacyResourceControls, resourceControl)
-		}
-
-		bucket = tx.Bucket([]byte("volumeResourceControl"))
-		cursor = bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var resourceControl portainer.ResourceControl
-			err := internal.UnmarshalResourceControl(v, &resourceControl)
-			if err != nil {
-				return err
-			}
-			resourceControl.Type = portainer.VolumeResourceControl
-			legacyResourceControls = append(legacyResourceControls, resourceControl)
-		}
-		return nil
-	})
-	return legacyResourceControls, err
-}

api/bolt/migrate_dbversion2.go

@@ -1,25 +0,0 @@
-package bolt
-
-import "github.com/portainer/portainer"
-
-func (m *Migrator) updateSettingsToDBVersion3() error {
-	legacySettings, err := m.SettingsService.Settings()
-	if err != nil {
-		return err
-	}
-
-	legacySettings.AuthenticationMethod = portainer.AuthenticationInternal
-	legacySettings.LDAPSettings = portainer.LDAPSettings{
-		TLSConfig: portainer.TLSConfiguration{},
-		SearchSettings: []portainer.LDAPSearchSettings{
-			portainer.LDAPSearchSettings{},
-		},
-	}
-
-	err = m.SettingsService.StoreSettings(legacySettings)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

api/bolt/migrate_dbversion3.go

@@ -1,27 +0,0 @@
-package bolt
-
-import "github.com/portainer/portainer"
-
-func (m *Migrator) updateEndpointsToDBVersion4() error {
-	legacyEndpoints, err := m.EndpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range legacyEndpoints {
-		endpoint.TLSConfig = portainer.TLSConfiguration{}
-		if endpoint.TLS {
-			endpoint.TLSConfig.TLS = true
-			endpoint.TLSConfig.TLSSkipVerify = false
-			endpoint.TLSConfig.TLSCACertPath = endpoint.TLSCACertPath
-			endpoint.TLSConfig.TLSCertPath = endpoint.TLSCertPath
-			endpoint.TLSConfig.TLSKeyPath = endpoint.TLSKeyPath
-		}
-		err = m.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/bolt/migrate_dbversion4.go

@@ -1,16 +0,0 @@
-package bolt
-
-func (m *Migrator) updateSettingsToVersion5() error {
-	legacySettings, err := m.SettingsService.Settings()
-	if err != nil {
-		return err
-	}
-	legacySettings.AllowBindMountsForRegularUsers = true
-
-	err = m.SettingsService.StoreSettings(legacySettings)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

api/bolt/migrate_dbversion5.go

@@ -1,16 +0,0 @@
-package bolt
-
-func (m *Migrator) updateSettingsToVersion6() error {
-	legacySettings, err := m.SettingsService.Settings()
-	if err != nil {
-		return err
-	}
-	legacySettings.AllowPrivilegedModeForRegularUsers = true
-
-	err = m.SettingsService.StoreSettings(legacySettings)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

api/bolt/migrate_dbversion6.go

@@ -1,16 +0,0 @@
-package bolt
-
-func (m *Migrator) updateSettingsToVersion7() error {
-	legacySettings, err := m.SettingsService.Settings()
-	if err != nil {
-		return err
-	}
-	legacySettings.DisplayDonationHeader = true
-
-	err = m.SettingsService.StoreSettings(legacySettings)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

api/bolt/migrate_dbversion7.go

@@ -1,20 +0,0 @@
-package bolt
-
-import "github.com/portainer/portainer"
-
-func (m *Migrator) updateEndpointsToVersion8() error {
-	legacyEndpoints, err := m.EndpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range legacyEndpoints {
-		endpoint.Extensions = []portainer.EndpointExtension{}
-		err = m.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/bolt/migrate_dbversion8.go

@@ -1,20 +0,0 @@
-package bolt
-
-import "github.com/portainer/portainer"
-
-func (m *Migrator) updateEndpointsToVersion9() error {
-	legacyEndpoints, err := m.EndpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range legacyEndpoints {
-		endpoint.GroupID = portainer.EndpointGroupID(1)
-		err = m.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/bolt/migrate_dbversion9.go

@@ -1,20 +0,0 @@
-package bolt
-
-import "github.com/portainer/portainer"
-
-func (m *Migrator) updateEndpointsToVersion10() error {
-	legacyEndpoints, err := m.EndpointService.Endpoints()
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range legacyEndpoints {
-		endpoint.Type = portainer.DockerEnvironment
-		err = m.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/bolt/migrator.go

@@ -1,120 +0,0 @@
-package bolt
-
-import "github.com/portainer/portainer"
-
-// Migrator defines a service to migrate data after a Portainer version update.
-type Migrator struct {
-	UserService            *UserService
-	EndpointService        *EndpointService
-	ResourceControlService *ResourceControlService
-	SettingsService        *SettingsService
-	VersionService         *VersionService
-	CurrentDBVersion       int
-	store                  *Store
-}
-
-// NewMigrator creates a new Migrator.
-func NewMigrator(store *Store, version int) *Migrator {
-	return &Migrator{
-		UserService:            store.UserService,
-		EndpointService:        store.EndpointService,
-		ResourceControlService: store.ResourceControlService,
-		SettingsService:        store.SettingsService,
-		VersionService:         store.VersionService,
-		CurrentDBVersion:       version,
-		store:                  store,
-	}
-}
-
-// Migrate checks the database version and migrate the existing data to the most recent data model.
-func (m *Migrator) Migrate() error {
-
-	// Portainer < 1.12
-	if m.CurrentDBVersion < 1 {
-		err := m.updateAdminUserToDBVersion1()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Portainer 1.12.x
-	if m.CurrentDBVersion < 2 {
-		err := m.updateResourceControlsToDBVersion2()
-		if err != nil {
-			return err
-		}
-		err = m.updateEndpointsToDBVersion2()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Portainer 1.13.x
-	if m.CurrentDBVersion < 3 {
-		err := m.updateSettingsToDBVersion3()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Portainer 1.14.0
-	if m.CurrentDBVersion < 4 {
-		err := m.updateEndpointsToDBVersion4()
-		if err != nil {
-			return err
-		}
-	}
-
-	// https://github.com/portainer/portainer/issues/1235
-	if m.CurrentDBVersion < 5 {
-		err := m.updateSettingsToVersion5()
-		if err != nil {
-			return err
-		}
-	}
-
-	// https://github.com/portainer/portainer/issues/1236
-	if m.CurrentDBVersion < 6 {
-		err := m.updateSettingsToVersion6()
-		if err != nil {
-			return err
-		}
-	}
-
-	// https://github.com/portainer/portainer/issues/1449
-	if m.CurrentDBVersion < 7 {
-		err := m.updateSettingsToVersion7()
-		if err != nil {
-			return err
-		}
-	}
-
-	if m.CurrentDBVersion < 8 {
-		err := m.updateEndpointsToVersion8()
-		if err != nil {
-			return err
-		}
-	}
-
-	// https: //github.com/portainer/portainer/issues/1396
-	if m.CurrentDBVersion < 9 {
-		err := m.updateEndpointsToVersion9()
-		if err != nil {
-			return err
-		}
-	}
-
-	// https://github.com/portainer/portainer/issues/461
-	if m.CurrentDBVersion < 10 {
-		err := m.updateEndpointsToVersion10()
-		if err != nil {
-			return err
-		}
-	}
-
-	err := m.VersionService.StoreDBVersion(portainer.DBVersion)
-	if err != nil {
-		return err
-	}
-	return nil
-}

api/bolt/registry_service.go

@@ -1,114 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// RegistryService represents a service for managing registries.
-type RegistryService struct {
-	store *Store
-}
-
-// Registry returns an registry by ID.
-func (service *RegistryService) Registry(ID portainer.RegistryID) (*portainer.Registry, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(registryBucketName))
-		value := bucket.Get(internal.Itob(int(ID)))
-		if value == nil {
-			return portainer.ErrRegistryNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var registry portainer.Registry
-	err = internal.UnmarshalRegistry(data, &registry)
-	if err != nil {
-		return nil, err
-	}
-	return &registry, nil
-}
-
-// Registries returns an array containing all the registries.
-func (service *RegistryService) Registries() ([]portainer.Registry, error) {
-	var registries = make([]portainer.Registry, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(registryBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var registry portainer.Registry
-			err := internal.UnmarshalRegistry(v, &registry)
-			if err != nil {
-				return err
-			}
-			registries = append(registries, registry)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return registries, nil
-}
-
-// CreateRegistry creates a new registry.
-func (service *RegistryService) CreateRegistry(registry *portainer.Registry) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(registryBucketName))
-
-		id, _ := bucket.NextSequence()
-		registry.ID = portainer.RegistryID(id)
-
-		data, err := internal.MarshalRegistry(registry)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put(internal.Itob(int(registry.ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// UpdateRegistry updates an registry.
-func (service *RegistryService) UpdateRegistry(ID portainer.RegistryID, registry *portainer.Registry) error {
-	data, err := internal.MarshalRegistry(registry)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(registryBucketName))
-		err = bucket.Put(internal.Itob(int(ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteRegistry deletes an registry.
-func (service *RegistryService) DeleteRegistry(ID portainer.RegistryID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(registryBucketName))
-		err := bucket.Delete(internal.Itob(int(ID)))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/resource_control_service.go

@@ -1,148 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// ResourceControlService represents a service for managing resource controls.
-type ResourceControlService struct {
-	store *Store
-}
-
-// ResourceControl returns a ResourceControl object by ID
-func (service *ResourceControlService) ResourceControl(ID portainer.ResourceControlID) (*portainer.ResourceControl, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(resourceControlBucketName))
-		value := bucket.Get(internal.Itob(int(ID)))
-		if value == nil {
-			return portainer.ErrResourceControlNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var resourceControl portainer.ResourceControl
-	err = internal.UnmarshalResourceControl(data, &resourceControl)
-	if err != nil {
-		return nil, err
-	}
-	return &resourceControl, nil
-}
-
-// ResourceControlByResourceID returns a ResourceControl object by checking if the resourceID is equal
-// to the main ResourceID or in SubResourceIDs
-func (service *ResourceControlService) ResourceControlByResourceID(resourceID string) (*portainer.ResourceControl, error) {
-	var resourceControl *portainer.ResourceControl
-
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(resourceControlBucketName))
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var rc portainer.ResourceControl
-			err := internal.UnmarshalResourceControl(v, &rc)
-			if err != nil {
-				return err
-			}
-			if rc.ResourceID == resourceID {
-				resourceControl = &rc
-			}
-			for _, subResourceID := range rc.SubResourceIDs {
-				if subResourceID == resourceID {
-					resourceControl = &rc
-				}
-			}
-		}
-
-		if resourceControl == nil {
-			return portainer.ErrResourceControlNotFound
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return resourceControl, nil
-}
-
-// ResourceControls returns all the ResourceControl objects
-func (service *ResourceControlService) ResourceControls() ([]portainer.ResourceControl, error) {
-	var rcs = make([]portainer.ResourceControl, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(resourceControlBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var resourceControl portainer.ResourceControl
-			err := internal.UnmarshalResourceControl(v, &resourceControl)
-			if err != nil {
-				return err
-			}
-			rcs = append(rcs, resourceControl)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return rcs, nil
-}
-
-// CreateResourceControl creates a new ResourceControl object
-func (service *ResourceControlService) CreateResourceControl(resourceControl *portainer.ResourceControl) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(resourceControlBucketName))
-		id, _ := bucket.NextSequence()
-		resourceControl.ID = portainer.ResourceControlID(id)
-		data, err := internal.MarshalResourceControl(resourceControl)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put(internal.Itob(int(resourceControl.ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// UpdateResourceControl saves a ResourceControl object.
-func (service *ResourceControlService) UpdateResourceControl(ID portainer.ResourceControlID, resourceControl *portainer.ResourceControl) error {
-	data, err := internal.MarshalResourceControl(resourceControl)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(resourceControlBucketName))
-		err = bucket.Put(internal.Itob(int(ID)), data)
-
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteResourceControl deletes a ResourceControl object by ID
-func (service *ResourceControlService) DeleteResourceControl(ID portainer.ResourceControlID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(resourceControlBucketName))
-		err := bucket.Delete(internal.Itob(int(ID)))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/settings_service.go

@@ -1,61 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// SettingsService represents a service to manage application settings.
-type SettingsService struct {
-	store *Store
-}
-
-const (
-	dbSettingsKey = "SETTINGS"
-)
-
-// Settings retrieve the settings object.
-func (service *SettingsService) Settings() (*portainer.Settings, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(settingsBucketName))
-		value := bucket.Get([]byte(dbSettingsKey))
-		if value == nil {
-			return portainer.ErrSettingsNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var settings portainer.Settings
-	err = internal.UnmarshalSettings(data, &settings)
-	if err != nil {
-		return nil, err
-	}
-	return &settings, nil
-}
-
-// StoreSettings persists a Settings object.
-func (service *SettingsService) StoreSettings(settings *portainer.Settings) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(settingsBucketName))
-
-		data, err := internal.MarshalSettings(settings)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put([]byte(dbSettingsKey), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/stack_service.go

@@ -1,138 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// StackService represents a service for managing stacks.
-type StackService struct {
-	store *Store
-}
-
-// Stack returns a stack object by ID.
-func (service *StackService) Stack(ID portainer.StackID) (*portainer.Stack, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(stackBucketName))
-		value := bucket.Get([]byte(ID))
-		if value == nil {
-			return portainer.ErrStackNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var stack portainer.Stack
-	err = internal.UnmarshalStack(data, &stack)
-	if err != nil {
-		return nil, err
-	}
-	return &stack, nil
-}
-
-// Stacks returns an array containing all the stacks.
-func (service *StackService) Stacks() ([]portainer.Stack, error) {
-	var stacks = make([]portainer.Stack, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(stackBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var stack portainer.Stack
-			err := internal.UnmarshalStack(v, &stack)
-			if err != nil {
-				return err
-			}
-			stacks = append(stacks, stack)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return stacks, nil
-}
-
-// StacksBySwarmID return an array containing all the stacks related to the specified Swarm ID.
-func (service *StackService) StacksBySwarmID(id string) ([]portainer.Stack, error) {
-	var stacks = make([]portainer.Stack, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(stackBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var stack portainer.Stack
-			err := internal.UnmarshalStack(v, &stack)
-			if err != nil {
-				return err
-			}
-			if stack.SwarmID == id {
-				stacks = append(stacks, stack)
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return stacks, nil
-}
-
-// CreateStack creates a new stack.
-func (service *StackService) CreateStack(stack *portainer.Stack) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(stackBucketName))
-
-		data, err := internal.MarshalStack(stack)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put([]byte(stack.ID), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// UpdateStack updates an stack.
-func (service *StackService) UpdateStack(ID portainer.StackID, stack *portainer.Stack) error {
-	data, err := internal.MarshalStack(stack)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(stackBucketName))
-		err = bucket.Put([]byte(ID), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteStack deletes an stack.
-func (service *StackService) DeleteStack(ID portainer.StackID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(stackBucketName))
-		err := bucket.Delete([]byte(ID))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/team_membership_service.go

@@ -1,217 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// TeamMembershipService represents a service for managing TeamMembership objects.
-type TeamMembershipService struct {
-	store *Store
-}
-
-// TeamMembership returns a TeamMembership object by ID
-func (service *TeamMembershipService) TeamMembership(ID portainer.TeamMembershipID) (*portainer.TeamMembership, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-		value := bucket.Get(internal.Itob(int(ID)))
-		if value == nil {
-			return portainer.ErrTeamMembershipNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var membership portainer.TeamMembership
-	err = internal.UnmarshalTeamMembership(data, &membership)
-	if err != nil {
-		return nil, err
-	}
-	return &membership, nil
-}
-
-// TeamMemberships return an array containing all the TeamMembership objects.
-func (service *TeamMembershipService) TeamMemberships() ([]portainer.TeamMembership, error) {
-	var memberships = make([]portainer.TeamMembership, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var membership portainer.TeamMembership
-			err := internal.UnmarshalTeamMembership(v, &membership)
-			if err != nil {
-				return err
-			}
-			memberships = append(memberships, membership)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return memberships, nil
-}
-
-// TeamMembershipsByUserID return an array containing all the TeamMembership objects where the specified userID is present.
-func (service *TeamMembershipService) TeamMembershipsByUserID(userID portainer.UserID) ([]portainer.TeamMembership, error) {
-	var memberships = make([]portainer.TeamMembership, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var membership portainer.TeamMembership
-			err := internal.UnmarshalTeamMembership(v, &membership)
-			if err != nil {
-				return err
-			}
-			if membership.UserID == userID {
-				memberships = append(memberships, membership)
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return memberships, nil
-}
-
-// TeamMembershipsByTeamID return an array containing all the TeamMembership objects where the specified teamID is present.
-func (service *TeamMembershipService) TeamMembershipsByTeamID(teamID portainer.TeamID) ([]portainer.TeamMembership, error) {
-	var memberships = make([]portainer.TeamMembership, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var membership portainer.TeamMembership
-			err := internal.UnmarshalTeamMembership(v, &membership)
-			if err != nil {
-				return err
-			}
-			if membership.TeamID == teamID {
-				memberships = append(memberships, membership)
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return memberships, nil
-}
-
-// UpdateTeamMembership saves a TeamMembership object.
-func (service *TeamMembershipService) UpdateTeamMembership(ID portainer.TeamMembershipID, membership *portainer.TeamMembership) error {
-	data, err := internal.MarshalTeamMembership(membership)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-		err = bucket.Put(internal.Itob(int(ID)), data)
-
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// CreateTeamMembership creates a new TeamMembership object.
-func (service *TeamMembershipService) CreateTeamMembership(membership *portainer.TeamMembership) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-
-		id, _ := bucket.NextSequence()
-		membership.ID = portainer.TeamMembershipID(id)
-
-		data, err := internal.MarshalTeamMembership(membership)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put(internal.Itob(int(membership.ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteTeamMembership deletes a TeamMembership object.
-func (service *TeamMembershipService) DeleteTeamMembership(ID portainer.TeamMembershipID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-		err := bucket.Delete(internal.Itob(int(ID)))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteTeamMembershipByUserID deletes all the TeamMembership object associated to a UserID.
-func (service *TeamMembershipService) DeleteTeamMembershipByUserID(userID portainer.UserID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var membership portainer.TeamMembership
-			err := internal.UnmarshalTeamMembership(v, &membership)
-			if err != nil {
-				return err
-			}
-			if membership.UserID == userID {
-				err := bucket.Delete(internal.Itob(int(membership.ID)))
-				if err != nil {
-					return err
-				}
-			}
-		}
-
-		return nil
-	})
-}
-
-// DeleteTeamMembershipByTeamID deletes all the TeamMembership object associated to a TeamID.
-func (service *TeamMembershipService) DeleteTeamMembershipByTeamID(teamID portainer.TeamID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamMembershipBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var membership portainer.TeamMembership
-			err := internal.UnmarshalTeamMembership(v, &membership)
-			if err != nil {
-				return err
-			}
-			if membership.TeamID == teamID {
-				err := bucket.Delete(internal.Itob(int(membership.ID)))
-				if err != nil {
-					return err
-				}
-			}
-		}
-
-		return nil
-	})
-}

api/bolt/team_service.go

@@ -1,144 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// TeamService represents a service for managing teams.
-type TeamService struct {
-	store *Store
-}
-
-// Team returns a Team by ID
-func (service *TeamService) Team(ID portainer.TeamID) (*portainer.Team, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamBucketName))
-		value := bucket.Get(internal.Itob(int(ID)))
-		if value == nil {
-			return portainer.ErrTeamNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var team portainer.Team
-	err = internal.UnmarshalTeam(data, &team)
-	if err != nil {
-		return nil, err
-	}
-	return &team, nil
-}
-
-// TeamByName returns a team by name.
-func (service *TeamService) TeamByName(name string) (*portainer.Team, error) {
-	var team *portainer.Team
-
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamBucketName))
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var t portainer.Team
-			err := internal.UnmarshalTeam(v, &t)
-			if err != nil {
-				return err
-			}
-			if t.Name == name {
-				team = &t
-			}
-		}
-
-		if team == nil {
-			return portainer.ErrTeamNotFound
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return team, nil
-}
-
-// Teams return an array containing all the teams.
-func (service *TeamService) Teams() ([]portainer.Team, error) {
-	var teams = make([]portainer.Team, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var team portainer.Team
-			err := internal.UnmarshalTeam(v, &team)
-			if err != nil {
-				return err
-			}
-			teams = append(teams, team)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return teams, nil
-}
-
-// UpdateTeam saves a Team.
-func (service *TeamService) UpdateTeam(ID portainer.TeamID, team *portainer.Team) error {
-	data, err := internal.MarshalTeam(team)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamBucketName))
-		err = bucket.Put(internal.Itob(int(ID)), data)
-
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// CreateTeam creates a new Team.
-func (service *TeamService) CreateTeam(team *portainer.Team) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamBucketName))
-
-		id, _ := bucket.NextSequence()
-		team.ID = portainer.TeamID(id)
-
-		data, err := internal.MarshalTeam(team)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put(internal.Itob(int(team.ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteTeam deletes a Team.
-func (service *TeamService) DeleteTeam(ID portainer.TeamID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(teamBucketName))
-		err := bucket.Delete(internal.Itob(int(ID)))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/user_service.go

@@ -1,170 +0,0 @@
-package bolt
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt/internal"
-
-	"github.com/boltdb/bolt"
-)
-
-// UserService represents a service for managing users.
-type UserService struct {
-	store *Store
-}
-
-// User returns a user by ID
-func (service *UserService) User(ID portainer.UserID) (*portainer.User, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-		value := bucket.Get(internal.Itob(int(ID)))
-		if value == nil {
-			return portainer.ErrUserNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var user portainer.User
-	err = internal.UnmarshalUser(data, &user)
-	if err != nil {
-		return nil, err
-	}
-	return &user, nil
-}
-
-// UserByUsername returns a user by username.
-func (service *UserService) UserByUsername(username string) (*portainer.User, error) {
-	var user *portainer.User
-
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var u portainer.User
-			err := internal.UnmarshalUser(v, &u)
-			if err != nil {
-				return err
-			}
-			if u.Username == username {
-				user = &u
-			}
-		}
-
-		if user == nil {
-			return portainer.ErrUserNotFound
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return user, nil
-}
-
-// Users return an array containing all the users.
-func (service *UserService) Users() ([]portainer.User, error) {
-	var users = make([]portainer.User, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var user portainer.User
-			err := internal.UnmarshalUser(v, &user)
-			if err != nil {
-				return err
-			}
-			users = append(users, user)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return users, nil
-}
-
-// UsersByRole return an array containing all the users with the specified role.
-func (service *UserService) UsersByRole(role portainer.UserRole) ([]portainer.User, error) {
-	var users = make([]portainer.User, 0)
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-
-		cursor := bucket.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var user portainer.User
-			err := internal.UnmarshalUser(v, &user)
-			if err != nil {
-				return err
-			}
-			if user.Role == role {
-				users = append(users, user)
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return users, nil
-}
-
-// UpdateUser saves a user.
-func (service *UserService) UpdateUser(ID portainer.UserID, user *portainer.User) error {
-	data, err := internal.MarshalUser(user)
-	if err != nil {
-		return err
-	}
-
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-		err = bucket.Put(internal.Itob(int(ID)), data)
-
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// CreateUser creates a new user.
-func (service *UserService) CreateUser(user *portainer.User) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-
-		id, _ := bucket.NextSequence()
-		user.ID = portainer.UserID(id)
-
-		data, err := internal.MarshalUser(user)
-		if err != nil {
-			return err
-		}
-
-		err = bucket.Put(internal.Itob(int(user.ID)), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// DeleteUser deletes a user.
-func (service *UserService) DeleteUser(ID portainer.UserID) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(userBucketName))
-		err := bucket.Delete(internal.Itob(int(ID)))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/bolt/version_service.go

@@ -1,58 +0,0 @@
-package bolt
-
-import (
-	"strconv"
-
-	"github.com/portainer/portainer"
-
-	"github.com/boltdb/bolt"
-)
-
-// VersionService represents a service to manage stored versions.
-type VersionService struct {
-	store *Store
-}
-
-const (
-	dBVersionKey = "DB_VERSION"
-)
-
-// DBVersion retrieves the stored database version.
-func (service *VersionService) DBVersion() (int, error) {
-	var data []byte
-	err := service.store.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(versionBucketName))
-		value := bucket.Get([]byte(dBVersionKey))
-		if value == nil {
-			return portainer.ErrDBVersionNotFound
-		}
-
-		data = make([]byte, len(value))
-		copy(data, value)
-		return nil
-	})
-	if err != nil {
-		return 0, err
-	}
-
-	dbVersion, err := strconv.Atoi(string(data))
-	if err != nil {
-		return 0, err
-	}
-
-	return dbVersion, nil
-}
-
-// StoreDBVersion store the database version.
-func (service *VersionService) StoreDBVersion(version int) error {
-	return service.store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket([]byte(versionBucketName))
-
-		data := []byte(strconv.Itoa(version))
-		err := bucket.Put([]byte(dBVersionKey), data)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}

api/cli/cli.go

@@ -1,141 +0,0 @@
-package cli
-
-import (
-	"time"
-
-	"github.com/portainer/portainer"
-
-	"os"
-	"path/filepath"
-	"strings"
-
-	"gopkg.in/alecthomas/kingpin.v2"
-)
-
-// Service implements the CLIService interface
-type Service struct{}
-
-const (
-	errInvalidEndpointProtocol       = portainer.Error("Invalid endpoint protocol: Portainer only supports unix:// or tcp://")
-	errSocketNotFound                = portainer.Error("Unable to locate Unix socket")
-	errEndpointsFileNotFound         = portainer.Error("Unable to locate external endpoints file")
-	errInvalidSyncInterval           = portainer.Error("Invalid synchronization interval")
-	errEndpointExcludeExternal       = portainer.Error("Cannot use the -H flag mutually with --external-endpoints")
-	errNoAuthExcludeAdminPassword    = portainer.Error("Cannot use --no-auth with --admin-password or --admin-password-file")
-	errAdminPassExcludeAdminPassFile = portainer.Error("Cannot use --admin-password with --admin-password-file")
-)
-
-// ParseFlags parse the CLI flags and return a portainer.Flags struct
-func (*Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
-	kingpin.Version(version)
-
-	flags := &portainer.CLIFlags{
-		Addr:              kingpin.Flag("bind", "Address and port to serve Portainer").Default(defaultBindAddress).Short('p').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(),
-		Endpoint:          kingpin.Flag("host", "Dockerd endpoint").Short('H').String(),
-		ExternalEndpoints: kingpin.Flag("external-endpoints", "Path to a file defining available endpoints").String(),
-		NoAuth:            kingpin.Flag("no-auth", "Disable authentication").Default(defaultNoAuth).Bool(),
-		NoAnalytics:       kingpin.Flag("no-analytics", "Disable Analytics in app").Default(defaultNoAnalytics).Bool(),
-		TLSVerify:         kingpin.Flag("tlsverify", "TLS support").Default(defaultTLSVerify).Bool(),
-		TLSSkipVerify:     kingpin.Flag("tlsskipverify", "Disable TLS server verification").Default(defaultTLSSkipVerify).Bool(),
-		TLSCacert:         kingpin.Flag("tlscacert", "Path to the CA").Default(defaultTLSCACertPath).String(),
-		TLSCert:           kingpin.Flag("tlscert", "Path to the TLS certificate file").Default(defaultTLSCertPath).String(),
-		TLSKey:            kingpin.Flag("tlskey", "Path to the TLS key").Default(defaultTLSKeyPath).String(),
-		SSL:               kingpin.Flag("ssl", "Secure Portainer instance using SSL").Default(defaultSSL).Bool(),
-		SSLCert:           kingpin.Flag("sslcert", "Path to the SSL certificate used to secure the Portainer instance").Default(defaultSSLCertPath).String(),
-		SSLKey:            kingpin.Flag("sslkey", "Path to the SSL key used to secure the Portainer instance").Default(defaultSSLKeyPath).String(),
-		SyncInterval:      kingpin.Flag("sync-interval", "Duration between each synchronization via the external endpoints source").Default(defaultSyncInterval).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(),
-		Templates:         kingpin.Flag("templates", "URL to the templates (apps) definitions").Short('t').String(),
-	}
-
-	kingpin.Parse()
-
-	if !filepath.IsAbs(*flags.Assets) {
-		ex, err := os.Executable()
-		if err != nil {
-			panic(err)
-		}
-		*flags.Assets = filepath.Join(filepath.Dir(ex), *flags.Assets)
-	}
-
-	return flags, nil
-}
-
-// ValidateFlags validates the values of the flags.
-func (*Service) ValidateFlags(flags *portainer.CLIFlags) error {
-
-	if *flags.Endpoint != "" && *flags.ExternalEndpoints != "" {
-		return errEndpointExcludeExternal
-	}
-
-	err := validateEndpoint(*flags.Endpoint)
-	if err != nil {
-		return err
-	}
-
-	err = validateExternalEndpoints(*flags.ExternalEndpoints)
-	if err != nil {
-		return err
-	}
-
-	err = validateSyncInterval(*flags.SyncInterval)
-	if err != nil {
-		return err
-	}
-
-	if *flags.NoAuth && (*flags.AdminPassword != "" || *flags.AdminPasswordFile != "") {
-		return errNoAuthExcludeAdminPassword
-	}
-
-	if *flags.AdminPassword != "" && *flags.AdminPasswordFile != "" {
-		return errAdminPassExcludeAdminPassFile
-	}
-
-	return nil
-}
-
-func validateEndpoint(endpoint string) error {
-	if endpoint != "" {
-		if !strings.HasPrefix(endpoint, "unix://") && !strings.HasPrefix(endpoint, "tcp://") {
-			return errInvalidEndpointProtocol
-		}
-
-		if strings.HasPrefix(endpoint, "unix://") {
-			socketPath := strings.TrimPrefix(endpoint, "unix://")
-			if _, err := os.Stat(socketPath); err != nil {
-				if os.IsNotExist(err) {
-					return errSocketNotFound
-				}
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func validateExternalEndpoints(externalEndpoints string) error {
-	if externalEndpoints != "" {
-		if _, err := os.Stat(externalEndpoints); err != nil {
-			if os.IsNotExist(err) {
-				return errEndpointsFileNotFound
-			}
-			return err
-		}
-	}
-	return nil
-}
-
-func validateSyncInterval(syncInterval string) error {
-	if syncInterval != defaultSyncInterval {
-		_, err := time.ParseDuration(syncInterval)
-		if err != nil {
-			return errInvalidSyncInterval
-		}
-	}
-	return nil
-}

api/cli/defaults.go

@@ -1,20 +0,0 @@
-// +build !windows
-
-package cli
-
-const (
-	defaultBindAddress     = ":9000"
-	defaultDataDirectory   = "/data"
-	defaultAssetsDirectory = "./"
-	defaultNoAuth          = "false"
-	defaultNoAnalytics     = "false"
-	defaultTLSVerify       = "false"
-	defaultTLSSkipVerify   = "false"
-	defaultTLSCACertPath   = "/certs/ca.pem"
-	defaultTLSCertPath     = "/certs/cert.pem"
-	defaultTLSKeyPath      = "/certs/key.pem"
-	defaultSSL             = "false"
-	defaultSSLCertPath     = "/certs/portainer.crt"
-	defaultSSLKeyPath      = "/certs/portainer.key"
-	defaultSyncInterval    = "60s"
-)

api/cli/defaults_windows.go

@@ -1,18 +0,0 @@
-package cli
-
-const (
-	defaultBindAddress     = ":9000"
-	defaultDataDirectory   = "C:\\data"
-	defaultAssetsDirectory = "./"
-	defaultNoAuth          = "false"
-	defaultNoAnalytics     = "false"
-	defaultTLSVerify       = "false"
-	defaultTLSSkipVerify   = "false"
-	defaultTLSCACertPath   = "C:\\certs\\ca.pem"
-	defaultTLSCertPath     = "C:\\certs\\cert.pem"
-	defaultTLSKeyPath      = "C:\\certs\\key.pem"
-	defaultSSL             = "false"
-	defaultSSLCertPath     = "C:\\certs\\portainer.crt"
-	defaultSSLKeyPath      = "C:\\certs\\portainer.key"
-	defaultSyncInterval    = "60s"
-)

api/cmd/portainer/main.go

@@ -1,361 +0,0 @@
-package main // import "github.com/portainer/portainer"
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/bolt"
-	"github.com/portainer/portainer/cli"
-	"github.com/portainer/portainer/cron"
-	"github.com/portainer/portainer/crypto"
-	"github.com/portainer/portainer/exec"
-	"github.com/portainer/portainer/filesystem"
-	"github.com/portainer/portainer/git"
-	"github.com/portainer/portainer/http"
-	"github.com/portainer/portainer/http/client"
-	"github.com/portainer/portainer/jwt"
-	"github.com/portainer/portainer/ldap"
-
-	"log"
-)
-
-func initCLI() *portainer.CLIFlags {
-	var cli portainer.CLIService = &cli.Service{}
-	flags, err := cli.ParseFlags(portainer.APIVersion)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = cli.ValidateFlags(flags)
-	if err != nil {
-		log.Fatal(err)
-	}
-	return flags
-}
-
-func initFileService(dataStorePath string) portainer.FileService {
-	fileService, err := filesystem.NewService(dataStorePath, "")
-	if err != nil {
-		log.Fatal(err)
-	}
-	return fileService
-}
-
-func initStore(dataStorePath string) *bolt.Store {
-	store, err := bolt.NewStore(dataStorePath)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = store.Open()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = store.Init()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = store.MigrateData()
-	if err != nil {
-		log.Fatal(err)
-	}
-	return store
-}
-
-func initStackManager(assetsPath string, signatureService portainer.DigitalSignatureService, fileService portainer.FileService) (portainer.StackManager, error) {
-	return exec.NewStackManager(assetsPath, signatureService, fileService)
-}
-
-func initJWTService(authenticationEnabled bool) portainer.JWTService {
-	if authenticationEnabled {
-		jwtService, err := jwt.NewService()
-		if err != nil {
-			log.Fatal(err)
-		}
-		return jwtService
-	}
-	return nil
-}
-
-func initDigitalSignatureService() portainer.DigitalSignatureService {
-	return &crypto.ECDSAService{}
-}
-
-func initCryptoService() portainer.CryptoService {
-	return &crypto.Service{}
-}
-
-func initLDAPService() portainer.LDAPService {
-	return &ldap.Service{}
-}
-
-func initGitService() portainer.GitService {
-	return &git.Service{}
-}
-
-func initEndpointWatcher(endpointService portainer.EndpointService, externalEnpointFile string, syncInterval string) bool {
-	authorizeEndpointMgmt := true
-	if externalEnpointFile != "" {
-		authorizeEndpointMgmt = false
-		log.Println("Using external endpoint definition. Endpoint management via the API will be disabled.")
-		endpointWatcher := cron.NewWatcher(endpointService, syncInterval)
-		err := endpointWatcher.WatchEndpointFile(externalEnpointFile)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-	return authorizeEndpointMgmt
-}
-
-func initStatus(authorizeEndpointMgmt bool, flags *portainer.CLIFlags) *portainer.Status {
-	return &portainer.Status{
-		Analytics:          !*flags.NoAnalytics,
-		Authentication:     !*flags.NoAuth,
-		EndpointManagement: authorizeEndpointMgmt,
-		Version:            portainer.APIVersion,
-	}
-}
-
-func initDockerHub(dockerHubService portainer.DockerHubService) error {
-	_, err := dockerHubService.DockerHub()
-	if err == portainer.ErrDockerHubNotFound {
-		dockerhub := &portainer.DockerHub{
-			Authentication: false,
-			Username:       "",
-			Password:       "",
-		}
-		return dockerHubService.StoreDockerHub(dockerhub)
-	} else if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func initSettings(settingsService portainer.SettingsService, flags *portainer.CLIFlags) error {
-	_, err := settingsService.Settings()
-	if err == portainer.ErrSettingsNotFound {
-		settings := &portainer.Settings{
-			LogoURL:                     *flags.Logo,
-			DisplayDonationHeader:       true,
-			DisplayExternalContributors: false,
-			AuthenticationMethod:        portainer.AuthenticationInternal,
-			LDAPSettings: portainer.LDAPSettings{
-				TLSConfig: portainer.TLSConfiguration{},
-				SearchSettings: []portainer.LDAPSearchSettings{
-					portainer.LDAPSearchSettings{},
-				},
-			},
-			AllowBindMountsForRegularUsers:     true,
-			AllowPrivilegedModeForRegularUsers: true,
-		}
-
-		if *flags.Templates != "" {
-			settings.TemplatesURL = *flags.Templates
-		} else {
-			settings.TemplatesURL = portainer.DefaultTemplatesURL
-		}
-
-		if *flags.Labels != nil {
-			settings.BlackListedLabels = *flags.Labels
-		} else {
-			settings.BlackListedLabels = make([]portainer.Pair, 0)
-		}
-
-		return settingsService.StoreSettings(settings)
-	} else if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func retrieveFirstEndpointFromDatabase(endpointService portainer.EndpointService) *portainer.Endpoint {
-	endpoints, err := endpointService.Endpoints()
-	if err != nil {
-		log.Fatal(err)
-	}
-	return &endpoints[0]
-}
-
-func loadAndParseKeyPair(fileService portainer.FileService, signatureService portainer.DigitalSignatureService) error {
-	private, public, err := fileService.LoadKeyPair()
-	if err != nil {
-		return err
-	}
-	return signatureService.ParseKeyPair(private, public)
-}
-
-func generateAndStoreKeyPair(fileService portainer.FileService, signatureService portainer.DigitalSignatureService) error {
-	private, public, err := signatureService.GenerateKeyPair()
-	if err != nil {
-		return err
-	}
-	privateHeader, publicHeader := signatureService.PEMHeaders()
-	return fileService.StoreKeyPair(private, public, privateHeader, publicHeader)
-}
-
-func initKeyPair(fileService portainer.FileService, signatureService portainer.DigitalSignatureService) error {
-	existingKeyPair, err := fileService.KeyPairFilesExist()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if existingKeyPair {
-		return loadAndParseKeyPair(fileService, signatureService)
-	}
-	return generateAndStoreKeyPair(fileService, signatureService)
-}
-
-func main() {
-	flags := initCLI()
-
-	fileService := initFileService(*flags.Data)
-
-	store := initStore(*flags.Data)
-	defer store.Close()
-
-	jwtService := initJWTService(!*flags.NoAuth)
-
-	cryptoService := initCryptoService()
-
-	digitalSignatureService := initDigitalSignatureService()
-
-	ldapService := initLDAPService()
-
-	gitService := initGitService()
-
-	authorizeEndpointMgmt := initEndpointWatcher(store.EndpointService, *flags.ExternalEndpoints, *flags.SyncInterval)
-
-	err := initKeyPair(fileService, digitalSignatureService)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	stackManager, err := initStackManager(*flags.Assets, digitalSignatureService, fileService)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = initSettings(store.SettingsService, flags)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = initDockerHub(store.DockerHubService)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	applicationStatus := initStatus(authorizeEndpointMgmt, flags)
-
-	if *flags.Endpoint != "" {
-		endpoints, err := store.EndpointService.Endpoints()
-		if err != nil {
-			log.Fatal(err)
-		}
-		if len(endpoints) == 0 {
-			endpoint := &portainer.Endpoint{
-				Name: "primary",
-				URL:  *flags.Endpoint,
-				Type: portainer.DockerEnvironment,
-				TLSConfig: portainer.TLSConfiguration{
-					TLS:           *flags.TLSVerify,
-					TLSSkipVerify: *flags.TLSSkipVerify,
-					TLSCACertPath: *flags.TLSCacert,
-					TLSCertPath:   *flags.TLSCert,
-					TLSKeyPath:    *flags.TLSKey,
-				},
-				AuthorizedUsers: []portainer.UserID{},
-				AuthorizedTeams: []portainer.TeamID{},
-				Extensions:      []portainer.EndpointExtension{},
-			}
-
-			agentOnDockerEnvironment, err := client.ExecutePingOperationFromEndpoint(endpoint)
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			if agentOnDockerEnvironment {
-				endpoint.Type = portainer.AgentOnDockerEnvironment
-			}
-
-			err = store.EndpointService.CreateEndpoint(endpoint)
-			if err != nil {
-				log.Fatal(err)
-			}
-		} else {
-			log.Println("Instance already has defined endpoints. Skipping the endpoint defined via CLI.")
-		}
-	}
-
-	adminPasswordHash := ""
-	if *flags.AdminPasswordFile != "" {
-		content, err := fileService.GetFileContent(*flags.AdminPasswordFile)
-		if err != nil {
-			log.Fatal(err)
-		}
-		adminPasswordHash, err = cryptoService.Hash(content)
-		if err != nil {
-			log.Fatal(err)
-		}
-	} else if *flags.AdminPassword != "" {
-		adminPasswordHash = *flags.AdminPassword
-	}
-
-	if adminPasswordHash != "" {
-		users, err := store.UserService.UsersByRole(portainer.AdministratorRole)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		if len(users) == 0 {
-			log.Printf("Creating admin user with password hash %s", adminPasswordHash)
-			user := &portainer.User{
-				Username: "admin",
-				Role:     portainer.AdministratorRole,
-				Password: adminPasswordHash,
-			}
-			err := store.UserService.CreateUser(user)
-			if err != nil {
-				log.Fatal(err)
-			}
-		} else {
-			log.Println("Instance already has an administrator user defined. Skipping admin password related flags.")
-		}
-	}
-
-	var server portainer.Server = &http.Server{
-		Status:                 applicationStatus,
-		BindAddress:            *flags.Addr,
-		AssetsPath:             *flags.Assets,
-		AuthDisabled:           *flags.NoAuth,
-		EndpointManagement:     authorizeEndpointMgmt,
-		UserService:            store.UserService,
-		TeamService:            store.TeamService,
-		TeamMembershipService:  store.TeamMembershipService,
-		EndpointService:        store.EndpointService,
-		EndpointGroupService:   store.EndpointGroupService,
-		ResourceControlService: store.ResourceControlService,
-		SettingsService:        store.SettingsService,
-		RegistryService:        store.RegistryService,
-		DockerHubService:       store.DockerHubService,
-		StackService:           store.StackService,
-		StackManager:           stackManager,
-		CryptoService:          cryptoService,
-		JWTService:             jwtService,
-		FileService:            fileService,
-		LDAPService:            ldapService,
-		GitService:             gitService,
-		SignatureService:       digitalSignatureService,
-		SSL:                    *flags.SSL,
-		SSLCert:                *flags.SSLCert,
-		SSLKey:                 *flags.SSLKey,
-	}
-
-	log.Printf("Starting Portainer %s on %s", portainer.APIVersion, *flags.Addr)
-	err = server.Start()
-	if err != nil {
-		log.Fatal(err)
-	}
-}

api/cron/endpoint_sync.go

@@ -1,209 +0,0 @@
-package cron
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"log"
-	"os"
-	"strings"
-
-	"github.com/portainer/portainer"
-)
-
-type (
-	endpointSyncJob struct {
-		logger           *log.Logger
-		endpointService  portainer.EndpointService
-		endpointFilePath string
-	}
-
-	synchronization struct {
-		endpointsToCreate []*portainer.Endpoint
-		endpointsToUpdate []*portainer.Endpoint
-		endpointsToDelete []*portainer.Endpoint
-	}
-
-	fileEndpoint struct {
-		Name          string `json:"Name"`
-		URL           string `json:"URL"`
-		TLS           bool   `json:"TLS,omitempty"`
-		TLSSkipVerify bool   `json:"TLSSkipVerify,omitempty"`
-		TLSCACert     string `json:"TLSCACert,omitempty"`
-		TLSCert       string `json:"TLSCert,omitempty"`
-		TLSKey        string `json:"TLSKey,omitempty"`
-	}
-)
-
-const (
-	// ErrEmptyEndpointArray is an error raised when the external endpoint source array is empty.
-	ErrEmptyEndpointArray = portainer.Error("External endpoint source is empty")
-)
-
-func newEndpointSyncJob(endpointFilePath string, endpointService portainer.EndpointService) endpointSyncJob {
-	return endpointSyncJob{
-		logger:           log.New(os.Stderr, "", log.LstdFlags),
-		endpointService:  endpointService,
-		endpointFilePath: endpointFilePath,
-	}
-}
-
-func endpointSyncError(err error, logger *log.Logger) bool {
-	if err != nil {
-		logger.Printf("Endpoint synchronization error: %s", err)
-		return true
-	}
-	return false
-}
-
-func isValidEndpoint(endpoint *portainer.Endpoint) bool {
-	if endpoint.Name != "" && endpoint.URL != "" {
-		if !strings.HasPrefix(endpoint.URL, "unix://") && !strings.HasPrefix(endpoint.URL, "tcp://") {
-			return false
-		}
-		return true
-	}
-	return false
-}
-
-func convertFileEndpoints(fileEndpoints []fileEndpoint) []portainer.Endpoint {
-	convertedEndpoints := make([]portainer.Endpoint, 0)
-
-	for _, e := range fileEndpoints {
-		endpoint := portainer.Endpoint{
-			Name:      e.Name,
-			URL:       e.URL,
-			TLSConfig: portainer.TLSConfiguration{},
-		}
-		if e.TLS {
-			endpoint.TLSConfig.TLS = true
-			endpoint.TLSConfig.TLSSkipVerify = e.TLSSkipVerify
-			endpoint.TLSConfig.TLSCACertPath = e.TLSCACert
-			endpoint.TLSConfig.TLSCertPath = e.TLSCert
-			endpoint.TLSConfig.TLSKeyPath = e.TLSKey
-		}
-		convertedEndpoints = append(convertedEndpoints, endpoint)
-	}
-
-	return convertedEndpoints
-}
-
-func endpointExists(endpoint *portainer.Endpoint, endpoints []portainer.Endpoint) int {
-	for idx, v := range endpoints {
-		if endpoint.Name == v.Name && isValidEndpoint(&v) {
-			return idx
-		}
-	}
-	return -1
-}
-
-func mergeEndpointIfRequired(original, updated *portainer.Endpoint) *portainer.Endpoint {
-	var endpoint *portainer.Endpoint
-	if original.URL != updated.URL || original.TLSConfig.TLS != updated.TLSConfig.TLS ||
-		(updated.TLSConfig.TLS && original.TLSConfig.TLSSkipVerify != updated.TLSConfig.TLSSkipVerify) ||
-		(updated.TLSConfig.TLS && original.TLSConfig.TLSCACertPath != updated.TLSConfig.TLSCACertPath) ||
-		(updated.TLSConfig.TLS && original.TLSConfig.TLSCertPath != updated.TLSConfig.TLSCertPath) ||
-		(updated.TLSConfig.TLS && original.TLSConfig.TLSKeyPath != updated.TLSConfig.TLSKeyPath) {
-		endpoint = original
-		endpoint.URL = updated.URL
-		if updated.TLSConfig.TLS {
-			endpoint.TLSConfig.TLS = true
-			endpoint.TLSConfig.TLSSkipVerify = updated.TLSConfig.TLSSkipVerify
-			endpoint.TLSConfig.TLSCACertPath = updated.TLSConfig.TLSCACertPath
-			endpoint.TLSConfig.TLSCertPath = updated.TLSConfig.TLSCertPath
-			endpoint.TLSConfig.TLSKeyPath = updated.TLSConfig.TLSKeyPath
-		} else {
-			endpoint.TLSConfig.TLS = false
-			endpoint.TLSConfig.TLSSkipVerify = false
-			endpoint.TLSConfig.TLSCACertPath = ""
-			endpoint.TLSConfig.TLSCertPath = ""
-			endpoint.TLSConfig.TLSKeyPath = ""
-		}
-	}
-	return endpoint
-}
-
-func (sync synchronization) requireSync() bool {
-	if len(sync.endpointsToCreate) != 0 || len(sync.endpointsToUpdate) != 0 || len(sync.endpointsToDelete) != 0 {
-		return true
-	}
-	return false
-}
-
-// TMP: endpointSyncJob method to access logger, should be generic
-func (job endpointSyncJob) prepareSyncData(storedEndpoints, fileEndpoints []portainer.Endpoint) *synchronization {
-	endpointsToCreate := make([]*portainer.Endpoint, 0)
-	endpointsToUpdate := make([]*portainer.Endpoint, 0)
-	endpointsToDelete := make([]*portainer.Endpoint, 0)
-
-	for idx := range storedEndpoints {
-		fidx := endpointExists(&storedEndpoints[idx], fileEndpoints)
-		if fidx != -1 {
-			endpoint := mergeEndpointIfRequired(&storedEndpoints[idx], &fileEndpoints[fidx])
-			if endpoint != nil {
-				job.logger.Printf("New definition for a stored endpoint found in file, updating database. [name: %v] [url: %v]\n", endpoint.Name, endpoint.URL)
-				endpointsToUpdate = append(endpointsToUpdate, endpoint)
-			}
-		} else {
-			job.logger.Printf("Stored endpoint not found in file (definition might be invalid), removing from database. [name: %v] [url: %v]", storedEndpoints[idx].Name, storedEndpoints[idx].URL)
-			endpointsToDelete = append(endpointsToDelete, &storedEndpoints[idx])
-		}
-	}
-
-	for idx, endpoint := range fileEndpoints {
-		if !isValidEndpoint(&endpoint) {
-			job.logger.Printf("Invalid file endpoint definition, skipping. [name: %v] [url: %v]", endpoint.Name, endpoint.URL)
-			continue
-		}
-		sidx := endpointExists(&fileEndpoints[idx], storedEndpoints)
-		if sidx == -1 {
-			job.logger.Printf("File endpoint not found in database, adding to database. [name: %v] [url: %v]", fileEndpoints[idx].Name, fileEndpoints[idx].URL)
-			endpointsToCreate = append(endpointsToCreate, &fileEndpoints[idx])
-		}
-	}
-
-	return &synchronization{
-		endpointsToCreate: endpointsToCreate,
-		endpointsToUpdate: endpointsToUpdate,
-		endpointsToDelete: endpointsToDelete,
-	}
-}
-
-func (job endpointSyncJob) Sync() error {
-	data, err := ioutil.ReadFile(job.endpointFilePath)
-	if endpointSyncError(err, job.logger) {
-		return err
-	}
-
-	var fileEndpoints []fileEndpoint
-	err = json.Unmarshal(data, &fileEndpoints)
-	if endpointSyncError(err, job.logger) {
-		return err
-	}
-
-	if len(fileEndpoints) == 0 {
-		return ErrEmptyEndpointArray
-	}
-
-	storedEndpoints, err := job.endpointService.Endpoints()
-	if endpointSyncError(err, job.logger) {
-		return err
-	}
-
-	convertedFileEndpoints := convertFileEndpoints(fileEndpoints)
-
-	sync := job.prepareSyncData(storedEndpoints, convertedFileEndpoints)
-	if sync.requireSync() {
-		err = job.endpointService.Synchronize(sync.endpointsToCreate, sync.endpointsToUpdate, sync.endpointsToDelete)
-		if endpointSyncError(err, job.logger) {
-			return err
-		}
-		job.logger.Printf("Endpoint synchronization ended. [created: %v] [updated: %v] [deleted: %v]", len(sync.endpointsToCreate), len(sync.endpointsToUpdate), len(sync.endpointsToDelete))
-	}
-	return nil
-}
-
-func (job endpointSyncJob) Run() {
-	job.logger.Println("Endpoint synchronization job started.")
-	err := job.Sync()
-	endpointSyncError(err, job.logger)
-}

api/cron/watcher.go

@@ -1,40 +0,0 @@
-package cron
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/robfig/cron"
-)
-
-// Watcher represents a service for managing crons.
-type Watcher struct {
-	Cron            *cron.Cron
-	EndpointService portainer.EndpointService
-	syncInterval    string
-}
-
-// NewWatcher initializes a new service.
-func NewWatcher(endpointService portainer.EndpointService, syncInterval string) *Watcher {
-	return &Watcher{
-		Cron:            cron.New(),
-		EndpointService: endpointService,
-		syncInterval:    syncInterval,
-	}
-}
-
-// WatchEndpointFile starts a cron job to synchronize the endpoints from a file
-func (watcher *Watcher) WatchEndpointFile(endpointFilePath string) error {
-	job := newEndpointSyncJob(endpointFilePath, watcher.EndpointService)
-
-	err := job.Sync()
-	if err != nil {
-		return err
-	}
-
-	err = watcher.Cron.AddJob("@every "+watcher.syncInterval, job)
-	if err != nil {
-		return err
-	}
-
-	watcher.Cron.Start()
-	return nil
-}

api/crypto/crypto.go

@@ -1,22 +0,0 @@
-package crypto
-
-import (
-	"golang.org/x/crypto/bcrypt"
-)
-
-// Service represents a service for encrypting/hashing data.
-type Service struct{}
-
-// Hash hashes a string using the bcrypt algorithm
-func (*Service) Hash(data string) (string, error) {
-	hash, err := bcrypt.GenerateFromPassword([]byte(data), bcrypt.DefaultCost)
-	if err != nil {
-		return "", nil
-	}
-	return string(hash), nil
-}
-
-// CompareHashAndData compares a hash to clear data and returns an error if the comparison fails.
-func (*Service) CompareHashAndData(hash string, data string) error {
-	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(data))
-}

api/crypto/ecdsa.go

@@ -1,125 +0,0 @@
-package crypto
-
-import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/md5"
-	"crypto/rand"
-	"crypto/x509"
-	"encoding/base64"
-	"encoding/hex"
-	"math/big"
-)
-
-const (
-	// PrivateKeyPemHeader represents the header that is appended to the PEM file when
-	// storing the private key.
-	PrivateKeyPemHeader = "EC PRIVATE KEY"
-	// PublicKeyPemHeader represents the header that is appended to the PEM file when
-	// storing the public key.
-	PublicKeyPemHeader = "ECDSA PUBLIC KEY"
-)
-
-// ECDSAService is a service used to create digital signatures when communicating with
-// an agent based environment. It will automatically generates a key pair using ECDSA or
-// can also reuse an existing ECDSA key pair.
-type ECDSAService struct {
-	privateKey    *ecdsa.PrivateKey
-	publicKey     *ecdsa.PublicKey
-	encodedPubKey string
-}
-
-// EncodedPublicKey returns the encoded version of the public that can be used
-// to be shared with other services. It's the hexadecimal encoding of the public key
-// content.
-func (service *ECDSAService) EncodedPublicKey() string {
-	return service.encodedPubKey
-}
-
-// PEMHeaders returns the ECDSA PEM headers.
-func (service *ECDSAService) PEMHeaders() (string, string) {
-	return PrivateKeyPemHeader, PublicKeyPemHeader
-}
-
-// ParseKeyPair parses existing private/public key pair content and associate
-// the parsed keys to the service.
-func (service *ECDSAService) ParseKeyPair(private, public []byte) error {
-	privateKey, err := x509.ParseECPrivateKey(private)
-	if err != nil {
-		return err
-	}
-
-	service.privateKey = privateKey
-
-	encodedKey := hex.EncodeToString(public)
-	service.encodedPubKey = encodedKey
-
-	publicKey, err := x509.ParsePKIXPublicKey(public)
-	if err != nil {
-		return err
-	}
-
-	service.publicKey = publicKey.(*ecdsa.PublicKey)
-
-	return nil
-}
-
-// GenerateKeyPair will create a new key pair using ECDSA.
-func (service *ECDSAService) GenerateKeyPair() ([]byte, []byte, error) {
-	pubkeyCurve := elliptic.P256()
-
-	privatekey, err := ecdsa.GenerateKey(pubkeyCurve, rand.Reader)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	service.privateKey = privatekey
-	service.publicKey = &privatekey.PublicKey
-
-	private, err := x509.MarshalECPrivateKey(service.privateKey)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	public, err := x509.MarshalPKIXPublicKey(service.publicKey)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	encodedKey := hex.EncodeToString(public)
-	service.encodedPubKey = encodedKey
-
-	return private, public, nil
-}
-
-// Sign creates a signature from a message.
-// It automatically hash the message using MD5 and creates a signature from
-// that hash.
-// It then encodes the generated signature in base64.
-func (service *ECDSAService) Sign(message string) (string, error) {
-	digest := md5.New()
-	digest.Write([]byte(message))
-	hash := digest.Sum(nil)
-
-	r := big.NewInt(0)
-	s := big.NewInt(0)
-
-	r, s, err := ecdsa.Sign(rand.Reader, service.privateKey, hash)
-	if err != nil {
-		return "", err
-	}
-
-	keyBytes := service.privateKey.Params().BitSize / 8
-
-	rBytes := r.Bytes()
-	rBytesPadded := make([]byte, keyBytes)
-	copy(rBytesPadded[keyBytes-len(rBytes):], rBytes)
-
-	sBytes := s.Bytes()
-	sBytesPadded := make([]byte, keyBytes)
-	copy(sBytesPadded[keyBytes-len(sBytes):], sBytes)
-
-	signature := append(rBytesPadded, sBytesPadded...)
-
-	return base64.RawStdEncoding.EncodeToString(signature), nil
-}

api/crypto/tls.go

@@ -1,60 +0,0 @@
-package crypto
-
-import (
-	"crypto/tls"
-	"crypto/x509"
-	"io/ioutil"
-
-	"github.com/portainer/portainer"
-)
-
-func CreateTLSConfig(caCert, cert, key []byte, skipClientVerification, skipServerVerification bool) (*tls.Config, error) {
-	config := &tls.Config{}
-	config.InsecureSkipVerify = skipServerVerification
-
-	if !skipClientVerification {
-		certificate, err := tls.X509KeyPair(cert, key)
-		if err != nil {
-			return nil, err
-		}
-		config.Certificates = []tls.Certificate{certificate}
-	}
-
-	if !skipServerVerification {
-		caCertPool := x509.NewCertPool()
-		caCertPool.AppendCertsFromPEM(caCert)
-		config.RootCAs = caCertPool
-	}
-
-	return config, nil
-}
-
-// CreateTLSConfiguration initializes a tls.Config using a CA certificate, a certificate and a key
-func CreateTLSConfiguration(config *portainer.TLSConfiguration) (*tls.Config, error) {
-	TLSConfig := &tls.Config{}
-
-	if config.TLS && config.TLSCertPath != "" && config.TLSKeyPath != "" {
-		cert, err := tls.LoadX509KeyPair(config.TLSCertPath, config.TLSKeyPath)
-		if err != nil {
-			return nil, err
-		}
-
-		TLSConfig.Certificates = []tls.Certificate{cert}
-	}
-
-	if config.TLS && !config.TLSSkipVerify {
-		caCert, err := ioutil.ReadFile(config.TLSCACertPath)
-		if err != nil {
-			return nil, err
-		}
-
-		caCertPool := x509.NewCertPool()
-		caCertPool.AppendCertsFromPEM(caCert)
-
-		TLSConfig.RootCAs = caCertPool
-	}
-
-	TLSConfig.InsecureSkipVerify = config.TLSSkipVerify
-
-	return TLSConfig, nil
-}

api/csrf.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"github.com/gorilla/csrf"
+	"github.com/gorilla/securecookie"
+	"io/ioutil"
+	"log"
+	"net/http"
+)
+
+const keyFile = "authKey.dat"
+
+// newAuthKey reuses an existing CSRF authkey if present or generates a new one
+func newAuthKey(path string) []byte {
+	var authKey []byte
+	authKeyPath := path + "/" + keyFile
+	data, err := ioutil.ReadFile(authKeyPath)
+	if err != nil {
+		log.Print("Unable to find an existing CSRF auth key. Generating a new key.")
+		authKey = securecookie.GenerateRandomKey(32)
+		err := ioutil.WriteFile(authKeyPath, authKey, 0644)
+		if err != nil {
+			log.Fatal("Unable to persist CSRF auth key.")
+			log.Fatal(err)
+		}
+	} else {
+		authKey = data
+	}
+	return authKey
+}
+
+// newCSRF initializes a new CSRF handler
+func newCSRFHandler(keyPath string) func(h http.Handler) http.Handler {
+	authKey := newAuthKey(keyPath)
+	return csrf.Protect(
+		authKey,
+		csrf.HttpOnly(false),
+		csrf.Secure(false),
+	)
+}
+
+// newCSRFWrapper wraps a http.Handler to add the CSRF token
+func newCSRFWrapper(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("X-CSRF-Token", csrf.Token(r))
+		h.ServeHTTP(w, r)
+	})
+}

api/errors.go

@@ -1,108 +0,0 @@
-package portainer
-
-// General errors.
-const (
-	ErrUnauthorized           = Error("Unauthorized")
-	ErrResourceAccessDenied   = Error("Access denied to resource")
-	ErrResourceNotFound       = Error("Unable to find resource")
-	ErrUnsupportedDockerAPI   = Error("Unsupported Docker API response")
-	ErrMissingSecurityContext = Error("Unable to find security details in request context")
-)
-
-// User errors.
-const (
-	ErrUserNotFound            = Error("User not found")
-	ErrUserAlreadyExists       = Error("User already exists")
-	ErrInvalidUsername         = Error("Invalid username. White spaces are not allowed")
-	ErrAdminAlreadyInitialized = Error("An administrator user already exists")
-	ErrCannotRemoveAdmin       = Error("Cannot remove the default administrator account")
-	ErrAdminCannotRemoveSelf   = Error("Cannot remove your own user account. Contact another administrator")
-)
-
-// Team errors.
-const (
-	ErrTeamNotFound      = Error("Team not found")
-	ErrTeamAlreadyExists = Error("Team already exists")
-)
-
-// TeamMembership errors.
-const (
-	ErrTeamMembershipNotFound      = Error("Team membership not found")
-	ErrTeamMembershipAlreadyExists = Error("Team membership already exists for this user and team")
-)
-
-// ResourceControl errors.
-const (
-	ErrResourceControlNotFound      = Error("Resource control not found")
-	ErrResourceControlAlreadyExists = Error("A resource control is already applied on this resource")
-	ErrInvalidResourceControlType   = Error("Unsupported resource control type")
-)
-
-// Endpoint errors.
-const (
-	ErrEndpointNotFound     = Error("Endpoint not found")
-	ErrEndpointAccessDenied = Error("Access denied to endpoint")
-)
-
-// Endpoint group errors.
-const (
-	ErrEndpointGroupNotFound    = Error("Endpoint group not found")
-	ErrCannotRemoveDefaultGroup = Error("Cannot remove the default endpoint group")
-)
-
-// Registry errors.
-const (
-	ErrRegistryNotFound      = Error("Registry not found")
-	ErrRegistryAlreadyExists = Error("A registry is already defined for this URL")
-)
-
-// Stack errors
-const (
-	ErrStackNotFound                   = Error("Stack not found")
-	ErrStackAlreadyExists              = Error("A stack already exists with this name")
-	ErrComposeFileNotFoundInRepository = Error("Unable to find a Compose file in the repository")
-)
-
-// Endpoint extensions error
-const (
-	ErrEndpointExtensionNotSupported      = Error("This extension is not supported")
-	ErrEndpointExtensionAlreadyAssociated = Error("This extension is already associated to the endpoint")
-)
-
-// Version errors.
-const (
-	ErrDBVersionNotFound = Error("DB version not found")
-)
-
-// Settings errors.
-const (
-	ErrSettingsNotFound = Error("Settings not found")
-)
-
-// DockerHub errors.
-const (
-	ErrDockerHubNotFound = Error("Dockerhub not found")
-)
-
-// Crypto errors.
-const (
-	ErrCryptoHashFailure = Error("Unable to hash data")
-)
-
-// JWT errors.
-const (
-	ErrSecretGeneration   = Error("Unable to generate secret key")
-	ErrInvalidJWTToken    = Error("Invalid JWT token")
-	ErrMissingContextData = Error("Unable to find JWT data in request context")
-)
-
-// File errors.
-const (
-	ErrUndefinedTLSFileType = Error("Undefined TLS file type")
-)
-
-// Error represents an application error.
-type Error string
-
-// Error returns the error message.
-func (e Error) Error() string { return string(e) }

api/exec.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"golang.org/x/net/websocket"
+	"log"
+)
+
+// execContainer is used to create a websocket communication with an exec instance
+func (a *api) execContainer(ws *websocket.Conn) {
+	qry := ws.Request().URL.Query()
+	execID := qry.Get("id")
+
+	var host string
+	if a.endpoint.Scheme == "tcp" {
+		host = a.endpoint.Host
+	} else if a.endpoint.Scheme == "unix" {
+		host = a.endpoint.Path
+	}
+
+	if err := hijack(host, a.endpoint.Scheme, "POST", "/exec/"+execID+"/start", a.tlsConfig, true, ws, ws, ws, nil, nil); err != nil {
+		log.Fatalf("error during hijack: %s", err)
+		return
+	}
+}

api/exec/stack_manager.go

@@ -1,160 +0,0 @@
-package exec
-
-import (
-	"bytes"
-	"os"
-	"os/exec"
-	"path"
-	"runtime"
-
-	"github.com/portainer/portainer"
-)
-
-// StackManager represents a service for managing stacks.
-type StackManager struct {
-	binaryPath       string
-	signatureService portainer.DigitalSignatureService
-	fileService      portainer.FileService
-}
-
-type dockerCLIConfiguration struct {
-	HTTPHeaders struct {
-		ManagerOperationHeader string `json:"X-PortainerAgent-ManagerOperation"`
-		SignatureHeader        string `json:"X-PortainerAgent-Signature"`
-		PublicKey              string `json:"X-PortainerAgent-PublicKey"`
-	} `json:"HttpHeaders"`
-}
-
-// NewStackManager initializes a new StackManager service.
-// It also updates the configuration of the Docker CLI binary.
-func NewStackManager(binaryPath string, signatureService portainer.DigitalSignatureService, fileService portainer.FileService) (*StackManager, error) {
-	manager := &StackManager{
-		binaryPath:       binaryPath,
-		signatureService: signatureService,
-		fileService:      fileService,
-	}
-
-	err := manager.updateDockerCLIConfiguration(binaryPath)
-	if err != nil {
-		return nil, err
-	}
-
-	return manager, nil
-}
-
-// Login executes the docker login command against a list of registries (including DockerHub).
-func (manager *StackManager) Login(dockerhub *portainer.DockerHub, registries []portainer.Registry, endpoint *portainer.Endpoint) {
-	command, args := prepareDockerCommandAndArgs(manager.binaryPath, endpoint)
-	for _, registry := range registries {
-		if registry.Authentication {
-			registryArgs := append(args, "login", "--username", registry.Username, "--password", registry.Password, registry.URL)
-			runCommandAndCaptureStdErr(command, registryArgs, nil, "")
-		}
-	}
-
-	if dockerhub.Authentication {
-		dockerhubArgs := append(args, "login", "--username", dockerhub.Username, "--password", dockerhub.Password)
-		runCommandAndCaptureStdErr(command, dockerhubArgs, nil, "")
-	}
-}
-
-// Logout executes the docker logout command.
-func (manager *StackManager) Logout(endpoint *portainer.Endpoint) error {
-	command, args := prepareDockerCommandAndArgs(manager.binaryPath, endpoint)
-	args = append(args, "logout")
-	return runCommandAndCaptureStdErr(command, args, nil, "")
-}
-
-// Deploy executes the docker stack deploy command.
-func (manager *StackManager) Deploy(stack *portainer.Stack, prune bool, endpoint *portainer.Endpoint) error {
-	stackFilePath := path.Join(stack.ProjectPath, stack.EntryPoint)
-	command, args := prepareDockerCommandAndArgs(manager.binaryPath, endpoint)
-
-	if prune {
-		args = append(args, "stack", "deploy", "--prune", "--with-registry-auth", "--compose-file", stackFilePath, stack.Name)
-	} else {
-		args = append(args, "stack", "deploy", "--with-registry-auth", "--compose-file", stackFilePath, stack.Name)
-	}
-
-	env := make([]string, 0)
-	for _, envvar := range stack.Env {
-		env = append(env, envvar.Name+"="+envvar.Value)
-	}
-
-	stackFolder := path.Dir(stackFilePath)
-	return runCommandAndCaptureStdErr(command, args, env, stackFolder)
-}
-
-// Remove executes the docker stack rm command.
-func (manager *StackManager) Remove(stack *portainer.Stack, endpoint *portainer.Endpoint) error {
-	command, args := prepareDockerCommandAndArgs(manager.binaryPath, endpoint)
-	args = append(args, "stack", "rm", stack.Name)
-	return runCommandAndCaptureStdErr(command, args, nil, "")
-}
-
-func runCommandAndCaptureStdErr(command string, args []string, env []string, workingDir string) error {
-	var stderr bytes.Buffer
-	cmd := exec.Command(command, args...)
-	cmd.Stderr = &stderr
-	cmd.Dir = workingDir
-
-	if env != nil {
-		cmd.Env = os.Environ()
-		cmd.Env = append(cmd.Env, env...)
-	}
-
-	err := cmd.Run()
-	if err != nil {
-		return portainer.Error(stderr.String())
-	}
-
-	return nil
-}
-
-func prepareDockerCommandAndArgs(binaryPath string, endpoint *portainer.Endpoint) (string, []string) {
-	// Assume Linux as a default
-	command := path.Join(binaryPath, "docker")
-
-	if runtime.GOOS == "windows" {
-		command = path.Join(binaryPath, "docker.exe")
-	}
-
-	args := make([]string, 0)
-	args = append(args, "--config", binaryPath)
-	args = append(args, "-H", endpoint.URL)
-
-	if !endpoint.TLSConfig.TLS && endpoint.TLSConfig.TLSSkipVerify {
-		args = append(args, "--tls")
-	} else if endpoint.TLSConfig.TLS {
-		args = append(args, "--tls")
-
-		if !endpoint.TLSConfig.TLSSkipVerify {
-			args = append(args, "--tlsverify", "--tlscacert", endpoint.TLSConfig.TLSCACertPath)
-		}
-
-		if endpoint.TLSConfig.TLSCertPath != "" && endpoint.TLSConfig.TLSKeyPath != "" {
-			args = append(args, "--tlscert", endpoint.TLSConfig.TLSCertPath, "--tlskey", endpoint.TLSConfig.TLSKeyPath)
-		}
-	}
-
-	return command, args
-}
-
-func (manager *StackManager) updateDockerCLIConfiguration(binaryPath string) error {
-	config := dockerCLIConfiguration{}
-	config.HTTPHeaders.ManagerOperationHeader = "1"
-
-	signature, err := manager.signatureService.Sign(portainer.PortainerAgentSignatureMessage)
-	if err != nil {
-		return err
-	}
-	config.HTTPHeaders.SignatureHeader = signature
-	config.HTTPHeaders.PublicKey = manager.signatureService.EncodedPublicKey()
-
-	err = manager.fileService.WriteJSONToFile(path.Join(binaryPath, "config.json"), config)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

api/filesystem/filesystem.go

@@ -1,332 +0,0 @@
-package filesystem
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/pem"
-	"io/ioutil"
-
-	"github.com/portainer/portainer"
-
-	"io"
-	"os"
-	"path"
-)
-
-const (
-	// TLSStorePath represents the subfolder where TLS files are stored in the file store folder.
-	TLSStorePath = "tls"
-	// LDAPStorePath represents the subfolder where LDAP TLS files are stored in the TLSStorePath.
-	LDAPStorePath = "ldap"
-	// TLSCACertFile represents the name on disk for a TLS CA file.
-	TLSCACertFile = "ca.pem"
-	// TLSCertFile represents the name on disk for a TLS certificate file.
-	TLSCertFile = "cert.pem"
-	// TLSKeyFile represents the name on disk for a TLS key file.
-	TLSKeyFile = "key.pem"
-	// ComposeStorePath represents the subfolder where compose files are stored in the file store folder.
-	ComposeStorePath = "compose"
-	// ComposeFileDefaultName represents the default name of a compose file.
-	ComposeFileDefaultName = "docker-compose.yml"
-	// PrivateKeyFile represents the name on disk of the file containing the private key.
-	PrivateKeyFile = "portainer.key"
-	// PublicKeyFile represents the name on disk of the file containing the public key.
-	PublicKeyFile = "portainer.pub"
-)
-
-// Service represents a service for managing files and directories.
-type Service struct {
-	dataStorePath string
-	fileStorePath string
-}
-
-// NewService initializes a new service. It creates a data directory and a directory to store files
-// inside this directory if they don't exist.
-func NewService(dataStorePath, fileStorePath string) (*Service, error) {
-	service := &Service{
-		dataStorePath: dataStorePath,
-		fileStorePath: path.Join(dataStorePath, fileStorePath),
-	}
-
-	err := os.MkdirAll(dataStorePath, 0755)
-	if err != nil {
-		return nil, err
-	}
-
-	err = service.createDirectoryInStore(TLSStorePath)
-	if err != nil {
-		return nil, err
-	}
-
-	err = service.createDirectoryInStore(ComposeStorePath)
-	if err != nil {
-		return nil, err
-	}
-
-	return service, nil
-}
-
-// RemoveDirectory removes a directory on the filesystem.
-func (service *Service) RemoveDirectory(directoryPath string) error {
-	return os.RemoveAll(directoryPath)
-}
-
-// GetStackProjectPath returns the absolute path on the FS for a stack based
-// on its identifier.
-func (service *Service) GetStackProjectPath(stackIdentifier string) string {
-	return path.Join(service.fileStorePath, ComposeStorePath, stackIdentifier)
-}
-
-// StoreStackFileFromString creates a subfolder in the ComposeStorePath and stores a new file using the content from a string.
-// It returns the path to the folder where the file is stored.
-func (service *Service) StoreStackFileFromString(stackIdentifier, fileName, stackFileContent string) (string, error) {
-	stackStorePath := path.Join(ComposeStorePath, stackIdentifier)
-	err := service.createDirectoryInStore(stackStorePath)
-	if err != nil {
-		return "", err
-	}
-
-	composeFilePath := path.Join(stackStorePath, fileName)
-	data := []byte(stackFileContent)
-	r := bytes.NewReader(data)
-
-	err = service.createFileInStore(composeFilePath, r)
-	if err != nil {
-		return "", err
-	}
-
-	return path.Join(service.fileStorePath, stackStorePath), nil
-}
-
-// StoreStackFileFromReader creates a subfolder in the ComposeStorePath and stores a new file using the content from an io.Reader.
-// It returns the path to the folder where the file is stored.
-func (service *Service) StoreStackFileFromReader(stackIdentifier, fileName string, r io.Reader) (string, error) {
-	stackStorePath := path.Join(ComposeStorePath, stackIdentifier)
-	err := service.createDirectoryInStore(stackStorePath)
-	if err != nil {
-		return "", err
-	}
-
-	composeFilePath := path.Join(stackStorePath, fileName)
-
-	err = service.createFileInStore(composeFilePath, r)
-	if err != nil {
-		return "", err
-	}
-
-	return path.Join(service.fileStorePath, stackStorePath), nil
-}
-
-// StoreTLSFile creates a folder in the TLSStorePath and stores a new file with the content from r.
-func (service *Service) StoreTLSFile(folder string, fileType portainer.TLSFileType, r io.Reader) error {
-	storePath := path.Join(TLSStorePath, folder)
-	err := service.createDirectoryInStore(storePath)
-	if err != nil {
-		return err
-	}
-
-	var fileName string
-	switch fileType {
-	case portainer.TLSFileCA:
-		fileName = TLSCACertFile
-	case portainer.TLSFileCert:
-		fileName = TLSCertFile
-	case portainer.TLSFileKey:
-		fileName = TLSKeyFile
-	default:
-		return portainer.ErrUndefinedTLSFileType
-	}
-
-	tlsFilePath := path.Join(storePath, fileName)
-	err = service.createFileInStore(tlsFilePath, r)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// GetPathForTLSFile returns the absolute path to a specific TLS file for an endpoint.
-func (service *Service) GetPathForTLSFile(folder string, fileType portainer.TLSFileType) (string, error) {
-	var fileName string
-	switch fileType {
-	case portainer.TLSFileCA:
-		fileName = TLSCACertFile
-	case portainer.TLSFileCert:
-		fileName = TLSCertFile
-	case portainer.TLSFileKey:
-		fileName = TLSKeyFile
-	default:
-		return "", portainer.ErrUndefinedTLSFileType
-	}
-	return path.Join(service.fileStorePath, TLSStorePath, folder, fileName), nil
-}
-
-// DeleteTLSFiles deletes a folder in the TLS store path.
-func (service *Service) DeleteTLSFiles(folder string) error {
-	storePath := path.Join(service.fileStorePath, TLSStorePath, folder)
-	err := os.RemoveAll(storePath)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// DeleteTLSFile deletes a specific TLS file from a folder.
-func (service *Service) DeleteTLSFile(folder string, fileType portainer.TLSFileType) error {
-	var fileName string
-	switch fileType {
-	case portainer.TLSFileCA:
-		fileName = TLSCACertFile
-	case portainer.TLSFileCert:
-		fileName = TLSCertFile
-	case portainer.TLSFileKey:
-		fileName = TLSKeyFile
-	default:
-		return portainer.ErrUndefinedTLSFileType
-	}
-
-	filePath := path.Join(service.fileStorePath, TLSStorePath, folder, fileName)
-
-	err := os.Remove(filePath)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// GetFileContent returns a string content from file.
-func (service *Service) GetFileContent(filePath string) (string, error) {
-	content, err := ioutil.ReadFile(filePath)
-	if err != nil {
-		return "", err
-	}
-
-	return string(content), nil
-}
-
-// WriteJSONToFile writes JSON to the specified file.
-func (service *Service) WriteJSONToFile(path string, content interface{}) error {
-	jsonContent, err := json.Marshal(content)
-	if err != nil {
-		return err
-	}
-
-	return ioutil.WriteFile(path, jsonContent, 0644)
-}
-
-// KeyPairFilesExist checks for the existence of the key files.
-func (service *Service) KeyPairFilesExist() (bool, error) {
-	privateKeyPath := path.Join(service.dataStorePath, PrivateKeyFile)
-	exists, err := fileExists(privateKeyPath)
-	if err != nil {
-		return false, err
-	}
-	if !exists {
-		return false, nil
-	}
-
-	publicKeyPath := path.Join(service.dataStorePath, PublicKeyFile)
-	exists, err = fileExists(publicKeyPath)
-	if err != nil {
-		return false, err
-	}
-	if !exists {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-// StoreKeyPair store the specified keys content as PEM files on disk.
-func (service *Service) StoreKeyPair(private, public []byte, privatePEMHeader, publicPEMHeader string) error {
-	err := service.createPEMFileInStore(private, privatePEMHeader, PrivateKeyFile)
-	if err != nil {
-		return err
-	}
-
-	err = service.createPEMFileInStore(public, publicPEMHeader, PublicKeyFile)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// LoadKeyPair retrieve the content of both key files on disk.
-func (service *Service) LoadKeyPair() ([]byte, []byte, error) {
-	privateKey, err := service.getContentFromPEMFile(PrivateKeyFile)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	publicKey, err := service.getContentFromPEMFile(PublicKeyFile)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return privateKey, publicKey, nil
-}
-
-// createDirectoryInStore creates a new directory in the file store
-func (service *Service) createDirectoryInStore(name string) error {
-	path := path.Join(service.fileStorePath, name)
-	return os.MkdirAll(path, 0700)
-}
-
-// createFile creates a new file in the file store with the content from r.
-func (service *Service) createFileInStore(filePath string, r io.Reader) error {
-	path := path.Join(service.fileStorePath, filePath)
-
-	out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-
-	_, err = io.Copy(out, r)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (service *Service) createPEMFileInStore(content []byte, fileType, filePath string) error {
-	path := path.Join(service.fileStorePath, filePath)
-	block := &pem.Block{Type: fileType, Bytes: content}
-
-	out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-
-	err = pem.Encode(out, block)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (service *Service) getContentFromPEMFile(filePath string) ([]byte, error) {
-	path := path.Join(service.fileStorePath, filePath)
-
-	fileContent, err := ioutil.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	block, _ := pem.Decode(fileContent)
-	return block.Bytes, nil
-}
-
-func fileExists(filePath string) (bool, error) {
-	if _, err := os.Stat(filePath); err != nil {
-		if os.IsNotExist(err) {
-			return false, nil
-		}
-		return false, err
-	}
-	return true, nil
-}

api/flags.go

@@ -1,40 +1,46 @@
-package cli
+package main
 
 import (
-	"github.com/portainer/portainer"
-
 	"fmt"
 	"gopkg.in/alecthomas/kingpin.v2"
 	"strings"
 )
 
-type pairList []portainer.Pair
+// pair defines a key/value pair
+type pair struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
 
-// Set implementation for a list of portainer.Pair
+// pairList defines an array of Label
+type pairList []pair
+
+// Set implementation for Labels
 func (l *pairList) Set(value string) error {
 	parts := strings.SplitN(value, "=", 2)
 	if len(parts) != 2 {
 		return fmt.Errorf("expected NAME=VALUE got '%s'", value)
 	}
-	p := new(portainer.Pair)
+	p := new(pair)
 	p.Name = parts[0]
 	p.Value = parts[1]
 	*l = append(*l, *p)
 	return nil
 }
 
-// String implementation for a list of pair
+// String implementation for Labels
 func (l *pairList) String() string {
 	return ""
 }
 
-// IsCumulative implementation for a list of pair
+// IsCumulative implementation for Labels
 func (l *pairList) IsCumulative() bool {
 	return true
 }
 
-func pairs(s kingpin.Settings) (target *[]portainer.Pair) {
-	target = new([]portainer.Pair)
+// LabelParser defines a custom parser for Labels flags
+func pairs(s kingpin.Settings) (target *[]pair) {
+	target = new([]pair)
 	s.SetValue((*pairList)(target))
 	return
 }

api/git/git.go

@@ -1,39 +0,0 @@
-package git
-
-import (
-	"net/url"
-	"strings"
-
-	"gopkg.in/src-d/go-git.v4"
-)
-
-// Service represents a service for managing Git.
-type Service struct{}
-
-// NewService initializes a new service.
-func NewService(dataStorePath string) (*Service, error) {
-	service := &Service{}
-
-	return service, nil
-}
-
-// ClonePublicRepository clones a public git repository using the specified URL in the specified
-// destination folder.
-func (service *Service) ClonePublicRepository(repositoryURL, destination string) error {
-	return cloneRepository(repositoryURL, destination)
-}
-
-// ClonePrivateRepositoryWithBasicAuth clones a private git repository using the specified URL in the specified
-// destination folder. It will use the specified username and password for basic HTTP authentication.
-func (service *Service) ClonePrivateRepositoryWithBasicAuth(repositoryURL, destination, username, password string) error {
-	credentials := username + ":" + url.PathEscape(password)
-	repositoryURL = strings.Replace(repositoryURL, "://", "://"+credentials+"@", 1)
-	return cloneRepository(repositoryURL, destination)
-}
-
-func cloneRepository(repositoryURL, destination string) error {
-	_, err := git.PlainClone(destination, false, &git.CloneOptions{
-		URL: repositoryURL,
-	})
-	return err
-}

api/handler.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"golang.org/x/net/websocket"
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+)
+
+// newHandler creates a new http.Handler with CSRF protection
+func (a *api) newHandler(settings *Settings) http.Handler {
+	var (
+		mux         = http.NewServeMux()
+		fileHandler = http.FileServer(http.Dir(a.assetPath))
+	)
+
+	handler := a.newAPIHandler()
+	CSRFHandler := newCSRFHandler(a.dataPath)
+
+	mux.Handle("/", fileHandler)
+	mux.Handle("/dockerapi/", http.StripPrefix("/dockerapi", handler))
+	mux.Handle("/ws/exec", websocket.Handler(a.execContainer))
+	mux.HandleFunc("/settings", func(w http.ResponseWriter, r *http.Request) {
+		settingsHandler(w, r, settings)
+	})
+	return CSRFHandler(newCSRFWrapper(mux))
+}
+
+// newAPIHandler initializes a new http.Handler based on the URL scheme
+func (a *api) newAPIHandler() http.Handler {
+	var handler http.Handler
+	var endpoint = *a.endpoint
+	if endpoint.Scheme == "tcp" {
+		if a.tlsConfig != nil {
+			handler = a.newTCPHandlerWithTLS(&endpoint)
+		} else {
+			handler = a.newTCPHandler(&endpoint)
+		}
+	} else if endpoint.Scheme == "unix" {
+		socketPath := endpoint.Path
+		if _, err := os.Stat(socketPath); err != nil {
+			if os.IsNotExist(err) {
+				log.Fatalf("Unix socket %s does not exist", socketPath)
+			}
+			log.Fatal(err)
+		}
+		handler = a.newUnixHandler(socketPath)
+	} else {
+		log.Fatalf("Bad Docker enpoint: %v. Only unix:// and tcp:// are supported.", &endpoint)
+	}
+	return handler
+}
+
+// newUnixHandler initializes a new UnixHandler
+func (a *api) newUnixHandler(e string) http.Handler {
+	return &unixHandler{e}
+}
+
+// newTCPHandler initializes a HTTP reverse proxy
+func (a *api) newTCPHandler(u *url.URL) http.Handler {
+	u.Scheme = "http"
+	return httputil.NewSingleHostReverseProxy(u)
+}
+
+// newTCPHandlerWithL initializes a HTTPS reverse proxy with a TLS configuration
+func (a *api) newTCPHandlerWithTLS(u *url.URL) http.Handler {
+	u.Scheme = "https"
+	proxy := httputil.NewSingleHostReverseProxy(u)
+	proxy.Transport = &http.Transport{
+		TLSClientConfig: a.tlsConfig,
+	}
+	return proxy
+}

api/hijack.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"time"
+)
+
+type execConfig struct {
+	Tty    bool
+	Detach bool
+}
+
+// hijack allows to upgrade an HTTP connection to a TCP connection
+// It redirects IO streams for stdin, stdout and stderr to a websocket
+func hijack(addr, scheme, method, path string, tlsConfig *tls.Config, setRawTerminal bool, in io.ReadCloser, stdout, stderr io.Writer, started chan io.Closer, data interface{}) error {
+	execConfig := &execConfig{
+		Tty:    true,
+		Detach: false,
+	}
+
+	buf, err := json.Marshal(execConfig)
+	if err != nil {
+		return fmt.Errorf("error marshaling exec config: %s", err)
+	}
+
+	rdr := bytes.NewReader(buf)
+
+	req, err := http.NewRequest(method, path, rdr)
+	if err != nil {
+		return fmt.Errorf("error during hijack request: %s", err)
+	}
+
+	req.Header.Set("User-Agent", "Docker-Client")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Connection", "Upgrade")
+	req.Header.Set("Upgrade", "tcp")
+	req.Host = addr
+
+	var (
+		dial    net.Conn
+		dialErr error
+	)
+
+	if tlsConfig == nil {
+		dial, dialErr = net.Dial(scheme, addr)
+	} else {
+		dial, dialErr = tls.Dial(scheme, addr, tlsConfig)
+	}
+
+	if dialErr != nil {
+		return dialErr
+	}
+
+	// When we set up a TCP connection for hijack, there could be long periods
+	// of inactivity (a long running command with no output) that in certain
+	// network setups may cause ECONNTIMEOUT, leaving the client in an unknown
+	// state. Setting TCP KeepAlive on the socket connection will prohibit
+	// ECONNTIMEOUT unless the socket connection truly is broken
+	if tcpConn, ok := dial.(*net.TCPConn); ok {
+		tcpConn.SetKeepAlive(true)
+		tcpConn.SetKeepAlivePeriod(30 * time.Second)
+	}
+	if err != nil {
+		return err
+	}
+	clientconn := httputil.NewClientConn(dial, nil)
+	defer clientconn.Close()
+
+	// Server hijacks the connection, error 'connection closed' expected
+	clientconn.Do(req)
+
+	rwc, br := clientconn.Hijack()
+	defer rwc.Close()
+
+	if started != nil {
+		started <- rwc
+	}
+
+	var receiveStdout chan error
+
+	if stdout != nil || stderr != nil {
+		go func() (err error) {
+			if setRawTerminal && stdout != nil {
+				_, err = io.Copy(stdout, br)
+			}
+			return err
+		}()
+	}
+
+	go func() error {
+		if in != nil {
+			io.Copy(rwc, in)
+		}
+
+		if conn, ok := rwc.(interface {
+			CloseWrite() error
+		}); ok {
+			if err := conn.CloseWrite(); err != nil {
+			}
+		}
+		return nil
+	}()
+
+	if stdout != nil || stderr != nil {
+		if err := <-receiveStdout; err != nil {
+			return err
+		}
+	}
+	go func() {
+		for {
+			fmt.Println(br)
+		}
+	}()
+
+	return nil
+}

api/http/client/client.go

@@ -1,77 +0,0 @@
-package client
-
-import (
-	"crypto/tls"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/crypto"
-)
-
-// ExecutePingOperationFromEndpoint will send a SystemPing operation HTTP request to a Docker environment
-// using the specified endpoint configuration. It is used exclusively when
-// specifying an endpoint from the CLI via the -H flag.
-func ExecutePingOperationFromEndpoint(endpoint *portainer.Endpoint) (bool, error) {
-	if strings.HasPrefix(endpoint.URL, "unix://") {
-		return false, nil
-	}
-
-	transport := &http.Transport{}
-
-	scheme := "http"
-
-	if endpoint.TLSConfig.TLS || endpoint.TLSConfig.TLSSkipVerify {
-		tlsConfig, err := crypto.CreateTLSConfiguration(&endpoint.TLSConfig)
-		if err != nil {
-			return false, err
-		}
-		scheme = "https"
-		transport.TLSClientConfig = tlsConfig
-	}
-
-	client := &http.Client{
-		Timeout:   time.Second * 3,
-		Transport: transport,
-	}
-
-	target := strings.Replace(endpoint.URL, "tcp://", scheme+"://", 1)
-	return pingOperation(client, target)
-}
-
-// ExecutePingOperation will send a SystemPing operation HTTP request to a Docker environment
-// using the specified host and optional TLS configuration.
-func ExecutePingOperation(host string, tlsConfig *tls.Config) (bool, error) {
-	transport := &http.Transport{}
-
-	scheme := "http"
-	if tlsConfig != nil {
-		transport.TLSClientConfig = tlsConfig
-		scheme = "https"
-	}
-
-	client := &http.Client{
-		Timeout:   time.Second * 3,
-		Transport: transport,
-	}
-
-	target := strings.Replace(host, "tcp://", scheme+"://", 1)
-	return pingOperation(client, target)
-}
-
-func pingOperation(client *http.Client, target string) (bool, error) {
-	pingOperationURL := target + "/_ping"
-
-	response, err := client.Get(pingOperationURL)
-	if err != nil {
-		return false, err
-	}
-
-	agentOnDockerEnvironment := false
-	if response.Header.Get(portainer.PortainerAgentHeader) != "" {
-		agentOnDockerEnvironment = true
-	}
-
-	return agentOnDockerEnvironment, nil
-}

api/http/error/error.go

@@ -1,23 +0,0 @@
-package error
-
-import (
-	"encoding/json"
-	"log"
-	"net/http"
-)
-
-// errorResponse is a generic response for sending a error.
-type errorResponse struct {
-	Err string `json:"err,omitempty"`
-}
-
-// WriteErrorResponse writes an error message to the response and logger.
-func WriteErrorResponse(w http.ResponseWriter, err error, code int, logger *log.Logger) {
-	if logger != nil {
-		logger.Printf("http error: %s (code=%d)", err, code)
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(code)
-	json.NewEncoder(w).Encode(&errorResponse{Err: err.Error()})
-}

api/http/handler/auth.go

@@ -1,126 +0,0 @@
-package handler
-
-import (
-	"github.com/portainer/portainer"
-
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/gorilla/mux"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-)
-
-// AuthHandler represents an HTTP API handler for managing authentication.
-type AuthHandler struct {
-	*mux.Router
-	Logger          *log.Logger
-	authDisabled    bool
-	UserService     portainer.UserService
-	CryptoService   portainer.CryptoService
-	JWTService      portainer.JWTService
-	LDAPService     portainer.LDAPService
-	SettingsService portainer.SettingsService
-}
-
-const (
-	// ErrInvalidCredentialsFormat is an error raised when credentials format is not valid
-	ErrInvalidCredentialsFormat = portainer.Error("Invalid credentials format")
-	// ErrInvalidCredentials is an error raised when credentials for a user are invalid
-	ErrInvalidCredentials = portainer.Error("Invalid credentials")
-	// ErrAuthDisabled is an error raised when trying to access the authentication endpoints
-	// when the server has been started with the --no-auth flag
-	ErrAuthDisabled = portainer.Error("Authentication is disabled")
-)
-
-// NewAuthHandler returns a new instance of AuthHandler.
-func NewAuthHandler(bouncer *security.RequestBouncer, rateLimiter *security.RateLimiter, authDisabled bool) *AuthHandler {
-	h := &AuthHandler{
-		Router:       mux.NewRouter(),
-		Logger:       log.New(os.Stderr, "", log.LstdFlags),
-		authDisabled: authDisabled,
-	}
-	h.Handle("/auth",
-		rateLimiter.LimitAccess(bouncer.PublicAccess(http.HandlerFunc(h.handlePostAuth)))).Methods(http.MethodPost)
-
-	return h
-}
-
-type (
-	postAuthRequest struct {
-		Username string `valid:"required"`
-		Password string `valid:"required"`
-	}
-
-	postAuthResponse struct {
-		JWT string `json:"jwt"`
-	}
-)
-
-func (handler *AuthHandler) handlePostAuth(w http.ResponseWriter, r *http.Request) {
-	if handler.authDisabled {
-		httperror.WriteErrorResponse(w, ErrAuthDisabled, http.StatusServiceUnavailable, handler.Logger)
-		return
-	}
-
-	var req postAuthRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidCredentialsFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var username = req.Username
-	var password = req.Password
-
-	u, err := handler.UserService.UserByUsername(username)
-	if err == portainer.ErrUserNotFound {
-		httperror.WriteErrorResponse(w, ErrInvalidCredentials, http.StatusBadRequest, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	settings, err := handler.SettingsService.Settings()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if settings.AuthenticationMethod == portainer.AuthenticationLDAP && u.ID != 1 {
-		err = handler.LDAPService.AuthenticateUser(username, password, &settings.LDAPSettings)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-	} else {
-		err = handler.CryptoService.CompareHashAndData(u.Password, password)
-		if err != nil {
-			httperror.WriteErrorResponse(w, ErrInvalidCredentials, http.StatusUnprocessableEntity, handler.Logger)
-			return
-		}
-	}
-
-	tokenData := &portainer.TokenData{
-		ID:       u.ID,
-		Username: u.Username,
-		Role:     u.Role,
-	}
-
-	token, err := handler.JWTService.GenerateToken(tokenData)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postAuthResponse{JWT: token}, handler.Logger)
-}

api/http/handler/docker.go

@@ -1,92 +0,0 @@
-package handler
-
-import (
-	"strconv"
-
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/proxy"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// DockerHandler represents an HTTP API handler for proxying requests to the Docker API.
-type DockerHandler struct {
-	*mux.Router
-	Logger                *log.Logger
-	EndpointService       portainer.EndpointService
-	EndpointGroupService  portainer.EndpointGroupService
-	TeamMembershipService portainer.TeamMembershipService
-	ProxyManager          *proxy.Manager
-}
-
-// NewDockerHandler returns a new instance of DockerHandler.
-func NewDockerHandler(bouncer *security.RequestBouncer) *DockerHandler {
-	h := &DockerHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.PathPrefix("/{id}/docker").Handler(
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.proxyRequestsToDockerAPI)))
-	return h
-}
-
-func (handler *DockerHandler) proxyRequestsToDockerAPI(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	parsedID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpointID := portainer.EndpointID(parsedID)
-	endpoint, err := handler.EndpointService.Endpoint(endpointID)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	tokenData, err := security.RetrieveTokenData(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	memberships, err := handler.TeamMembershipService.TeamMembershipsByUserID(tokenData.ID)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if tokenData.Role != portainer.AdministratorRole {
-		group, err := handler.EndpointGroupService.EndpointGroup(endpoint.GroupID)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-
-		if !security.AuthorizedEndpointAccess(endpoint, group, tokenData.ID, memberships) {
-			httperror.WriteErrorResponse(w, portainer.ErrEndpointAccessDenied, http.StatusForbidden, handler.Logger)
-			return
-		}
-	}
-
-	var proxy http.Handler
-	proxy = handler.ProxyManager.GetProxy(string(endpointID))
-	if proxy == nil {
-		proxy, err = handler.ProxyManager.CreateAndRegisterProxy(endpoint)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-	}
-
-	http.StripPrefix("/"+id+"/docker", proxy).ServeHTTP(w, r)
-}

api/http/handler/dockerhub.go

@@ -1,91 +0,0 @@
-package handler
-
-import (
-	"encoding/json"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// DockerHubHandler represents an HTTP API handler for managing DockerHub.
-type DockerHubHandler struct {
-	*mux.Router
-	Logger           *log.Logger
-	DockerHubService portainer.DockerHubService
-}
-
-// NewDockerHubHandler returns a new instance of DockerHubHandler.
-func NewDockerHubHandler(bouncer *security.RequestBouncer) *DockerHubHandler {
-	h := &DockerHubHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/dockerhub",
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.handleGetDockerHub))).Methods(http.MethodGet)
-	h.Handle("/dockerhub",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutDockerHub))).Methods(http.MethodPut)
-
-	return h
-}
-
-type (
-	putDockerHubRequest struct {
-		Authentication bool   `valid:""`
-		Username       string `valid:""`
-		Password       string `valid:""`
-	}
-)
-
-// handleGetDockerHub handles GET requests on /dockerhub
-func (handler *DockerHubHandler) handleGetDockerHub(w http.ResponseWriter, r *http.Request) {
-	dockerhub, err := handler.DockerHubService.DockerHub()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	dockerhub.Password = ""
-
-	encodeJSON(w, dockerhub, handler.Logger)
-	return
-}
-
-// handlePutDockerHub handles PUT requests on /dockerhub
-func (handler *DockerHubHandler) handlePutDockerHub(w http.ResponseWriter, r *http.Request) {
-	var req putDockerHubRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	dockerhub := &portainer.DockerHub{
-		Authentication: false,
-		Username:       "",
-		Password:       "",
-	}
-
-	if req.Authentication {
-		dockerhub.Authentication = true
-		dockerhub.Username = req.Username
-		dockerhub.Password = req.Password
-	}
-
-	err = handler.DockerHubService.StoreDockerHub(dockerhub)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-	}
-}

api/http/handler/endpoint.go

@@ -1,541 +0,0 @@
-package handler
-
-import (
-	"bytes"
-	"strings"
-
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/crypto"
-	"github.com/portainer/portainer/http/client"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/proxy"
-	"github.com/portainer/portainer/http/security"
-
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-	"strconv"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/gorilla/mux"
-)
-
-// EndpointHandler represents an HTTP API handler for managing Docker endpoints.
-type EndpointHandler struct {
-	*mux.Router
-	Logger                      *log.Logger
-	authorizeEndpointManagement bool
-	EndpointService             portainer.EndpointService
-	EndpointGroupService        portainer.EndpointGroupService
-	FileService                 portainer.FileService
-	ProxyManager                *proxy.Manager
-}
-
-const (
-	// ErrEndpointManagementDisabled is an error raised when trying to access the endpoints management endpoints
-	// when the server has been started with the --external-endpoints flag
-	ErrEndpointManagementDisabled = portainer.Error("Endpoint management is disabled")
-)
-
-// NewEndpointHandler returns a new instance of EndpointHandler.
-func NewEndpointHandler(bouncer *security.RequestBouncer, authorizeEndpointManagement bool) *EndpointHandler {
-	h := &EndpointHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-		authorizeEndpointManagement: authorizeEndpointManagement,
-	}
-	h.Handle("/endpoints",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePostEndpoints))).Methods(http.MethodPost)
-	h.Handle("/endpoints",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetEndpoints))).Methods(http.MethodGet)
-	h.Handle("/endpoints/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleGetEndpoint))).Methods(http.MethodGet)
-	h.Handle("/endpoints/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutEndpoint))).Methods(http.MethodPut)
-	h.Handle("/endpoints/{id}/access",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutEndpointAccess))).Methods(http.MethodPut)
-	h.Handle("/endpoints/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleDeleteEndpoint))).Methods(http.MethodDelete)
-
-	return h
-}
-
-type (
-	putEndpointAccessRequest struct {
-		AuthorizedUsers []int `valid:"-"`
-		AuthorizedTeams []int `valid:"-"`
-	}
-
-	putEndpointsRequest struct {
-		Name                string `valid:"-"`
-		URL                 string `valid:"-"`
-		PublicURL           string `valid:"-"`
-		GroupID             int    `valid:"-"`
-		TLS                 bool   `valid:"-"`
-		TLSSkipVerify       bool   `valid:"-"`
-		TLSSkipClientVerify bool   `valid:"-"`
-	}
-
-	postEndpointPayload struct {
-		name                      string
-		url                       string
-		publicURL                 string
-		groupID                   int
-		useTLS                    bool
-		skipTLSServerVerification bool
-		skipTLSClientVerification bool
-		caCert                    []byte
-		cert                      []byte
-		key                       []byte
-	}
-)
-
-// handleGetEndpoints handles GET requests on /endpoints
-func (handler *EndpointHandler) handleGetEndpoints(w http.ResponseWriter, r *http.Request) {
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	endpoints, err := handler.EndpointService.Endpoints()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	groups, err := handler.EndpointGroupService.EndpointGroups()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredEndpoints, err := security.FilterEndpoints(endpoints, groups, securityContext)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, filteredEndpoints, handler.Logger)
-}
-
-func (handler *EndpointHandler) createTLSSecuredEndpoint(payload *postEndpointPayload) (*portainer.Endpoint, error) {
-	tlsConfig, err := crypto.CreateTLSConfig(payload.caCert, payload.cert, payload.key, payload.skipTLSClientVerification, payload.skipTLSServerVerification)
-	if err != nil {
-		return nil, err
-	}
-
-	agentOnDockerEnvironment, err := client.ExecutePingOperation(payload.url, tlsConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	endpointType := portainer.DockerEnvironment
-	if agentOnDockerEnvironment {
-		endpointType = portainer.AgentOnDockerEnvironment
-	}
-
-	endpoint := &portainer.Endpoint{
-		Name:      payload.name,
-		URL:       payload.url,
-		Type:      endpointType,
-		GroupID:   portainer.EndpointGroupID(payload.groupID),
-		PublicURL: payload.publicURL,
-		TLSConfig: portainer.TLSConfiguration{
-			TLS:           payload.useTLS,
-			TLSSkipVerify: payload.skipTLSServerVerification,
-		},
-		AuthorizedUsers: []portainer.UserID{},
-		AuthorizedTeams: []portainer.TeamID{},
-		Extensions:      []portainer.EndpointExtension{},
-	}
-
-	err = handler.EndpointService.CreateEndpoint(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	folder := strconv.Itoa(int(endpoint.ID))
-
-	if !payload.skipTLSServerVerification {
-		r := bytes.NewReader(payload.caCert)
-		// TODO: review the API exposed by the FileService to store
-		// a file from a byte slice and return the path to the stored file instead
-		// of using multiple legacy calls (StoreTLSFile, GetPathForTLSFile) here.
-		err = handler.FileService.StoreTLSFile(folder, portainer.TLSFileCA, r)
-		if err != nil {
-			handler.EndpointService.DeleteEndpoint(endpoint.ID)
-			return nil, err
-		}
-		caCertPath, _ := handler.FileService.GetPathForTLSFile(folder, portainer.TLSFileCA)
-		endpoint.TLSConfig.TLSCACertPath = caCertPath
-	}
-
-	if !payload.skipTLSClientVerification {
-		r := bytes.NewReader(payload.cert)
-		err = handler.FileService.StoreTLSFile(folder, portainer.TLSFileCert, r)
-		if err != nil {
-			handler.EndpointService.DeleteEndpoint(endpoint.ID)
-			return nil, err
-		}
-		certPath, _ := handler.FileService.GetPathForTLSFile(folder, portainer.TLSFileCert)
-		endpoint.TLSConfig.TLSCertPath = certPath
-
-		r = bytes.NewReader(payload.key)
-		err = handler.FileService.StoreTLSFile(folder, portainer.TLSFileKey, r)
-		if err != nil {
-			handler.EndpointService.DeleteEndpoint(endpoint.ID)
-			return nil, err
-		}
-		keyPath, _ := handler.FileService.GetPathForTLSFile(folder, portainer.TLSFileKey)
-		endpoint.TLSConfig.TLSKeyPath = keyPath
-	}
-
-	err = handler.EndpointService.UpdateEndpoint(endpoint.ID, endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	return endpoint, nil
-}
-
-func (handler *EndpointHandler) createUnsecuredEndpoint(payload *postEndpointPayload) (*portainer.Endpoint, error) {
-	endpointType := portainer.DockerEnvironment
-
-	if !strings.HasPrefix(payload.url, "unix://") {
-		agentOnDockerEnvironment, err := client.ExecutePingOperation(payload.url, nil)
-		if err != nil {
-			return nil, err
-		}
-		if agentOnDockerEnvironment {
-			endpointType = portainer.AgentOnDockerEnvironment
-		}
-	}
-
-	endpoint := &portainer.Endpoint{
-		Name:      payload.name,
-		URL:       payload.url,
-		Type:      endpointType,
-		GroupID:   portainer.EndpointGroupID(payload.groupID),
-		PublicURL: payload.publicURL,
-		TLSConfig: portainer.TLSConfiguration{
-			TLS: false,
-		},
-		AuthorizedUsers: []portainer.UserID{},
-		AuthorizedTeams: []portainer.TeamID{},
-		Extensions:      []portainer.EndpointExtension{},
-	}
-
-	err := handler.EndpointService.CreateEndpoint(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	return endpoint, nil
-}
-
-func (handler *EndpointHandler) createEndpoint(payload *postEndpointPayload) (*portainer.Endpoint, error) {
-	if payload.useTLS {
-		return handler.createTLSSecuredEndpoint(payload)
-	}
-	return handler.createUnsecuredEndpoint(payload)
-}
-
-func convertPostEndpointRequestToPayload(r *http.Request) (*postEndpointPayload, error) {
-	payload := &postEndpointPayload{}
-	payload.name = r.FormValue("Name")
-	payload.url = r.FormValue("URL")
-	payload.publicURL = r.FormValue("PublicURL")
-
-	if payload.name == "" || payload.url == "" {
-		return nil, ErrInvalidRequestFormat
-	}
-
-	rawGroupID := r.FormValue("GroupID")
-	if rawGroupID == "" {
-		payload.groupID = 1
-	} else {
-		groupID, err := strconv.Atoi(rawGroupID)
-		if err != nil {
-			return nil, err
-		}
-		payload.groupID = groupID
-	}
-
-	payload.useTLS = r.FormValue("TLS") == "true"
-
-	if payload.useTLS {
-		payload.skipTLSServerVerification = r.FormValue("TLSSkipVerify") == "true"
-		payload.skipTLSClientVerification = r.FormValue("TLSSkipClientVerify") == "true"
-
-		if !payload.skipTLSServerVerification {
-			caCert, err := getUploadedFileContent(r, "TLSCACertFile")
-			if err != nil {
-				return nil, err
-			}
-			payload.caCert = caCert
-		}
-
-		if !payload.skipTLSClientVerification {
-			cert, err := getUploadedFileContent(r, "TLSCertFile")
-			if err != nil {
-				return nil, err
-			}
-			payload.cert = cert
-			key, err := getUploadedFileContent(r, "TLSKeyFile")
-			if err != nil {
-				return nil, err
-			}
-			payload.key = key
-		}
-	}
-
-	return payload, nil
-}
-
-// handlePostEndpoints handles POST requests on /endpoints
-func (handler *EndpointHandler) handlePostEndpoints(w http.ResponseWriter, r *http.Request) {
-	if !handler.authorizeEndpointManagement {
-		httperror.WriteErrorResponse(w, ErrEndpointManagementDisabled, http.StatusServiceUnavailable, handler.Logger)
-		return
-	}
-
-	payload, err := convertPostEndpointRequestToPayload(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.createEndpoint(payload)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &endpoint, handler.Logger)
-}
-
-// handleGetEndpoint handles GET requests on /endpoints/:id
-func (handler *EndpointHandler) handleGetEndpoint(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, endpoint, handler.Logger)
-}
-
-// handlePutEndpointAccess handles PUT requests on /endpoints/:id/access
-func (handler *EndpointHandler) handlePutEndpointAccess(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putEndpointAccessRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.AuthorizedUsers != nil {
-		authorizedUserIDs := []portainer.UserID{}
-		for _, value := range req.AuthorizedUsers {
-			authorizedUserIDs = append(authorizedUserIDs, portainer.UserID(value))
-		}
-		endpoint.AuthorizedUsers = authorizedUserIDs
-	}
-
-	if req.AuthorizedTeams != nil {
-		authorizedTeamIDs := []portainer.TeamID{}
-		for _, value := range req.AuthorizedTeams {
-			authorizedTeamIDs = append(authorizedTeamIDs, portainer.TeamID(value))
-		}
-		endpoint.AuthorizedTeams = authorizedTeamIDs
-	}
-
-	err = handler.EndpointService.UpdateEndpoint(endpoint.ID, endpoint)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handlePutEndpoint handles PUT requests on /endpoints/:id
-func (handler *EndpointHandler) handlePutEndpoint(w http.ResponseWriter, r *http.Request) {
-	if !handler.authorizeEndpointManagement {
-		httperror.WriteErrorResponse(w, ErrEndpointManagementDisabled, http.StatusServiceUnavailable, handler.Logger)
-		return
-	}
-
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putEndpointsRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.Name != "" {
-		endpoint.Name = req.Name
-	}
-
-	if req.URL != "" {
-		endpoint.URL = req.URL
-	}
-
-	if req.PublicURL != "" {
-		endpoint.PublicURL = req.PublicURL
-	}
-
-	if req.GroupID != 0 {
-		endpoint.GroupID = portainer.EndpointGroupID(req.GroupID)
-	}
-
-	folder := strconv.Itoa(int(endpoint.ID))
-	if req.TLS {
-		endpoint.TLSConfig.TLS = true
-		endpoint.TLSConfig.TLSSkipVerify = req.TLSSkipVerify
-		if !req.TLSSkipVerify {
-			caCertPath, _ := handler.FileService.GetPathForTLSFile(folder, portainer.TLSFileCA)
-			endpoint.TLSConfig.TLSCACertPath = caCertPath
-		} else {
-			endpoint.TLSConfig.TLSCACertPath = ""
-			handler.FileService.DeleteTLSFile(folder, portainer.TLSFileCA)
-		}
-
-		if !req.TLSSkipClientVerify {
-			certPath, _ := handler.FileService.GetPathForTLSFile(folder, portainer.TLSFileCert)
-			endpoint.TLSConfig.TLSCertPath = certPath
-			keyPath, _ := handler.FileService.GetPathForTLSFile(folder, portainer.TLSFileKey)
-			endpoint.TLSConfig.TLSKeyPath = keyPath
-		} else {
-			endpoint.TLSConfig.TLSCertPath = ""
-			handler.FileService.DeleteTLSFile(folder, portainer.TLSFileCert)
-			endpoint.TLSConfig.TLSKeyPath = ""
-			handler.FileService.DeleteTLSFile(folder, portainer.TLSFileKey)
-		}
-	} else {
-		endpoint.TLSConfig.TLS = false
-		endpoint.TLSConfig.TLSSkipVerify = true
-		endpoint.TLSConfig.TLSCACertPath = ""
-		endpoint.TLSConfig.TLSCertPath = ""
-		endpoint.TLSConfig.TLSKeyPath = ""
-		err = handler.FileService.DeleteTLSFiles(folder)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-	}
-
-	_, err = handler.ProxyManager.CreateAndRegisterProxy(endpoint)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.EndpointService.UpdateEndpoint(endpoint.ID, endpoint)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleDeleteEndpoint handles DELETE requests on /endpoints/:id
-func (handler *EndpointHandler) handleDeleteEndpoint(w http.ResponseWriter, r *http.Request) {
-	if !handler.authorizeEndpointManagement {
-		httperror.WriteErrorResponse(w, ErrEndpointManagementDisabled, http.StatusServiceUnavailable, handler.Logger)
-		return
-	}
-
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	handler.ProxyManager.DeleteProxy(string(endpointID))
-	handler.ProxyManager.DeleteExtensionProxies(string(endpointID))
-
-	err = handler.EndpointService.DeleteEndpoint(portainer.EndpointID(endpointID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if endpoint.TLSConfig.TLS {
-		err = handler.FileService.DeleteTLSFiles(id)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-	}
-}

api/http/handler/endpoint_group.go

@@ -1,364 +0,0 @@
-package handler
-
-import (
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-	"strconv"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/gorilla/mux"
-)
-
-// EndpointGroupHandler represents an HTTP API handler for managing endpoint groups.
-type EndpointGroupHandler struct {
-	*mux.Router
-	Logger               *log.Logger
-	EndpointService      portainer.EndpointService
-	EndpointGroupService portainer.EndpointGroupService
-}
-
-// NewEndpointGroupHandler returns a new instance of EndpointGroupHandler.
-func NewEndpointGroupHandler(bouncer *security.RequestBouncer) *EndpointGroupHandler {
-	h := &EndpointGroupHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/endpoint_groups",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePostEndpointGroups))).Methods(http.MethodPost)
-	h.Handle("/endpoint_groups",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetEndpointGroups))).Methods(http.MethodGet)
-	h.Handle("/endpoint_groups/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleGetEndpointGroup))).Methods(http.MethodGet)
-	h.Handle("/endpoint_groups/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutEndpointGroup))).Methods(http.MethodPut)
-	h.Handle("/endpoint_groups/{id}/access",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutEndpointGroupAccess))).Methods(http.MethodPut)
-	h.Handle("/endpoint_groups/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleDeleteEndpointGroup))).Methods(http.MethodDelete)
-
-	return h
-}
-
-type (
-	postEndpointGroupsResponse struct {
-		ID int `json:"Id"`
-	}
-
-	postEndpointGroupsRequest struct {
-		Name                string                 `valid:"required"`
-		Description         string                 `valid:"-"`
-		Labels              []portainer.Pair       `valid:""`
-		AssociatedEndpoints []portainer.EndpointID `valid:""`
-	}
-
-	putEndpointGroupAccessRequest struct {
-		AuthorizedUsers []int `valid:"-"`
-		AuthorizedTeams []int `valid:"-"`
-	}
-
-	putEndpointGroupsRequest struct {
-		Name                string                 `valid:"-"`
-		Description         string                 `valid:"-"`
-		Labels              []portainer.Pair       `valid:""`
-		AssociatedEndpoints []portainer.EndpointID `valid:""`
-	}
-)
-
-// handleGetEndpointGroups handles GET requests on /endpoint_groups
-func (handler *EndpointGroupHandler) handleGetEndpointGroups(w http.ResponseWriter, r *http.Request) {
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	endpointGroups, err := handler.EndpointGroupService.EndpointGroups()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredEndpointGroups, err := security.FilterEndpointGroups(endpointGroups, securityContext)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, filteredEndpointGroups, handler.Logger)
-}
-
-// handlePostEndpointGroups handles POST requests on /endpoint_groups
-func (handler *EndpointGroupHandler) handlePostEndpointGroups(w http.ResponseWriter, r *http.Request) {
-	var req postEndpointGroupsRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpointGroup := &portainer.EndpointGroup{
-		Name:            req.Name,
-		Description:     req.Description,
-		Labels:          req.Labels,
-		AuthorizedUsers: []portainer.UserID{},
-		AuthorizedTeams: []portainer.TeamID{},
-	}
-
-	err = handler.EndpointGroupService.CreateEndpointGroup(endpointGroup)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	endpoints, err := handler.EndpointService.Endpoints()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	for _, endpoint := range endpoints {
-		if endpoint.GroupID == portainer.EndpointGroupID(1) {
-			err = handler.checkForGroupAssignment(endpoint, endpointGroup.ID, req.AssociatedEndpoints)
-			if err != nil {
-				httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-				return
-			}
-		}
-	}
-
-	encodeJSON(w, &postEndpointGroupsResponse{ID: int(endpointGroup.ID)}, handler.Logger)
-}
-
-// handleGetEndpointGroup handles GET requests on /endpoint_groups/:id
-func (handler *EndpointGroupHandler) handleGetEndpointGroup(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointGroupID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpointGroup, err := handler.EndpointGroupService.EndpointGroup(portainer.EndpointGroupID(endpointGroupID))
-	if err == portainer.ErrEndpointGroupNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, endpointGroup, handler.Logger)
-}
-
-// handlePutEndpointGroupAccess handles PUT requests on /endpoint_groups/:id/access
-func (handler *EndpointGroupHandler) handlePutEndpointGroupAccess(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointGroupID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putEndpointGroupAccessRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpointGroup, err := handler.EndpointGroupService.EndpointGroup(portainer.EndpointGroupID(endpointGroupID))
-	if err == portainer.ErrEndpointGroupNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.AuthorizedUsers != nil {
-		authorizedUserIDs := []portainer.UserID{}
-		for _, value := range req.AuthorizedUsers {
-			authorizedUserIDs = append(authorizedUserIDs, portainer.UserID(value))
-		}
-		endpointGroup.AuthorizedUsers = authorizedUserIDs
-	}
-
-	if req.AuthorizedTeams != nil {
-		authorizedTeamIDs := []portainer.TeamID{}
-		for _, value := range req.AuthorizedTeams {
-			authorizedTeamIDs = append(authorizedTeamIDs, portainer.TeamID(value))
-		}
-		endpointGroup.AuthorizedTeams = authorizedTeamIDs
-	}
-
-	err = handler.EndpointGroupService.UpdateEndpointGroup(endpointGroup.ID, endpointGroup)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handlePutEndpointGroup handles PUT requests on /endpoint_groups/:id
-func (handler *EndpointGroupHandler) handlePutEndpointGroup(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointGroupID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putEndpointGroupsRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	groupID := portainer.EndpointGroupID(endpointGroupID)
-	endpointGroup, err := handler.EndpointGroupService.EndpointGroup(groupID)
-	if err == portainer.ErrEndpointGroupNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.Name != "" {
-		endpointGroup.Name = req.Name
-	}
-
-	if req.Description != "" {
-		endpointGroup.Description = req.Description
-	}
-
-	endpointGroup.Labels = req.Labels
-
-	err = handler.EndpointGroupService.UpdateEndpointGroup(endpointGroup.ID, endpointGroup)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	endpoints, err := handler.EndpointService.Endpoints()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	for _, endpoint := range endpoints {
-		err = handler.updateEndpointGroup(endpoint, groupID, req.AssociatedEndpoints)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-	}
-}
-
-func (handler *EndpointGroupHandler) updateEndpointGroup(endpoint portainer.Endpoint, groupID portainer.EndpointGroupID, associatedEndpoints []portainer.EndpointID) error {
-	if endpoint.GroupID == groupID {
-		return handler.checkForGroupUnassignment(endpoint, associatedEndpoints)
-	} else if endpoint.GroupID == portainer.EndpointGroupID(1) {
-		return handler.checkForGroupAssignment(endpoint, groupID, associatedEndpoints)
-	}
-	return nil
-}
-
-func (handler *EndpointGroupHandler) checkForGroupUnassignment(endpoint portainer.Endpoint, associatedEndpoints []portainer.EndpointID) error {
-	for _, id := range associatedEndpoints {
-		if id == endpoint.ID {
-			return nil
-		}
-	}
-
-	endpoint.GroupID = portainer.EndpointGroupID(1)
-	return handler.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-}
-
-func (handler *EndpointGroupHandler) checkForGroupAssignment(endpoint portainer.Endpoint, groupID portainer.EndpointGroupID, associatedEndpoints []portainer.EndpointID) error {
-	for _, id := range associatedEndpoints {
-
-		if id == endpoint.ID {
-			endpoint.GroupID = groupID
-			return handler.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-		}
-	}
-	return nil
-}
-
-// handleDeleteEndpointGroup handles DELETE requests on /endpoint_groups/:id
-func (handler *EndpointGroupHandler) handleDeleteEndpointGroup(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	endpointGroupID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if endpointGroupID == 1 {
-		httperror.WriteErrorResponse(w, portainer.ErrCannotRemoveDefaultGroup, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	groupID := portainer.EndpointGroupID(endpointGroupID)
-	_, err = handler.EndpointGroupService.EndpointGroup(groupID)
-	if err == portainer.ErrEndpointGroupNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.EndpointGroupService.DeleteEndpointGroup(portainer.EndpointGroupID(endpointGroupID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	endpoints, err := handler.EndpointService.Endpoints()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	for _, endpoint := range endpoints {
-		if endpoint.GroupID == groupID {
-			endpoint.GroupID = portainer.EndpointGroupID(1)
-			err = handler.EndpointService.UpdateEndpoint(endpoint.ID, &endpoint)
-			if err != nil {
-				httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-				return
-			}
-		}
-	}
-}

api/http/handler/extensions.go

@@ -1,143 +0,0 @@
-package handler
-
-import (
-	"encoding/json"
-	"strconv"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/proxy"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// ExtensionHandler represents an HTTP API handler for managing Settings.
-type ExtensionHandler struct {
-	*mux.Router
-	Logger          *log.Logger
-	EndpointService portainer.EndpointService
-	ProxyManager    *proxy.Manager
-}
-
-// NewExtensionHandler returns a new instance of ExtensionHandler.
-func NewExtensionHandler(bouncer *security.RequestBouncer) *ExtensionHandler {
-	h := &ExtensionHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/{endpointId}/extensions",
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.handlePostExtensions))).Methods(http.MethodPost)
-	h.Handle("/{endpointId}/extensions/{extensionType}",
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.handleDeleteExtensions))).Methods(http.MethodDelete)
-	return h
-}
-
-type (
-	postExtensionRequest struct {
-		Type int    `valid:"required"`
-		URL  string `valid:"required"`
-	}
-)
-
-func (handler *ExtensionHandler) handlePostExtensions(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	endpointID := portainer.EndpointID(id)
-
-	endpoint, err := handler.EndpointService.Endpoint(endpointID)
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	var req postExtensionRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	extensionType := portainer.EndpointExtensionType(req.Type)
-
-	var extension *portainer.EndpointExtension
-
-	for _, ext := range endpoint.Extensions {
-		if ext.Type == extensionType {
-			extension = &ext
-		}
-	}
-
-	if extension != nil {
-		extension.URL = req.URL
-	} else {
-		extension = &portainer.EndpointExtension{
-			Type: extensionType,
-			URL:  req.URL,
-		}
-		endpoint.Extensions = append(endpoint.Extensions, *extension)
-	}
-
-	err = handler.EndpointService.UpdateEndpoint(endpoint.ID, endpoint)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, extension, handler.Logger)
-}
-
-func (handler *ExtensionHandler) handleDeleteExtensions(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	endpointID := portainer.EndpointID(id)
-
-	endpoint, err := handler.EndpointService.Endpoint(endpointID)
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	extType, err := strconv.Atoi(vars["extensionType"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	extensionType := portainer.EndpointExtensionType(extType)
-
-	for idx, ext := range endpoint.Extensions {
-		if ext.Type == extensionType {
-			endpoint.Extensions = append(endpoint.Extensions[:idx], endpoint.Extensions[idx+1:]...)
-		}
-	}
-
-	err = handler.EndpointService.UpdateEndpoint(endpoint.ID, endpoint)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}

api/http/handler/extensions/storidge.go

@@ -1,106 +0,0 @@
-package extensions
-
-import (
-	"strconv"
-
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/proxy"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// StoridgeHandler represents an HTTP API handler for proxying requests to the Docker API.
-type StoridgeHandler struct {
-	*mux.Router
-	Logger                *log.Logger
-	EndpointService       portainer.EndpointService
-	EndpointGroupService  portainer.EndpointGroupService
-	TeamMembershipService portainer.TeamMembershipService
-	ProxyManager          *proxy.Manager
-}
-
-// NewStoridgeHandler returns a new instance of StoridgeHandler.
-func NewStoridgeHandler(bouncer *security.RequestBouncer) *StoridgeHandler {
-	h := &StoridgeHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.PathPrefix("/{id}/extensions/storidge").Handler(
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.proxyRequestsToStoridgeAPI)))
-	return h
-}
-
-func (handler *StoridgeHandler) proxyRequestsToStoridgeAPI(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	parsedID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpointID := portainer.EndpointID(parsedID)
-	endpoint, err := handler.EndpointService.Endpoint(endpointID)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	tokenData, err := security.RetrieveTokenData(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	memberships, err := handler.TeamMembershipService.TeamMembershipsByUserID(tokenData.ID)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if tokenData.Role != portainer.AdministratorRole {
-		group, err := handler.EndpointGroupService.EndpointGroup(endpoint.GroupID)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-
-		if !security.AuthorizedEndpointAccess(endpoint, group, tokenData.ID, memberships) {
-			httperror.WriteErrorResponse(w, portainer.ErrEndpointAccessDenied, http.StatusForbidden, handler.Logger)
-			return
-		}
-	}
-
-	var storidgeExtension *portainer.EndpointExtension
-	for _, extension := range endpoint.Extensions {
-		if extension.Type == portainer.StoridgeEndpointExtension {
-			storidgeExtension = &extension
-		}
-	}
-
-	if storidgeExtension == nil {
-		httperror.WriteErrorResponse(w, portainer.ErrEndpointExtensionNotSupported, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	proxyExtensionKey := string(endpoint.ID) + "_" + string(portainer.StoridgeEndpointExtension)
-
-	var proxy http.Handler
-	proxy = handler.ProxyManager.GetExtensionProxy(proxyExtensionKey)
-	if proxy == nil {
-		proxy, err = handler.ProxyManager.CreateAndRegisterExtensionProxy(proxyExtensionKey, storidgeExtension.URL)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-	}
-
-	http.StripPrefix("/"+id+"/extensions/storidge", proxy).ServeHTTP(w, r)
-}

api/http/handler/file.go

@@ -1,42 +0,0 @@
-package handler
-
-import (
-	"os"
-
-	"log"
-	"net/http"
-	"strings"
-)
-
-// FileHandler represents an HTTP API handler for managing static files.
-type FileHandler struct {
-	http.Handler
-	Logger *log.Logger
-}
-
-// NewFileHandler returns a new instance of FileHandler.
-func NewFileHandler(assetPublicPath string) *FileHandler {
-	h := &FileHandler{
-		Handler: http.FileServer(http.Dir(assetPublicPath)),
-		Logger:  log.New(os.Stderr, "", log.LstdFlags),
-	}
-	return h
-}
-
-func isHTML(acceptContent []string) bool {
-	for _, accept := range acceptContent {
-		if strings.Contains(accept, "text/html") {
-			return true
-		}
-	}
-	return false
-}
-
-func (handler *FileHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	if !isHTML(r.Header["Accept"]) {
-		w.Header().Set("Cache-Control", "max-age=31536000")
-	} else {
-		w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-	}
-	handler.Handler.ServeHTTP(w, r)
-}

api/http/handler/handler.go

@@ -1,117 +0,0 @@
-package handler
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"strings"
-
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/handler/extensions"
-)
-
-// Handler is a collection of all the service handlers.
-type Handler struct {
-	AuthHandler           *AuthHandler
-	UserHandler           *UserHandler
-	TeamHandler           *TeamHandler
-	TeamMembershipHandler *TeamMembershipHandler
-	EndpointHandler       *EndpointHandler
-	EndpointGroupHandler  *EndpointGroupHandler
-	RegistryHandler       *RegistryHandler
-	DockerHubHandler      *DockerHubHandler
-	ExtensionHandler      *ExtensionHandler
-	StoridgeHandler       *extensions.StoridgeHandler
-	ResourceHandler       *ResourceHandler
-	StackHandler          *StackHandler
-	StatusHandler         *StatusHandler
-	SettingsHandler       *SettingsHandler
-	TemplatesHandler      *TemplatesHandler
-	DockerHandler         *DockerHandler
-	WebSocketHandler      *WebSocketHandler
-	UploadHandler         *UploadHandler
-	FileHandler           *FileHandler
-}
-
-const (
-	// ErrInvalidJSON defines an error raised the app is unable to parse request data
-	ErrInvalidJSON = portainer.Error("Invalid JSON")
-	// ErrInvalidRequestFormat defines an error raised when the format of the data sent in a request is not valid
-	ErrInvalidRequestFormat = portainer.Error("Invalid request data format")
-	// ErrInvalidQueryFormat defines an error raised when the data sent in the query or the URL is invalid
-	ErrInvalidQueryFormat = portainer.Error("Invalid query format")
-)
-
-// ServeHTTP delegates a request to the appropriate subhandler.
-func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-
-	switch {
-	case strings.HasPrefix(r.URL.Path, "/api/auth"):
-		http.StripPrefix("/api", h.AuthHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/dockerhub"):
-		http.StripPrefix("/api", h.DockerHubHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/endpoint_groups"):
-		http.StripPrefix("/api", h.EndpointGroupHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/endpoints"):
-		switch {
-		case strings.Contains(r.URL.Path, "/docker/"):
-			http.StripPrefix("/api/endpoints", h.DockerHandler).ServeHTTP(w, r)
-		case strings.Contains(r.URL.Path, "/stacks"):
-			http.StripPrefix("/api/endpoints", h.StackHandler).ServeHTTP(w, r)
-		case strings.Contains(r.URL.Path, "/extensions/storidge"):
-			http.StripPrefix("/api/endpoints", h.StoridgeHandler).ServeHTTP(w, r)
-		case strings.Contains(r.URL.Path, "/extensions"):
-			http.StripPrefix("/api/endpoints", h.ExtensionHandler).ServeHTTP(w, r)
-		default:
-			http.StripPrefix("/api", h.EndpointHandler).ServeHTTP(w, r)
-		}
-	case strings.HasPrefix(r.URL.Path, "/api/registries"):
-		http.StripPrefix("/api", h.RegistryHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/resource_controls"):
-		http.StripPrefix("/api", h.ResourceHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/settings"):
-		http.StripPrefix("/api", h.SettingsHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/status"):
-		http.StripPrefix("/api", h.StatusHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/templates"):
-		http.StripPrefix("/api", h.TemplatesHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/upload"):
-		http.StripPrefix("/api", h.UploadHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/users"):
-		http.StripPrefix("/api", h.UserHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/teams"):
-		http.StripPrefix("/api", h.TeamHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/team_memberships"):
-		http.StripPrefix("/api", h.TeamMembershipHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/api/websocket"):
-		http.StripPrefix("/api", h.WebSocketHandler).ServeHTTP(w, r)
-	case strings.HasPrefix(r.URL.Path, "/"):
-		h.FileHandler.ServeHTTP(w, r)
-	}
-}
-
-// encodeJSON encodes v to w in JSON format. WriteErrorResponse() is called if encoding fails.
-func encodeJSON(w http.ResponseWriter, v interface{}, logger *log.Logger) {
-	w.Header().Set("Content-Type", "application/json")
-	if err := json.NewEncoder(w).Encode(v); err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, logger)
-	}
-}
-
-// getUploadedFileContent retrieve the content of a file uploaded in the request.
-// Uses requestParameter as the key to retrieve the file in the request payload.
-func getUploadedFileContent(request *http.Request, requestParameter string) ([]byte, error) {
-	file, _, err := request.FormFile(requestParameter)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	fileContent, err := ioutil.ReadAll(file)
-	if err != nil {
-		return nil, err
-	}
-	return fileContent, nil
-}

api/http/handler/registry.go

@@ -1,320 +0,0 @@
-package handler
-
-import (
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-	"strconv"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/gorilla/mux"
-)
-
-// RegistryHandler represents an HTTP API handler for managing Docker registries.
-type RegistryHandler struct {
-	*mux.Router
-	Logger          *log.Logger
-	RegistryService portainer.RegistryService
-}
-
-// NewRegistryHandler returns a new instance of RegistryHandler.
-func NewRegistryHandler(bouncer *security.RequestBouncer) *RegistryHandler {
-	h := &RegistryHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/registries",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePostRegistries))).Methods(http.MethodPost)
-	h.Handle("/registries",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetRegistries))).Methods(http.MethodGet)
-	h.Handle("/registries/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleGetRegistry))).Methods(http.MethodGet)
-	h.Handle("/registries/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutRegistry))).Methods(http.MethodPut)
-	h.Handle("/registries/{id}/access",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutRegistryAccess))).Methods(http.MethodPut)
-	h.Handle("/registries/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleDeleteRegistry))).Methods(http.MethodDelete)
-
-	return h
-}
-
-type (
-	postRegistriesRequest struct {
-		Name           string `valid:"required"`
-		URL            string `valid:"required"`
-		Authentication bool   `valid:""`
-		Username       string `valid:""`
-		Password       string `valid:""`
-	}
-
-	postRegistriesResponse struct {
-		ID int `json:"Id"`
-	}
-
-	putRegistryAccessRequest struct {
-		AuthorizedUsers []int `valid:"-"`
-		AuthorizedTeams []int `valid:"-"`
-	}
-
-	putRegistriesRequest struct {
-		Name           string `valid:"required"`
-		URL            string `valid:"required"`
-		Authentication bool   `valid:""`
-		Username       string `valid:""`
-		Password       string `valid:""`
-	}
-)
-
-// handleGetRegistries handles GET requests on /registries
-func (handler *RegistryHandler) handleGetRegistries(w http.ResponseWriter, r *http.Request) {
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	registries, err := handler.RegistryService.Registries()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredRegistries, err := security.FilterRegistries(registries, securityContext)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	for i := range filteredRegistries {
-		filteredRegistries[i].Password = ""
-	}
-
-	encodeJSON(w, filteredRegistries, handler.Logger)
-}
-
-// handlePostRegistries handles POST requests on /registries
-func (handler *RegistryHandler) handlePostRegistries(w http.ResponseWriter, r *http.Request) {
-	var req postRegistriesRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	registries, err := handler.RegistryService.Registries()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	for _, r := range registries {
-		if r.URL == req.URL {
-			httperror.WriteErrorResponse(w, portainer.ErrRegistryAlreadyExists, http.StatusConflict, handler.Logger)
-			return
-		}
-	}
-
-	registry := &portainer.Registry{
-		Name:            req.Name,
-		URL:             req.URL,
-		Authentication:  req.Authentication,
-		Username:        req.Username,
-		Password:        req.Password,
-		AuthorizedUsers: []portainer.UserID{},
-		AuthorizedTeams: []portainer.TeamID{},
-	}
-
-	err = handler.RegistryService.CreateRegistry(registry)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postRegistriesResponse{ID: int(registry.ID)}, handler.Logger)
-}
-
-// handleGetRegistry handles GET requests on /registries/:id
-func (handler *RegistryHandler) handleGetRegistry(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	registryID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	registry, err := handler.RegistryService.Registry(portainer.RegistryID(registryID))
-	if err == portainer.ErrRegistryNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	registry.Password = ""
-
-	encodeJSON(w, registry, handler.Logger)
-}
-
-// handlePutRegistryAccess handles PUT requests on /registries/:id/access
-func (handler *RegistryHandler) handlePutRegistryAccess(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	registryID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putRegistryAccessRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	registry, err := handler.RegistryService.Registry(portainer.RegistryID(registryID))
-	if err == portainer.ErrRegistryNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.AuthorizedUsers != nil {
-		authorizedUserIDs := []portainer.UserID{}
-		for _, value := range req.AuthorizedUsers {
-			authorizedUserIDs = append(authorizedUserIDs, portainer.UserID(value))
-		}
-		registry.AuthorizedUsers = authorizedUserIDs
-	}
-
-	if req.AuthorizedTeams != nil {
-		authorizedTeamIDs := []portainer.TeamID{}
-		for _, value := range req.AuthorizedTeams {
-			authorizedTeamIDs = append(authorizedTeamIDs, portainer.TeamID(value))
-		}
-		registry.AuthorizedTeams = authorizedTeamIDs
-	}
-
-	err = handler.RegistryService.UpdateRegistry(registry.ID, registry)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handlePutRegistry handles PUT requests on /registries/:id
-func (handler *RegistryHandler) handlePutRegistry(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	registryID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putRegistriesRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	registry, err := handler.RegistryService.Registry(portainer.RegistryID(registryID))
-	if err == portainer.ErrRegistryNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	registries, err := handler.RegistryService.Registries()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	for _, r := range registries {
-		if r.URL == req.URL && r.ID != registry.ID {
-			httperror.WriteErrorResponse(w, portainer.ErrRegistryAlreadyExists, http.StatusConflict, handler.Logger)
-			return
-		}
-	}
-
-	if req.Name != "" {
-		registry.Name = req.Name
-	}
-
-	if req.URL != "" {
-		registry.URL = req.URL
-	}
-
-	if req.Authentication {
-		registry.Authentication = true
-		registry.Username = req.Username
-		registry.Password = req.Password
-	} else {
-		registry.Authentication = false
-		registry.Username = ""
-		registry.Password = ""
-	}
-
-	err = handler.RegistryService.UpdateRegistry(registry.ID, registry)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleDeleteRegistry handles DELETE requests on /registries/:id
-func (handler *RegistryHandler) handleDeleteRegistry(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	registryID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = handler.RegistryService.Registry(portainer.RegistryID(registryID))
-	if err == portainer.ErrRegistryNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.RegistryService.DeleteRegistry(portainer.RegistryID(registryID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}

api/http/handler/resource_control.go

@@ -1,266 +0,0 @@
-package handler
-
-import (
-	"encoding/json"
-	"strconv"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// ResourceHandler represents an HTTP API handler for managing resource controls.
-type ResourceHandler struct {
-	*mux.Router
-	Logger                 *log.Logger
-	ResourceControlService portainer.ResourceControlService
-}
-
-// NewResourceHandler returns a new instance of ResourceHandler.
-func NewResourceHandler(bouncer *security.RequestBouncer) *ResourceHandler {
-	h := &ResourceHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/resource_controls",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handlePostResources))).Methods(http.MethodPost)
-	h.Handle("/resource_controls/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handlePutResources))).Methods(http.MethodPut)
-	h.Handle("/resource_controls/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleDeleteResources))).Methods(http.MethodDelete)
-
-	return h
-}
-
-type (
-	postResourcesRequest struct {
-		ResourceID         string   `valid:"required"`
-		Type               string   `valid:"required"`
-		AdministratorsOnly bool     `valid:"-"`
-		Users              []int    `valid:"-"`
-		Teams              []int    `valid:"-"`
-		SubResourceIDs     []string `valid:"-"`
-	}
-
-	putResourcesRequest struct {
-		AdministratorsOnly bool  `valid:"-"`
-		Users              []int `valid:"-"`
-		Teams              []int `valid:"-"`
-	}
-)
-
-// handlePostResources handles POST requests on /resources
-func (handler *ResourceHandler) handlePostResources(w http.ResponseWriter, r *http.Request) {
-	var req postResourcesRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var resourceControlType portainer.ResourceControlType
-	switch req.Type {
-	case "container":
-		resourceControlType = portainer.ContainerResourceControl
-	case "service":
-		resourceControlType = portainer.ServiceResourceControl
-	case "volume":
-		resourceControlType = portainer.VolumeResourceControl
-	case "network":
-		resourceControlType = portainer.NetworkResourceControl
-	case "secret":
-		resourceControlType = portainer.SecretResourceControl
-	case "stack":
-		resourceControlType = portainer.StackResourceControl
-	case "config":
-		resourceControlType = portainer.ConfigResourceControl
-	default:
-		httperror.WriteErrorResponse(w, portainer.ErrInvalidResourceControlType, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if len(req.Users) == 0 && len(req.Teams) == 0 && !req.AdministratorsOnly {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	rc, err := handler.ResourceControlService.ResourceControlByResourceID(req.ResourceID)
-	if err != nil && err != portainer.ErrResourceControlNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	if rc != nil {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceControlAlreadyExists, http.StatusConflict, handler.Logger)
-		return
-	}
-
-	var userAccesses = make([]portainer.UserResourceAccess, 0)
-	for _, v := range req.Users {
-		userAccess := portainer.UserResourceAccess{
-			UserID:      portainer.UserID(v),
-			AccessLevel: portainer.ReadWriteAccessLevel,
-		}
-		userAccesses = append(userAccesses, userAccess)
-	}
-
-	var teamAccesses = make([]portainer.TeamResourceAccess, 0)
-	for _, v := range req.Teams {
-		teamAccess := portainer.TeamResourceAccess{
-			TeamID:      portainer.TeamID(v),
-			AccessLevel: portainer.ReadWriteAccessLevel,
-		}
-		teamAccesses = append(teamAccesses, teamAccess)
-	}
-
-	resourceControl := portainer.ResourceControl{
-		ResourceID:         req.ResourceID,
-		SubResourceIDs:     req.SubResourceIDs,
-		Type:               resourceControlType,
-		AdministratorsOnly: req.AdministratorsOnly,
-		UserAccesses:       userAccesses,
-		TeamAccesses:       teamAccesses,
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !security.AuthorizedResourceControlCreation(&resourceControl, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	err = handler.ResourceControlService.CreateResourceControl(&resourceControl)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	return
-}
-
-// handlePutResources handles PUT requests on /resources/:id
-func (handler *ResourceHandler) handlePutResources(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	resourceControlID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putResourcesRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	resourceControl, err := handler.ResourceControlService.ResourceControl(portainer.ResourceControlID(resourceControlID))
-
-	if err == portainer.ErrResourceControlNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	resourceControl.AdministratorsOnly = req.AdministratorsOnly
-
-	var userAccesses = make([]portainer.UserResourceAccess, 0)
-	for _, v := range req.Users {
-		userAccess := portainer.UserResourceAccess{
-			UserID:      portainer.UserID(v),
-			AccessLevel: portainer.ReadWriteAccessLevel,
-		}
-		userAccesses = append(userAccesses, userAccess)
-	}
-	resourceControl.UserAccesses = userAccesses
-
-	var teamAccesses = make([]portainer.TeamResourceAccess, 0)
-	for _, v := range req.Teams {
-		teamAccess := portainer.TeamResourceAccess{
-			TeamID:      portainer.TeamID(v),
-			AccessLevel: portainer.ReadWriteAccessLevel,
-		}
-		teamAccesses = append(teamAccesses, teamAccess)
-	}
-	resourceControl.TeamAccesses = teamAccesses
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !security.AuthorizedResourceControlUpdate(resourceControl, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	err = handler.ResourceControlService.UpdateResourceControl(resourceControl.ID, resourceControl)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleDeleteResources handles DELETE requests on /resources/:id
-func (handler *ResourceHandler) handleDeleteResources(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	resourceControlID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	resourceControl, err := handler.ResourceControlService.ResourceControl(portainer.ResourceControlID(resourceControlID))
-
-	if err == portainer.ErrResourceControlNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !security.AuthorizedResourceControlDeletion(resourceControl, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	err = handler.ResourceControlService.DeleteResourceControl(portainer.ResourceControlID(resourceControlID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}

api/http/handler/settings.go

@@ -1,181 +0,0 @@
-package handler
-
-import (
-	"encoding/json"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/filesystem"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// SettingsHandler represents an HTTP API handler for managing Settings.
-type SettingsHandler struct {
-	*mux.Router
-	Logger          *log.Logger
-	SettingsService portainer.SettingsService
-	LDAPService     portainer.LDAPService
-	FileService     portainer.FileService
-}
-
-// NewSettingsHandler returns a new instance of OldSettingsHandler.
-func NewSettingsHandler(bouncer *security.RequestBouncer) *SettingsHandler {
-	h := &SettingsHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/settings",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleGetSettings))).Methods(http.MethodGet)
-	h.Handle("/settings",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutSettings))).Methods(http.MethodPut)
-	h.Handle("/settings/public",
-		bouncer.PublicAccess(http.HandlerFunc(h.handleGetPublicSettings))).Methods(http.MethodGet)
-	h.Handle("/settings/authentication/checkLDAP",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutSettingsLDAPCheck))).Methods(http.MethodPut)
-
-	return h
-}
-
-type (
-	publicSettingsResponse struct {
-		LogoURL                            string                         `json:"LogoURL"`
-		DisplayDonationHeader              bool                           `json:"DisplayDonationHeader"`
-		DisplayExternalContributors        bool                           `json:"DisplayExternalContributors"`
-		AuthenticationMethod               portainer.AuthenticationMethod `json:"AuthenticationMethod"`
-		AllowBindMountsForRegularUsers     bool                           `json:"AllowBindMountsForRegularUsers"`
-		AllowPrivilegedModeForRegularUsers bool                           `json:"AllowPrivilegedModeForRegularUsers"`
-	}
-
-	putSettingsRequest struct {
-		TemplatesURL                       string                 `valid:"required"`
-		LogoURL                            string                 `valid:""`
-		BlackListedLabels                  []portainer.Pair       `valid:""`
-		DisplayDonationHeader              bool                   `valid:""`
-		DisplayExternalContributors        bool                   `valid:""`
-		AuthenticationMethod               int                    `valid:"required"`
-		LDAPSettings                       portainer.LDAPSettings `valid:""`
-		AllowBindMountsForRegularUsers     bool                   `valid:""`
-		AllowPrivilegedModeForRegularUsers bool                   `valid:""`
-	}
-
-	putSettingsLDAPCheckRequest struct {
-		LDAPSettings portainer.LDAPSettings `valid:""`
-	}
-)
-
-// handleGetSettings handles GET requests on /settings
-func (handler *SettingsHandler) handleGetSettings(w http.ResponseWriter, r *http.Request) {
-	settings, err := handler.SettingsService.Settings()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, settings, handler.Logger)
-	return
-}
-
-// handleGetPublicSettings handles GET requests on /settings/public
-func (handler *SettingsHandler) handleGetPublicSettings(w http.ResponseWriter, r *http.Request) {
-	settings, err := handler.SettingsService.Settings()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	publicSettings := &publicSettingsResponse{
-		LogoURL:                            settings.LogoURL,
-		DisplayDonationHeader:              settings.DisplayDonationHeader,
-		DisplayExternalContributors:        settings.DisplayExternalContributors,
-		AuthenticationMethod:               settings.AuthenticationMethod,
-		AllowBindMountsForRegularUsers:     settings.AllowBindMountsForRegularUsers,
-		AllowPrivilegedModeForRegularUsers: settings.AllowPrivilegedModeForRegularUsers,
-	}
-
-	encodeJSON(w, publicSettings, handler.Logger)
-	return
-}
-
-// handlePutSettings handles PUT requests on /settings
-func (handler *SettingsHandler) handlePutSettings(w http.ResponseWriter, r *http.Request) {
-	var req putSettingsRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	settings := &portainer.Settings{
-		TemplatesURL:                       req.TemplatesURL,
-		LogoURL:                            req.LogoURL,
-		BlackListedLabels:                  req.BlackListedLabels,
-		DisplayDonationHeader:              req.DisplayDonationHeader,
-		DisplayExternalContributors:        req.DisplayExternalContributors,
-		LDAPSettings:                       req.LDAPSettings,
-		AllowBindMountsForRegularUsers:     req.AllowBindMountsForRegularUsers,
-		AllowPrivilegedModeForRegularUsers: req.AllowPrivilegedModeForRegularUsers,
-	}
-
-	if req.AuthenticationMethod == 1 {
-		settings.AuthenticationMethod = portainer.AuthenticationInternal
-	} else if req.AuthenticationMethod == 2 {
-		settings.AuthenticationMethod = portainer.AuthenticationLDAP
-	} else {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if (settings.LDAPSettings.TLSConfig.TLS || settings.LDAPSettings.StartTLS) && !settings.LDAPSettings.TLSConfig.TLSSkipVerify {
-		caCertPath, _ := handler.FileService.GetPathForTLSFile(filesystem.LDAPStorePath, portainer.TLSFileCA)
-		settings.LDAPSettings.TLSConfig.TLSCACertPath = caCertPath
-	} else {
-		settings.LDAPSettings.TLSConfig.TLSCACertPath = ""
-		err := handler.FileService.DeleteTLSFiles(filesystem.LDAPStorePath)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		}
-	}
-
-	err = handler.SettingsService.StoreSettings(settings)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-	}
-}
-
-// handlePutSettingsLDAPCheck handles PUT requests on /settings/ldap/check
-func (handler *SettingsHandler) handlePutSettingsLDAPCheck(w http.ResponseWriter, r *http.Request) {
-	var req putSettingsLDAPCheckRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if (req.LDAPSettings.TLSConfig.TLS || req.LDAPSettings.StartTLS) && !req.LDAPSettings.TLSConfig.TLSSkipVerify {
-		caCertPath, _ := handler.FileService.GetPathForTLSFile(filesystem.LDAPStorePath, portainer.TLSFileCA)
-		req.LDAPSettings.TLSConfig.TLSCACertPath = caCertPath
-	}
-
-	err = handler.LDAPService.TestConnectivity(&req.LDAPSettings)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}

api/http/handler/stack.go

@@ -1,794 +0,0 @@
-package handler
-
-import (
-	"encoding/json"
-	"path"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/filesystem"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/proxy"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// StackHandler represents an HTTP API handler for managing Stack.
-type StackHandler struct {
-	stackCreationMutex *sync.Mutex
-	stackDeletionMutex *sync.Mutex
-	*mux.Router
-	Logger                 *log.Logger
-	FileService            portainer.FileService
-	GitService             portainer.GitService
-	StackService           portainer.StackService
-	EndpointService        portainer.EndpointService
-	ResourceControlService portainer.ResourceControlService
-	RegistryService        portainer.RegistryService
-	DockerHubService       portainer.DockerHubService
-	StackManager           portainer.StackManager
-}
-
-type stackDeploymentConfig struct {
-	endpoint   *portainer.Endpoint
-	stack      *portainer.Stack
-	prune      bool
-	dockerhub  *portainer.DockerHub
-	registries []portainer.Registry
-}
-
-// NewStackHandler returns a new instance of StackHandler.
-func NewStackHandler(bouncer *security.RequestBouncer) *StackHandler {
-	h := &StackHandler{
-		Router:             mux.NewRouter(),
-		stackCreationMutex: &sync.Mutex{},
-		stackDeletionMutex: &sync.Mutex{},
-		Logger:             log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/{endpointId}/stacks",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handlePostStacks))).Methods(http.MethodPost)
-	h.Handle("/{endpointId}/stacks",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetStacks))).Methods(http.MethodGet)
-	h.Handle("/{endpointId}/stacks/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetStack))).Methods(http.MethodGet)
-	h.Handle("/{endpointId}/stacks/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleDeleteStack))).Methods(http.MethodDelete)
-	h.Handle("/{endpointId}/stacks/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handlePutStack))).Methods(http.MethodPut)
-	h.Handle("/{endpointId}/stacks/{id}/stackfile",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetStackFile))).Methods(http.MethodGet)
-	return h
-}
-
-type (
-	postStacksRequest struct {
-		Name                        string           `valid:"required"`
-		SwarmID                     string           `valid:"required"`
-		StackFileContent            string           `valid:""`
-		RepositoryURL               string           `valid:""`
-		RepositoryAuthentication    bool             `valid:""`
-		RepositoryUsername          string           `valid:""`
-		RepositoryPassword          string           `valid:""`
-		ComposeFilePathInRepository string           `valid:""`
-		Env                         []portainer.Pair `valid:""`
-	}
-	postStacksResponse struct {
-		ID string `json:"Id"`
-	}
-	getStackFileResponse struct {
-		StackFileContent string `json:"StackFileContent"`
-	}
-	putStackRequest struct {
-		StackFileContent string           `valid:"required"`
-		Env              []portainer.Pair `valid:""`
-		Prune            bool             `valid:"-"`
-	}
-)
-
-// handlePostStacks handles POST requests on /:endpointId/stacks?method=<method>
-func (handler *StackHandler) handlePostStacks(w http.ResponseWriter, r *http.Request) {
-	method := r.FormValue("method")
-	if method == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidQueryFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if method == "string" {
-		handler.handlePostStacksStringMethod(w, r)
-	} else if method == "repository" {
-		handler.handlePostStacksRepositoryMethod(w, r)
-	} else if method == "file" {
-		handler.handlePostStacksFileMethod(w, r)
-	} else {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-}
-
-func (handler *StackHandler) handlePostStacksStringMethod(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	endpointID := portainer.EndpointID(id)
-
-	endpoint, err := handler.EndpointService.Endpoint(endpointID)
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	var req postStacksRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	stackName := req.Name
-	if stackName == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	stackFileContent := req.StackFileContent
-	if stackFileContent == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	swarmID := req.SwarmID
-	if swarmID == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	stacks, err := handler.StackService.Stacks()
-	if err != nil && err != portainer.ErrStackNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	for _, stack := range stacks {
-		if strings.EqualFold(stack.Name, stackName) {
-			httperror.WriteErrorResponse(w, portainer.ErrStackAlreadyExists, http.StatusConflict, handler.Logger)
-			return
-		}
-	}
-
-	stack := &portainer.Stack{
-		ID:         portainer.StackID(stackName + "_" + swarmID),
-		Name:       stackName,
-		SwarmID:    swarmID,
-		EntryPoint: filesystem.ComposeFileDefaultName,
-		Env:        req.Env,
-	}
-
-	projectPath, err := handler.FileService.StoreStackFileFromString(string(stack.ID), stack.EntryPoint, stackFileContent)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	stack.ProjectPath = projectPath
-
-	err = handler.StackService.CreateStack(stack)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	dockerhub, err := handler.DockerHubService.DockerHub()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	registries, err := handler.RegistryService.Registries()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredRegistries, err := security.FilterRegistries(registries, securityContext)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	config := stackDeploymentConfig{
-		stack:      stack,
-		endpoint:   endpoint,
-		dockerhub:  dockerhub,
-		registries: filteredRegistries,
-		prune:      false,
-	}
-	err = handler.deployStack(&config)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postStacksResponse{ID: string(stack.ID)}, handler.Logger)
-}
-
-func (handler *StackHandler) handlePostStacksRepositoryMethod(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	endpointID := portainer.EndpointID(id)
-
-	endpoint, err := handler.EndpointService.Endpoint(endpointID)
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	var req postStacksRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	stackName := req.Name
-	swarmID := req.SwarmID
-
-	if stackName == "" || swarmID == "" || req.RepositoryURL == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if req.RepositoryAuthentication && (req.RepositoryUsername == "" || req.RepositoryPassword == "") {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if req.ComposeFilePathInRepository == "" {
-		req.ComposeFilePathInRepository = filesystem.ComposeFileDefaultName
-	}
-
-	stacks, err := handler.StackService.Stacks()
-	if err != nil && err != portainer.ErrStackNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	for _, stack := range stacks {
-		if strings.EqualFold(stack.Name, stackName) {
-			httperror.WriteErrorResponse(w, portainer.ErrStackAlreadyExists, http.StatusConflict, handler.Logger)
-			return
-		}
-	}
-
-	stack := &portainer.Stack{
-		ID:         portainer.StackID(stackName + "_" + swarmID),
-		Name:       stackName,
-		SwarmID:    swarmID,
-		EntryPoint: req.ComposeFilePathInRepository,
-		Env:        req.Env,
-	}
-
-	projectPath := handler.FileService.GetStackProjectPath(string(stack.ID))
-	stack.ProjectPath = projectPath
-
-	// Ensure projectPath is empty
-	err = handler.FileService.RemoveDirectory(projectPath)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.RepositoryAuthentication {
-		err = handler.GitService.ClonePrivateRepositoryWithBasicAuth(req.RepositoryURL, projectPath, req.RepositoryUsername, req.RepositoryPassword)
-	} else {
-		err = handler.GitService.ClonePublicRepository(req.RepositoryURL, projectPath)
-	}
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.StackService.CreateStack(stack)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	dockerhub, err := handler.DockerHubService.DockerHub()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	registries, err := handler.RegistryService.Registries()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredRegistries, err := security.FilterRegistries(registries, securityContext)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	config := stackDeploymentConfig{
-		stack:      stack,
-		endpoint:   endpoint,
-		dockerhub:  dockerhub,
-		registries: filteredRegistries,
-		prune:      false,
-	}
-	err = handler.deployStack(&config)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postStacksResponse{ID: string(stack.ID)}, handler.Logger)
-}
-
-func (handler *StackHandler) handlePostStacksFileMethod(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	endpointID := portainer.EndpointID(id)
-
-	endpoint, err := handler.EndpointService.Endpoint(endpointID)
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	stackName := r.FormValue("Name")
-	if stackName == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	swarmID := r.FormValue("SwarmID")
-	if swarmID == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	envParam := r.FormValue("Env")
-	var env []portainer.Pair
-	if err = json.Unmarshal([]byte(envParam), &env); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	stackFile, _, err := r.FormFile("file")
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	defer stackFile.Close()
-
-	stacks, err := handler.StackService.Stacks()
-	if err != nil && err != portainer.ErrStackNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	for _, stack := range stacks {
-		if strings.EqualFold(stack.Name, stackName) {
-			httperror.WriteErrorResponse(w, portainer.ErrStackAlreadyExists, http.StatusConflict, handler.Logger)
-			return
-		}
-	}
-
-	stack := &portainer.Stack{
-		ID:         portainer.StackID(stackName + "_" + swarmID),
-		Name:       stackName,
-		SwarmID:    swarmID,
-		EntryPoint: filesystem.ComposeFileDefaultName,
-		Env:        env,
-	}
-
-	projectPath, err := handler.FileService.StoreStackFileFromReader(string(stack.ID), stack.EntryPoint, stackFile)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	stack.ProjectPath = projectPath
-
-	err = handler.StackService.CreateStack(stack)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	dockerhub, err := handler.DockerHubService.DockerHub()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	registries, err := handler.RegistryService.Registries()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredRegistries, err := security.FilterRegistries(registries, securityContext)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	config := stackDeploymentConfig{
-		stack:      stack,
-		endpoint:   endpoint,
-		dockerhub:  dockerhub,
-		registries: filteredRegistries,
-		prune:      false,
-	}
-	err = handler.deployStack(&config)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postStacksResponse{ID: string(stack.ID)}, handler.Logger)
-}
-
-// handleGetStacks handles GET requests on /:endpointId/stacks?swarmId=<swarmId>
-func (handler *StackHandler) handleGetStacks(w http.ResponseWriter, r *http.Request) {
-	swarmID := r.FormValue("swarmId")
-
-	vars := mux.Vars(r)
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	id, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	endpointID := portainer.EndpointID(id)
-
-	_, err = handler.EndpointService.Endpoint(endpointID)
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	var stacks []portainer.Stack
-	if swarmID == "" {
-		stacks, err = handler.StackService.Stacks()
-	} else {
-		stacks, err = handler.StackService.StacksBySwarmID(swarmID)
-	}
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	resourceControls, err := handler.ResourceControlService.ResourceControls()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredStacks := proxy.FilterStacks(stacks, resourceControls, securityContext.IsAdmin,
-		securityContext.UserID, securityContext.UserMemberships)
-
-	encodeJSON(w, filteredStacks, handler.Logger)
-}
-
-// handleGetStack handles GET requests on /:endpointId/stacks/:id
-func (handler *StackHandler) handleGetStack(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	stackID := vars["id"]
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	endpointID, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	stack, err := handler.StackService.Stack(portainer.StackID(stackID))
-	if err == portainer.ErrStackNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	resourceControl, err := handler.ResourceControlService.ResourceControlByResourceID(stack.Name)
-	if err != nil && err != portainer.ErrResourceControlNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	extendedStack := proxy.ExtendedStack{*stack, portainer.ResourceControl{}}
-	if resourceControl != nil {
-		if securityContext.IsAdmin || proxy.CanAccessStack(stack, resourceControl, securityContext.UserID, securityContext.UserMemberships) {
-			extendedStack.ResourceControl = *resourceControl
-		} else {
-			httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-			return
-		}
-	}
-
-	encodeJSON(w, extendedStack, handler.Logger)
-}
-
-// handlePutStack handles PUT requests on /:endpointId/stacks/:id
-func (handler *StackHandler) handlePutStack(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	stackID := vars["id"]
-
-	endpointID, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	stack, err := handler.StackService.Stack(portainer.StackID(stackID))
-	if err == portainer.ErrStackNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	var req putStackRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	stack.Env = req.Env
-
-	_, err = handler.FileService.StoreStackFileFromString(string(stack.ID), stack.EntryPoint, req.StackFileContent)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.StackService.UpdateStack(stack.ID, stack)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	dockerhub, err := handler.DockerHubService.DockerHub()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	registries, err := handler.RegistryService.Registries()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredRegistries, err := security.FilterRegistries(registries, securityContext)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	config := stackDeploymentConfig{
-		stack:      stack,
-		endpoint:   endpoint,
-		dockerhub:  dockerhub,
-		registries: filteredRegistries,
-		prune:      req.Prune,
-	}
-	err = handler.deployStack(&config)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleGetStackFile handles GET requests on /:endpointId/stacks/:id/stackfile
-func (handler *StackHandler) handleGetStackFile(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	stackID := vars["id"]
-
-	endpointID, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	stack, err := handler.StackService.Stack(portainer.StackID(stackID))
-	if err == portainer.ErrStackNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	stackFileContent, err := handler.FileService.GetFileContent(path.Join(stack.ProjectPath, stack.EntryPoint))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &getStackFileResponse{StackFileContent: stackFileContent}, handler.Logger)
-}
-
-// handleDeleteStack handles DELETE requests on /:endpointId/stacks/:id
-func (handler *StackHandler) handleDeleteStack(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	stackID := vars["id"]
-
-	endpointID, err := strconv.Atoi(vars["endpointId"])
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err == portainer.ErrEndpointNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	stack, err := handler.StackService.Stack(portainer.StackID(stackID))
-	if err == portainer.ErrStackNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	handler.stackDeletionMutex.Lock()
-	err = handler.StackManager.Remove(stack, endpoint)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	handler.stackDeletionMutex.Unlock()
-
-	err = handler.StackService.DeleteStack(portainer.StackID(stackID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.FileService.RemoveDirectory(stack.ProjectPath)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-func (handler *StackHandler) deployStack(config *stackDeploymentConfig) error {
-	handler.stackCreationMutex.Lock()
-
-	handler.StackManager.Login(config.dockerhub, config.registries, config.endpoint)
-
-	err := handler.StackManager.Deploy(config.stack, config.prune, config.endpoint)
-	if err != nil {
-		handler.stackCreationMutex.Unlock()
-		return err
-	}
-
-	err = handler.StackManager.Logout(config.endpoint)
-	if err != nil {
-		handler.stackCreationMutex.Unlock()
-		return err
-	}
-
-	handler.stackCreationMutex.Unlock()
-	return nil
-}

api/http/handler/status.go

@@ -1,38 +0,0 @@
-package handler
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// StatusHandler represents an HTTP API handler for managing Status.
-type StatusHandler struct {
-	*mux.Router
-	Logger *log.Logger
-	Status *portainer.Status
-}
-
-// NewStatusHandler returns a new instance of StatusHandler.
-func NewStatusHandler(bouncer *security.RequestBouncer, status *portainer.Status) *StatusHandler {
-	h := &StatusHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-		Status: status,
-	}
-	h.Handle("/status",
-		bouncer.PublicAccess(http.HandlerFunc(h.handleGetStatus))).Methods(http.MethodGet)
-
-	return h
-}
-
-// handleGetStatus handles GET requests on /status
-func (handler *StatusHandler) handleGetStatus(w http.ResponseWriter, r *http.Request) {
-	encodeJSON(w, handler.Status, handler.Logger)
-	return
-}

api/http/handler/team.go

@@ -1,262 +0,0 @@
-package handler
-
-import (
-	"strconv"
-
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/gorilla/mux"
-)
-
-// TeamHandler represents an HTTP API handler for managing teams.
-type TeamHandler struct {
-	*mux.Router
-	Logger                 *log.Logger
-	TeamService            portainer.TeamService
-	TeamMembershipService  portainer.TeamMembershipService
-	ResourceControlService portainer.ResourceControlService
-}
-
-// NewTeamHandler returns a new instance of TeamHandler.
-func NewTeamHandler(bouncer *security.RequestBouncer) *TeamHandler {
-	h := &TeamHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/teams",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePostTeams))).Methods(http.MethodPost)
-	h.Handle("/teams",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetTeams))).Methods(http.MethodGet)
-	h.Handle("/teams/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetTeam))).Methods(http.MethodGet)
-	h.Handle("/teams/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePutTeam))).Methods(http.MethodPut)
-	h.Handle("/teams/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleDeleteTeam))).Methods(http.MethodDelete)
-	h.Handle("/teams/{id}/memberships",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetMemberships))).Methods(http.MethodGet)
-
-	return h
-}
-
-type (
-	postTeamsRequest struct {
-		Name string `valid:"required"`
-	}
-
-	postTeamsResponse struct {
-		ID int `json:"Id"`
-	}
-
-	putTeamRequest struct {
-		Name string `valid:"-"`
-	}
-)
-
-// handlePostTeams handles POST requests on /teams
-func (handler *TeamHandler) handlePostTeams(w http.ResponseWriter, r *http.Request) {
-	var req postTeamsRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	team, err := handler.TeamService.TeamByName(req.Name)
-	if err != nil && err != portainer.ErrTeamNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	if team != nil {
-		httperror.WriteErrorResponse(w, portainer.ErrTeamAlreadyExists, http.StatusConflict, handler.Logger)
-		return
-	}
-
-	team = &portainer.Team{
-		Name: req.Name,
-	}
-
-	err = handler.TeamService.CreateTeam(team)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postTeamsResponse{ID: int(team.ID)}, handler.Logger)
-}
-
-// handleGetTeams handles GET requests on /teams
-func (handler *TeamHandler) handleGetTeams(w http.ResponseWriter, r *http.Request) {
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	teams, err := handler.TeamService.Teams()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredTeams := security.FilterUserTeams(teams, securityContext)
-
-	encodeJSON(w, filteredTeams, handler.Logger)
-}
-
-// handleGetTeam handles GET requests on /teams/:id
-func (handler *TeamHandler) handleGetTeam(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	tid, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	teamID := portainer.TeamID(tid)
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !security.AuthorizedTeamManagement(teamID, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	team, err := handler.TeamService.Team(teamID)
-	if err == portainer.ErrTeamNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &team, handler.Logger)
-}
-
-// handlePutTeam handles PUT requests on /teams/:id
-func (handler *TeamHandler) handlePutTeam(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	teamID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putTeamRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	team, err := handler.TeamService.Team(portainer.TeamID(teamID))
-	if err == portainer.ErrTeamNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.Name != "" {
-		team.Name = req.Name
-	}
-
-	err = handler.TeamService.UpdateTeam(team.ID, team)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleDeleteTeam handles DELETE requests on /teams/:id
-func (handler *TeamHandler) handleDeleteTeam(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	teamID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = handler.TeamService.Team(portainer.TeamID(teamID))
-
-	if err == portainer.ErrTeamNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.TeamService.DeleteTeam(portainer.TeamID(teamID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.TeamMembershipService.DeleteTeamMembershipByTeamID(portainer.TeamID(teamID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleGetMemberships handles GET requests on /teams/:id/memberships
-func (handler *TeamHandler) handleGetMemberships(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	tid, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-	teamID := portainer.TeamID(tid)
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !security.AuthorizedTeamManagement(teamID, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	memberships, err := handler.TeamMembershipService.TeamMembershipsByTeamID(teamID)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, memberships, handler.Logger)
-}

api/http/handler/team_membership.go

@@ -1,242 +0,0 @@
-package handler
-
-import (
-	"strconv"
-
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/gorilla/mux"
-)
-
-// TeamMembershipHandler represents an HTTP API handler for managing teams.
-type TeamMembershipHandler struct {
-	*mux.Router
-	Logger                 *log.Logger
-	TeamMembershipService  portainer.TeamMembershipService
-	ResourceControlService portainer.ResourceControlService
-}
-
-// NewTeamMembershipHandler returns a new instance of TeamMembershipHandler.
-func NewTeamMembershipHandler(bouncer *security.RequestBouncer) *TeamMembershipHandler {
-	h := &TeamMembershipHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/team_memberships",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handlePostTeamMemberships))).Methods(http.MethodPost)
-	h.Handle("/team_memberships",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetTeamsMemberships))).Methods(http.MethodGet)
-	h.Handle("/team_memberships/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handlePutTeamMembership))).Methods(http.MethodPut)
-	h.Handle("/team_memberships/{id}",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleDeleteTeamMembership))).Methods(http.MethodDelete)
-
-	return h
-}
-
-type (
-	postTeamMembershipsRequest struct {
-		UserID int `valid:"required"`
-		TeamID int `valid:"required"`
-		Role   int `valid:"required"`
-	}
-
-	postTeamMembershipsResponse struct {
-		ID int `json:"Id"`
-	}
-
-	putTeamMembershipRequest struct {
-		UserID int `valid:"required"`
-		TeamID int `valid:"required"`
-		Role   int `valid:"required"`
-	}
-)
-
-// handlePostTeamMemberships handles POST requests on /team_memberships
-func (handler *TeamMembershipHandler) handlePostTeamMemberships(w http.ResponseWriter, r *http.Request) {
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	var req postTeamMembershipsRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	userID := portainer.UserID(req.UserID)
-	teamID := portainer.TeamID(req.TeamID)
-	role := portainer.MembershipRole(req.Role)
-
-	if !security.AuthorizedTeamManagement(teamID, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	memberships, err := handler.TeamMembershipService.TeamMembershipsByUserID(userID)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	if len(memberships) > 0 {
-		for _, membership := range memberships {
-			if membership.UserID == userID && membership.TeamID == teamID {
-				httperror.WriteErrorResponse(w, portainer.ErrTeamMembershipAlreadyExists, http.StatusConflict, handler.Logger)
-				return
-			}
-		}
-	}
-
-	membership := &portainer.TeamMembership{
-		UserID: userID,
-		TeamID: teamID,
-		Role:   role,
-	}
-
-	err = handler.TeamMembershipService.CreateTeamMembership(membership)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postTeamMembershipsResponse{ID: int(membership.ID)}, handler.Logger)
-}
-
-// handleGetTeamsMemberships handles GET requests on /team_memberships
-func (handler *TeamMembershipHandler) handleGetTeamsMemberships(w http.ResponseWriter, r *http.Request) {
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !securityContext.IsAdmin && !securityContext.IsTeamLeader {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	memberships, err := handler.TeamMembershipService.TeamMemberships()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, memberships, handler.Logger)
-}
-
-// handlePutTeamMembership handles PUT requests on /team_memberships/:id
-func (handler *TeamMembershipHandler) handlePutTeamMembership(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	membershipID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req putTeamMembershipRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	userID := portainer.UserID(req.UserID)
-	teamID := portainer.TeamID(req.TeamID)
-	role := portainer.MembershipRole(req.Role)
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !security.AuthorizedTeamManagement(teamID, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	membership, err := handler.TeamMembershipService.TeamMembership(portainer.TeamMembershipID(membershipID))
-	if err == portainer.ErrTeamMembershipNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if securityContext.IsTeamLeader && membership.Role != role {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	membership.UserID = userID
-	membership.TeamID = teamID
-	membership.Role = role
-
-	err = handler.TeamMembershipService.UpdateTeamMembership(membership.ID, membership)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleDeleteTeamMembership handles DELETE requests on /team_memberships/:id
-func (handler *TeamMembershipHandler) handleDeleteTeamMembership(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	membershipID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	membership, err := handler.TeamMembershipService.TeamMembership(portainer.TeamMembershipID(membershipID))
-	if err == portainer.ErrTeamMembershipNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !security.AuthorizedTeamManagement(membership.TeamID, securityContext) {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	err = handler.TeamMembershipService.DeleteTeamMembership(portainer.TeamMembershipID(membershipID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}

api/http/handler/templates.go

@@ -1,74 +0,0 @@
-package handler
-
-import (
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-)
-
-// TemplatesHandler represents an HTTP API handler for managing templates.
-type TemplatesHandler struct {
-	*mux.Router
-	Logger          *log.Logger
-	SettingsService portainer.SettingsService
-}
-
-const (
-	containerTemplatesURLLinuxServerIo = "https://tools.linuxserver.io/portainer.json"
-)
-
-// NewTemplatesHandler returns a new instance of TemplatesHandler.
-func NewTemplatesHandler(bouncer *security.RequestBouncer) *TemplatesHandler {
-	h := &TemplatesHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/templates",
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.handleGetTemplates))).Methods(http.MethodGet)
-	return h
-}
-
-// handleGetTemplates handles GET requests on /templates?key=<key>
-func (handler *TemplatesHandler) handleGetTemplates(w http.ResponseWriter, r *http.Request) {
-	key := r.FormValue("key")
-	if key == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidQueryFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var templatesURL string
-	switch key {
-	case "containers":
-		settings, err := handler.SettingsService.Settings()
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-		templatesURL = settings.TemplatesURL
-	case "linuxserver.io":
-		templatesURL = containerTemplatesURLLinuxServerIo
-	default:
-		httperror.WriteErrorResponse(w, ErrInvalidQueryFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	resp, err := http.Get(templatesURL)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	w.Header().Set("Content-Type", "application/json")
-	w.Write(body)
-}

api/http/handler/upload.go

@@ -1,69 +0,0 @@
-package handler
-
-import (
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-)
-
-// UploadHandler represents an HTTP API handler for managing file uploads.
-type UploadHandler struct {
-	*mux.Router
-	Logger      *log.Logger
-	FileService portainer.FileService
-}
-
-// NewUploadHandler returns a new instance of UploadHandler.
-func NewUploadHandler(bouncer *security.RequestBouncer) *UploadHandler {
-	h := &UploadHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/upload/tls/{certificate:(?:ca|cert|key)}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handlePostUploadTLS))).Methods(http.MethodPost)
-	return h
-}
-
-// handlePostUploadTLS handles POST requests on /upload/tls/{certificate:(?:ca|cert|key)}?folder=<folder>
-func (handler *UploadHandler) handlePostUploadTLS(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	certificate := vars["certificate"]
-
-	folder := r.FormValue("folder")
-	if folder == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidQueryFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	file, _, err := r.FormFile("file")
-	defer file.Close()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	var fileType portainer.TLSFileType
-	switch certificate {
-	case "ca":
-		fileType = portainer.TLSFileCA
-	case "cert":
-		fileType = portainer.TLSFileCert
-	case "key":
-		fileType = portainer.TLSFileKey
-	default:
-		httperror.WriteErrorResponse(w, portainer.ErrUndefinedTLSFileType, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.FileService.StoreTLSFile(folder, fileType, file)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}

api/http/handler/user.go

@@ -1,468 +0,0 @@
-package handler
-
-import (
-	"strconv"
-	"strings"
-
-	"github.com/portainer/portainer"
-	httperror "github.com/portainer/portainer/http/error"
-	"github.com/portainer/portainer/http/security"
-
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/gorilla/mux"
-)
-
-// UserHandler represents an HTTP API handler for managing users.
-type UserHandler struct {
-	*mux.Router
-	Logger                 *log.Logger
-	UserService            portainer.UserService
-	TeamService            portainer.TeamService
-	TeamMembershipService  portainer.TeamMembershipService
-	ResourceControlService portainer.ResourceControlService
-	CryptoService          portainer.CryptoService
-	SettingsService        portainer.SettingsService
-}
-
-// NewUserHandler returns a new instance of UserHandler.
-func NewUserHandler(bouncer *security.RequestBouncer) *UserHandler {
-	h := &UserHandler{
-		Router: mux.NewRouter(),
-		Logger: log.New(os.Stderr, "", log.LstdFlags),
-	}
-	h.Handle("/users",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handlePostUsers))).Methods(http.MethodPost)
-	h.Handle("/users",
-		bouncer.RestrictedAccess(http.HandlerFunc(h.handleGetUsers))).Methods(http.MethodGet)
-	h.Handle("/users/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleGetUser))).Methods(http.MethodGet)
-	h.Handle("/users/{id}",
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.handlePutUser))).Methods(http.MethodPut)
-	h.Handle("/users/{id}",
-		bouncer.AdministratorAccess(http.HandlerFunc(h.handleDeleteUser))).Methods(http.MethodDelete)
-	h.Handle("/users/{id}/memberships",
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.handleGetMemberships))).Methods(http.MethodGet)
-	h.Handle("/users/{id}/passwd",
-		bouncer.AuthenticatedAccess(http.HandlerFunc(h.handlePostUserPasswd))).Methods(http.MethodPost)
-	h.Handle("/users/admin/check",
-		bouncer.PublicAccess(http.HandlerFunc(h.handleGetAdminCheck))).Methods(http.MethodGet)
-	h.Handle("/users/admin/init",
-		bouncer.PublicAccess(http.HandlerFunc(h.handlePostAdminInit))).Methods(http.MethodPost)
-
-	return h
-}
-
-type (
-	postUsersRequest struct {
-		Username string `valid:"required"`
-		Password string `valid:""`
-		Role     int    `valid:"required"`
-	}
-
-	postUsersResponse struct {
-		ID int `json:"Id"`
-	}
-
-	postUserPasswdRequest struct {
-		Password string `valid:"required"`
-	}
-
-	postUserPasswdResponse struct {
-		Valid bool `json:"valid"`
-	}
-
-	putUserRequest struct {
-		Password string `valid:"-"`
-		Role     int    `valid:"-"`
-	}
-
-	postAdminInitRequest struct {
-		Username string `valid:"required"`
-		Password string `valid:"required"`
-	}
-)
-
-// handlePostUsers handles POST requests on /users
-func (handler *UserHandler) handlePostUsers(w http.ResponseWriter, r *http.Request) {
-	var req postUsersRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if !securityContext.IsAdmin && !securityContext.IsTeamLeader {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, nil)
-		return
-	}
-
-	if securityContext.IsTeamLeader && req.Role == 1 {
-		httperror.WriteErrorResponse(w, portainer.ErrResourceAccessDenied, http.StatusForbidden, nil)
-		return
-	}
-
-	if strings.ContainsAny(req.Username, " ") {
-		httperror.WriteErrorResponse(w, portainer.ErrInvalidUsername, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	user, err := handler.UserService.UserByUsername(req.Username)
-	if err != nil && err != portainer.ErrUserNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	if user != nil {
-		httperror.WriteErrorResponse(w, portainer.ErrUserAlreadyExists, http.StatusConflict, handler.Logger)
-		return
-	}
-
-	var role portainer.UserRole
-	if req.Role == 1 {
-		role = portainer.AdministratorRole
-	} else {
-		role = portainer.StandardUserRole
-	}
-
-	user = &portainer.User{
-		Username: req.Username,
-		Role:     role,
-	}
-
-	settings, err := handler.SettingsService.Settings()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if settings.AuthenticationMethod == portainer.AuthenticationInternal {
-		user.Password, err = handler.CryptoService.Hash(req.Password)
-		if err != nil {
-			httperror.WriteErrorResponse(w, portainer.ErrCryptoHashFailure, http.StatusBadRequest, handler.Logger)
-			return
-		}
-	}
-
-	err = handler.UserService.CreateUser(user)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, &postUsersResponse{ID: int(user.ID)}, handler.Logger)
-}
-
-// handleGetUsers handles GET requests on /users
-func (handler *UserHandler) handleGetUsers(w http.ResponseWriter, r *http.Request) {
-	securityContext, err := security.RetrieveRestrictedRequestContext(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	users, err := handler.UserService.Users()
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	filteredUsers := security.FilterUsers(users, securityContext)
-
-	for i := range filteredUsers {
-		filteredUsers[i].Password = ""
-	}
-
-	encodeJSON(w, filteredUsers, handler.Logger)
-}
-
-// handlePostUserPasswd handles POST requests on /users/:id/passwd
-func (handler *UserHandler) handlePostUserPasswd(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	userID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var req postUserPasswdRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	var password = req.Password
-
-	u, err := handler.UserService.User(portainer.UserID(userID))
-	if err == portainer.ErrUserNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	valid := true
-	err = handler.CryptoService.CompareHashAndData(u.Password, password)
-	if err != nil {
-		valid = false
-	}
-
-	encodeJSON(w, &postUserPasswdResponse{Valid: valid}, handler.Logger)
-}
-
-// handleGetUser handles GET requests on /users/:id
-func (handler *UserHandler) handleGetUser(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	userID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	user, err := handler.UserService.User(portainer.UserID(userID))
-	if err == portainer.ErrUserNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	user.Password = ""
-	encodeJSON(w, &user, handler.Logger)
-}
-
-// handlePutUser handles PUT requests on /users/:id
-func (handler *UserHandler) handlePutUser(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	userID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	tokenData, err := security.RetrieveTokenData(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if tokenData.Role != portainer.AdministratorRole && tokenData.ID != portainer.UserID(userID) {
-		httperror.WriteErrorResponse(w, portainer.ErrUnauthorized, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	var req putUserRequest
-	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err = govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if req.Password == "" && req.Role == 0 {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	user, err := handler.UserService.User(portainer.UserID(userID))
-	if err == portainer.ErrUserNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if req.Password != "" {
-		user.Password, err = handler.CryptoService.Hash(req.Password)
-		if err != nil {
-			httperror.WriteErrorResponse(w, portainer.ErrCryptoHashFailure, http.StatusBadRequest, handler.Logger)
-			return
-		}
-	}
-
-	if req.Role != 0 {
-		if tokenData.Role != portainer.AdministratorRole {
-			httperror.WriteErrorResponse(w, portainer.ErrUnauthorized, http.StatusForbidden, handler.Logger)
-			return
-		}
-		if req.Role == 1 {
-			user.Role = portainer.AdministratorRole
-		} else {
-			user.Role = portainer.StandardUserRole
-		}
-	}
-
-	err = handler.UserService.UpdateUser(user.ID, user)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleGetAdminCheck handles GET requests on /users/admin/check
-func (handler *UserHandler) handleGetAdminCheck(w http.ResponseWriter, r *http.Request) {
-	users, err := handler.UserService.UsersByRole(portainer.AdministratorRole)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	if len(users) == 0 {
-		httperror.WriteErrorResponse(w, portainer.ErrUserNotFound, http.StatusNotFound, handler.Logger)
-		return
-	}
-}
-
-// handlePostAdminInit handles POST requests on /users/admin/init
-func (handler *UserHandler) handlePostAdminInit(w http.ResponseWriter, r *http.Request) {
-	var req postAdminInitRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	_, err := govalidator.ValidateStruct(req)
-	if err != nil {
-		httperror.WriteErrorResponse(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	users, err := handler.UserService.UsersByRole(portainer.AdministratorRole)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-	if len(users) == 0 {
-		user := &portainer.User{
-			Username: req.Username,
-			Role:     portainer.AdministratorRole,
-		}
-		user.Password, err = handler.CryptoService.Hash(req.Password)
-		if err != nil {
-			httperror.WriteErrorResponse(w, portainer.ErrCryptoHashFailure, http.StatusBadRequest, handler.Logger)
-			return
-		}
-
-		err = handler.UserService.CreateUser(user)
-		if err != nil {
-			httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-			return
-		}
-	} else {
-		httperror.WriteErrorResponse(w, portainer.ErrAdminAlreadyInitialized, http.StatusConflict, handler.Logger)
-		return
-	}
-}
-
-// handleDeleteUser handles DELETE requests on /users/:id
-func (handler *UserHandler) handleDeleteUser(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	userID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	if userID == 1 {
-		httperror.WriteErrorResponse(w, portainer.ErrCannotRemoveAdmin, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	tokenData, err := security.RetrieveTokenData(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if tokenData.ID == portainer.UserID(userID) {
-		httperror.WriteErrorResponse(w, portainer.ErrAdminCannotRemoveSelf, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	_, err = handler.UserService.User(portainer.UserID(userID))
-
-	if err == portainer.ErrUserNotFound {
-		httperror.WriteErrorResponse(w, err, http.StatusNotFound, handler.Logger)
-		return
-	} else if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.UserService.DeleteUser(portainer.UserID(userID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	err = handler.TeamMembershipService.DeleteTeamMembershipByUserID(portainer.UserID(userID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-// handleGetMemberships handles GET requests on /users/:id/memberships
-func (handler *UserHandler) handleGetMemberships(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	userID, err := strconv.Atoi(id)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	tokenData, err := security.RetrieveTokenData(r)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	if tokenData.Role != portainer.AdministratorRole && tokenData.ID != portainer.UserID(userID) {
-		httperror.WriteErrorResponse(w, portainer.ErrUnauthorized, http.StatusForbidden, handler.Logger)
-		return
-	}
-
-	memberships, err := handler.TeamMembershipService.TeamMembershipsByUserID(portainer.UserID(userID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	encodeJSON(w, memberships, handler.Logger)
-}

api/http/handler/websocket.go

@@ -1,283 +0,0 @@
-package handler
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/tls"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/gorilla/mux"
-	"github.com/gorilla/websocket"
-	"github.com/koding/websocketproxy"
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/crypto"
-	httperror "github.com/portainer/portainer/http/error"
-)
-
-type (
-	// WebSocketHandler represents an HTTP API handler for proxying requests to a web socket.
-	WebSocketHandler struct {
-		*mux.Router
-		Logger             *log.Logger
-		EndpointService    portainer.EndpointService
-		SignatureService   portainer.DigitalSignatureService
-		connectionUpgrader websocket.Upgrader
-	}
-
-	webSocketExecRequestParams struct {
-		execID   string
-		nodeName string
-		endpoint *portainer.Endpoint
-	}
-
-	execStartOperationPayload struct {
-		Tty    bool
-		Detach bool
-	}
-)
-
-// NewWebSocketHandler returns a new instance of WebSocketHandler.
-func NewWebSocketHandler() *WebSocketHandler {
-	h := &WebSocketHandler{
-		Router:             mux.NewRouter(),
-		Logger:             log.New(os.Stderr, "", log.LstdFlags),
-		connectionUpgrader: websocket.Upgrader{},
-	}
-	h.HandleFunc("/websocket/exec", h.handleWebsocketExec).Methods(http.MethodGet)
-	return h
-}
-
-// handleWebsocketExec handles GET requests on /websocket/exec?id=<execID>&endpointId=<endpointID>&nodeName=<nodeName>
-// If the nodeName query parameter is present, the request will be proxied to the underlying agent endpoint.
-// If the nodeName query parameter is not specified, the request will be upgraded to the websocket protocol and
-// an ExecStart operation HTTP request will be created and hijacked.
-func (handler *WebSocketHandler) handleWebsocketExec(w http.ResponseWriter, r *http.Request) {
-	paramExecID := r.FormValue("id")
-	paramEndpointID := r.FormValue("endpointId")
-	if paramExecID == "" || paramEndpointID == "" {
-		httperror.WriteErrorResponse(w, ErrInvalidQueryFormat, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpointID, err := strconv.Atoi(paramEndpointID)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusBadRequest, handler.Logger)
-		return
-	}
-
-	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-
-	params := &webSocketExecRequestParams{
-		endpoint: endpoint,
-		execID:   paramExecID,
-		nodeName: r.FormValue("nodeName"),
-	}
-
-	err = handler.handleRequest(w, r, params)
-	if err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, handler.Logger)
-		return
-	}
-}
-
-func (handler *WebSocketHandler) handleRequest(w http.ResponseWriter, r *http.Request, params *webSocketExecRequestParams) error {
-	if params.nodeName != "" {
-		return handler.proxyWebsocketRequest(w, r, params)
-	}
-
-	websocketConn, err := handler.connectionUpgrader.Upgrade(w, r, nil)
-	if err != nil {
-		return err
-	}
-	defer websocketConn.Close()
-
-	return hijackExecStartOperation(websocketConn, params.endpoint, params.execID)
-}
-
-func (handler *WebSocketHandler) proxyWebsocketRequest(w http.ResponseWriter, r *http.Request, params *webSocketExecRequestParams) error {
-	agentURL, err := url.Parse(params.endpoint.URL)
-	if err != nil {
-		return err
-	}
-
-	agentURL.Scheme = "ws"
-	proxy := websocketproxy.NewProxy(agentURL)
-
-	if params.endpoint.TLSConfig.TLS || params.endpoint.TLSConfig.TLSSkipVerify {
-		agentURL.Scheme = "wss"
-		proxy.Dialer = &websocket.Dialer{
-			TLSClientConfig: &tls.Config{
-				InsecureSkipVerify: params.endpoint.TLSConfig.TLSSkipVerify,
-			},
-		}
-	}
-
-	signature, err := handler.SignatureService.Sign(portainer.PortainerAgentSignatureMessage)
-	if err != nil {
-		return err
-	}
-
-	proxy.Director = func(incoming *http.Request, out http.Header) {
-		out.Set(portainer.PortainerAgentSignatureHeader, signature)
-		out.Set(portainer.PortainerAgentTargetHeader, params.nodeName)
-	}
-
-	r.Header.Del("Origin")
-	proxy.ServeHTTP(w, r)
-
-	return nil
-}
-
-func hijackExecStartOperation(websocketConn *websocket.Conn, endpoint *portainer.Endpoint, execID string) error {
-	dial, err := createDial(endpoint)
-	if err != nil {
-		return err
-	}
-
-	// When we set up a TCP connection for hijack, there could be long periods
-	// of inactivity (a long running command with no output) that in certain
-	// network setups may cause ECONNTIMEOUT, leaving the client in an unknown
-	// state. Setting TCP KeepAlive on the socket connection will prohibit
-	// ECONNTIMEOUT unless the socket connection truly is broken
-	if tcpConn, ok := dial.(*net.TCPConn); ok {
-		tcpConn.SetKeepAlive(true)
-		tcpConn.SetKeepAlivePeriod(30 * time.Second)
-	}
-
-	httpConn := httputil.NewClientConn(dial, nil)
-	defer httpConn.Close()
-
-	execStartRequest, err := createExecStartRequest(execID)
-	if err != nil {
-		return err
-	}
-
-	err = hijackRequest(websocketConn, httpConn, execStartRequest)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func createDial(endpoint *portainer.Endpoint) (net.Conn, error) {
-	url, err := url.Parse(endpoint.URL)
-	if err != nil {
-		return nil, err
-	}
-
-	var host string
-	if url.Scheme == "tcp" {
-		host = url.Host
-	} else if url.Scheme == "unix" {
-		host = url.Path
-	}
-
-	if endpoint.TLSConfig.TLS {
-		tlsConfig, err := crypto.CreateTLSConfiguration(&endpoint.TLSConfig)
-		if err != nil {
-			return nil, err
-		}
-		return tls.Dial(url.Scheme, host, tlsConfig)
-	}
-
-	return net.Dial(url.Scheme, host)
-}
-
-func createExecStartRequest(execID string) (*http.Request, error) {
-	execStartOperationPayload := &execStartOperationPayload{
-		Tty:    true,
-		Detach: false,
-	}
-
-	encodedBody := bytes.NewBuffer(nil)
-	err := json.NewEncoder(encodedBody).Encode(execStartOperationPayload)
-	if err != nil {
-		return nil, err
-	}
-
-	request, err := http.NewRequest("POST", "/exec/"+execID+"/start", encodedBody)
-	if err != nil {
-		return nil, err
-	}
-
-	request.Header.Set("Content-Type", "application/json")
-	request.Header.Set("Connection", "Upgrade")
-	request.Header.Set("Upgrade", "tcp")
-
-	return request, nil
-}
-
-func hijackRequest(websocketConn *websocket.Conn, httpConn *httputil.ClientConn, request *http.Request) error {
-	// Server hijacks the connection, error 'connection closed' expected
-	resp, err := httpConn.Do(request)
-	if err != httputil.ErrPersistEOF {
-		if err != nil {
-			return err
-		}
-		if resp.StatusCode != http.StatusSwitchingProtocols {
-			resp.Body.Close()
-			return fmt.Errorf("unable to upgrade to tcp, received %d", resp.StatusCode)
-		}
-	}
-
-	tcpConn, brw := httpConn.Hijack()
-	defer tcpConn.Close()
-
-	errorChan := make(chan error, 1)
-	go streamFromTCPConnToWebsocketConn(websocketConn, brw, errorChan)
-	go streamFromWebsocketConnToTCPConn(websocketConn, tcpConn, errorChan)
-
-	err = <-errorChan
-	if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseNoStatusReceived) {
-		return err
-	}
-
-	return nil
-}
-
-func streamFromWebsocketConnToTCPConn(websocketConn *websocket.Conn, tcpConn net.Conn, errorChan chan error) {
-	for {
-		_, in, err := websocketConn.ReadMessage()
-		if err != nil {
-			errorChan <- err
-			break
-		}
-
-		_, err = tcpConn.Write(in)
-		if err != nil {
-			errorChan <- err
-			break
-		}
-	}
-}
-
-func streamFromTCPConnToWebsocketConn(websocketConn *websocket.Conn, br *bufio.Reader, errorChan chan error) {
-	for {
-		out := make([]byte, 1024)
-		_, err := br.Read(out)
-		if err != nil {
-			errorChan <- err
-			break
-		}
-
-		err = websocketConn.WriteMessage(websocket.TextMessage, out)
-		if err != nil {
-			errorChan <- err
-			break
-		}
-	}
-}

api/http/proxy/access_control.go

@@ -1,161 +0,0 @@
-package proxy
-
-import "github.com/portainer/portainer"
-
-type (
-	// ExtendedStack represents a stack combined with its associated access control
-	ExtendedStack struct {
-		portainer.Stack
-		ResourceControl portainer.ResourceControl `json:"ResourceControl"`
-	}
-)
-
-// applyResourceAccessControl returns an optionally decorated object as the first return value and the
-// access level for the user (granted or denied) as the second return value.
-// It will retrieve an identifier from the labels object. If an identifier exists, it will check for
-// an existing resource control associated to it.
-// Returns a decorated object and authorized access (true) when a resource control is found and the user can access the resource.
-// Returns the original object and authorized access (true) when no resource control is found.
-// Returns the original object and denied access (false) when a resource control is found and the user cannot access the resource.
-func applyResourceAccessControlFromLabel(labelsObject, resourceObject map[string]interface{}, labelIdentifier string,
-	context *restrictedOperationContext) (map[string]interface{}, bool) {
-
-	if labelsObject != nil && labelsObject[labelIdentifier] != nil {
-		resourceIdentifier := labelsObject[labelIdentifier].(string)
-		return applyResourceAccessControl(resourceObject, resourceIdentifier, context)
-	}
-	return resourceObject, true
-}
-
-// applyResourceAccessControl returns an optionally decorated object as the first return value and the
-// access level for the user (granted or denied) as the second return value.
-// Returns a decorated object and authorized access (true) when a resource control is found to the specified resource
-// identifier and the user can access the resource.
-// Returns the original object and authorized access (true) when no resource control is found for the specified
-// resource identifier.
-// Returns the original object and denied access (false) when a resource control is associated to the resource
-// and the user cannot access the resource.
-func applyResourceAccessControl(resourceObject map[string]interface{}, resourceIdentifier string,
-	context *restrictedOperationContext) (map[string]interface{}, bool) {
-
-	authorizedAccess := true
-
-	resourceControl := getResourceControlByResourceID(resourceIdentifier, context.resourceControls)
-	if resourceControl != nil {
-		if context.isAdmin || canUserAccessResource(context.userID, context.userTeamIDs, resourceControl) {
-			resourceObject = decorateObject(resourceObject, resourceControl)
-		} else {
-			authorizedAccess = false
-		}
-	}
-
-	return resourceObject, authorizedAccess
-}
-
-// decorateResourceWithAccessControlFromLabel will retrieve an identifier from the labels object. If an identifier exists,
-// it will check for an existing resource control associated to it. If a resource control is found, the resource object will be
-// decorated. If no identifier can be found in the labels or no resource control is associated to the identifier, the resource
-// object will not be changed.
-func decorateResourceWithAccessControlFromLabel(labelsObject, resourceObject map[string]interface{}, labelIdentifier string,
-	resourceControls []portainer.ResourceControl) map[string]interface{} {
-
-	if labelsObject != nil && labelsObject[labelIdentifier] != nil {
-		resourceIdentifier := labelsObject[labelIdentifier].(string)
-		resourceObject = decorateResourceWithAccessControl(resourceObject, resourceIdentifier, resourceControls)
-	}
-
-	return resourceObject
-}
-
-// decorateResourceWithAccessControl will check if a resource control is associated to the specified resource identifier.
-// If a resource control is found, the resource object will be decorated, otherwise it will not be changed.
-func decorateResourceWithAccessControl(resourceObject map[string]interface{}, resourceIdentifier string,
-	resourceControls []portainer.ResourceControl) map[string]interface{} {
-
-	resourceControl := getResourceControlByResourceID(resourceIdentifier, resourceControls)
-	if resourceControl != nil {
-		return decorateObject(resourceObject, resourceControl)
-	}
-	return resourceObject
-}
-
-func canUserAccessResource(userID portainer.UserID, userTeamIDs []portainer.TeamID, resourceControl *portainer.ResourceControl) bool {
-	for _, authorizedUserAccess := range resourceControl.UserAccesses {
-		if userID == authorizedUserAccess.UserID {
-			return true
-		}
-	}
-
-	for _, authorizedTeamAccess := range resourceControl.TeamAccesses {
-		for _, userTeamID := range userTeamIDs {
-			if userTeamID == authorizedTeamAccess.TeamID {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func decorateObject(object map[string]interface{}, resourceControl *portainer.ResourceControl) map[string]interface{} {
-	if object["Portainer"] == nil {
-		object["Portainer"] = make(map[string]interface{})
-	}
-
-	portainerMetadata := object["Portainer"].(map[string]interface{})
-	portainerMetadata["ResourceControl"] = resourceControl
-	return object
-}
-
-func getResourceControlByResourceID(resourceID string, resourceControls []portainer.ResourceControl) *portainer.ResourceControl {
-	for _, resourceControl := range resourceControls {
-		if resourceID == resourceControl.ResourceID {
-			return &resourceControl
-		}
-		for _, subResourceID := range resourceControl.SubResourceIDs {
-			if resourceID == subResourceID {
-				return &resourceControl
-			}
-		}
-	}
-	return nil
-}
-
-// CanAccessStack checks if a user can access a stack
-func CanAccessStack(stack *portainer.Stack, resourceControl *portainer.ResourceControl, userID portainer.UserID, memberships []portainer.TeamMembership) bool {
-	userTeamIDs := make([]portainer.TeamID, 0)
-	for _, membership := range memberships {
-		userTeamIDs = append(userTeamIDs, membership.TeamID)
-	}
-
-	if canUserAccessResource(userID, userTeamIDs, resourceControl) {
-		return true
-	}
-
-	return false
-}
-
-// FilterStacks filters stacks based on user role and resource controls.
-func FilterStacks(stacks []portainer.Stack, resourceControls []portainer.ResourceControl, isAdmin bool,
-	userID portainer.UserID, memberships []portainer.TeamMembership) []ExtendedStack {
-
-	filteredStacks := make([]ExtendedStack, 0)
-
-	userTeamIDs := make([]portainer.TeamID, 0)
-	for _, membership := range memberships {
-		userTeamIDs = append(userTeamIDs, membership.TeamID)
-	}
-
-	for _, stack := range stacks {
-		extendedStack := ExtendedStack{stack, portainer.ResourceControl{}}
-		resourceControl := getResourceControlByResourceID(stack.Name, resourceControls)
-		if resourceControl == nil {
-			filteredStacks = append(filteredStacks, extendedStack)
-		} else if resourceControl != nil && (isAdmin || canUserAccessResource(userID, userTeamIDs, resourceControl)) {
-			extendedStack.ResourceControl = *resourceControl
-			filteredStacks = append(filteredStacks, extendedStack)
-		}
-	}
-
-	return filteredStacks
-}

api/http/proxy/build.go

@@ -1,56 +0,0 @@
-package proxy
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	"strings"
-
-	"github.com/portainer/portainer/archive"
-)
-
-type postDockerfileRequest struct {
-	Content string
-}
-
-// buildOperation inspects the "Content-Type" header to determine if it needs to alter the request.
-// If the value of the header is empty, it means that a Dockerfile is posted via upload, the function
-// will extract the file content from the request body, tar it, and rewrite the body.
-// If the value of the header contains "application/json", it means that the content of a Dockerfile is posted
-// in the request payload as JSON, the function will create a new file called Dockerfile inside a tar archive and
-// rewrite the body of the request.
-// In any other case, it will leave the request unaltered.
-func buildOperation(request *http.Request) error {
-	contentTypeHeader := request.Header.Get("Content-Type")
-	if contentTypeHeader != "" && !strings.Contains(contentTypeHeader, "application/json") {
-		return nil
-	}
-
-	var dockerfileContent []byte
-
-	if contentTypeHeader == "" {
-		body, err := ioutil.ReadAll(request.Body)
-		if err != nil {
-			return err
-		}
-		dockerfileContent = body
-	} else {
-		var req postDockerfileRequest
-		if err := json.NewDecoder(request.Body).Decode(&req); err != nil {
-			return err
-		}
-		dockerfileContent = []byte(req.Content)
-	}
-
-	buffer, err := archive.TarFileInBuffer(dockerfileContent, "Dockerfile")
-	if err != nil {
-		return err
-	}
-
-	request.Body = ioutil.NopCloser(bytes.NewReader(buffer))
-	request.ContentLength = int64(len(buffer))
-	request.Header.Set("Content-Type", "application/x-tar")
-
-	return nil
-}

api/http/proxy/configs.go

@@ -1,107 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrDockerConfigIdentifierNotFound defines an error raised when Portainer is unable to find a config identifier
-	ErrDockerConfigIdentifierNotFound = portainer.Error("Docker config identifier not found")
-	configIdentifier                  = "ID"
-)
-
-// configListOperation extracts the response as a JSON object, loop through the configs array
-// decorate and/or filter the configs based on resource controls before rewriting the response
-func configListOperation(response *http.Response, executor *operationExecutor) error {
-	var err error
-
-	// ConfigList response is a JSON array
-	// https://docs.docker.com/engine/api/v1.30/#operation/ConfigList
-	responseArray, err := getResponseAsJSONArray(response)
-	if err != nil {
-		return err
-	}
-
-	if executor.operationContext.isAdmin {
-		responseArray, err = decorateConfigList(responseArray, executor.operationContext.resourceControls)
-	} else {
-		responseArray, err = filterConfigList(responseArray, executor.operationContext)
-	}
-	if err != nil {
-		return err
-	}
-
-	return rewriteResponse(response, responseArray, http.StatusOK)
-}
-
-// configInspectOperation extracts the response as a JSON object, verify that the user
-// has access to the config based on resource control (check are done based on the configID and optional Swarm service ID)
-// and either rewrite an access denied response or a decorated config.
-func configInspectOperation(response *http.Response, executor *operationExecutor) error {
-	// ConfigInspect response is a JSON object
-	// https://docs.docker.com/engine/api/v1.30/#operation/ConfigInspect
-	responseObject, err := getResponseAsJSONOBject(response)
-	if err != nil {
-		return err
-	}
-
-	if responseObject[configIdentifier] == nil {
-		return ErrDockerConfigIdentifierNotFound
-	}
-
-	configID := responseObject[configIdentifier].(string)
-	responseObject, access := applyResourceAccessControl(responseObject, configID, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	return rewriteResponse(response, responseObject, http.StatusOK)
-}
-
-// decorateConfigList loops through all configs and decorates any config with an existing resource control.
-// Resource controls checks are based on: resource identifier.
-// Config object schema reference: https://docs.docker.com/engine/api/v1.30/#operation/ConfigList
-func decorateConfigList(configData []interface{}, resourceControls []portainer.ResourceControl) ([]interface{}, error) {
-	decoratedConfigData := make([]interface{}, 0)
-
-	for _, config := range configData {
-
-		configObject := config.(map[string]interface{})
-		if configObject[configIdentifier] == nil {
-			return nil, ErrDockerConfigIdentifierNotFound
-		}
-
-		configID := configObject[configIdentifier].(string)
-		configObject = decorateResourceWithAccessControl(configObject, configID, resourceControls)
-
-		decoratedConfigData = append(decoratedConfigData, configObject)
-	}
-
-	return decoratedConfigData, nil
-}
-
-// filterConfigList loops through all configs and filters public configs (no associated resource control)
-// as well as authorized configs (access granted to the user based on existing resource control).
-// Authorized configs are decorated during the process.
-// Resource controls checks are based on: resource identifier.
-// Config object schema reference: https://docs.docker.com/engine/api/v1.30/#operation/ConfigList
-func filterConfigList(configData []interface{}, context *restrictedOperationContext) ([]interface{}, error) {
-	filteredConfigData := make([]interface{}, 0)
-
-	for _, config := range configData {
-		configObject := config.(map[string]interface{})
-		if configObject[configIdentifier] == nil {
-			return nil, ErrDockerConfigIdentifierNotFound
-		}
-
-		configID := configObject[configIdentifier].(string)
-		configObject, access := applyResourceAccessControl(configObject, configID, context)
-		if access {
-			filteredConfigData = append(filteredConfigData, configObject)
-		}
-	}
-
-	return filteredConfigData, nil
-}

api/http/proxy/containers.go

@@ -1,193 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrDockerContainerIdentifierNotFound defines an error raised when Portainer is unable to find a container identifier
-	ErrDockerContainerIdentifierNotFound = portainer.Error("Docker container identifier not found")
-	containerIdentifier                  = "Id"
-	containerLabelForServiceIdentifier   = "com.docker.swarm.service.id"
-	containerLabelForStackIdentifier     = "com.docker.stack.namespace"
-)
-
-// containerListOperation extracts the response as a JSON object, loop through the containers array
-// decorate and/or filter the containers based on resource controls before rewriting the response
-func containerListOperation(response *http.Response, executor *operationExecutor) error {
-	var err error
-	// ContainerList response is a JSON array
-	// https://docs.docker.com/engine/api/v1.28/#operation/ContainerList
-	responseArray, err := getResponseAsJSONArray(response)
-	if err != nil {
-		return err
-	}
-
-	if executor.operationContext.isAdmin {
-		responseArray, err = decorateContainerList(responseArray, executor.operationContext.resourceControls)
-	} else {
-		responseArray, err = filterContainerList(responseArray, executor.operationContext)
-	}
-	if err != nil {
-		return err
-	}
-
-	if executor.labelBlackList != nil {
-		responseArray, err = filterContainersWithBlackListedLabels(responseArray, executor.labelBlackList)
-		if err != nil {
-			return err
-		}
-	}
-
-	return rewriteResponse(response, responseArray, http.StatusOK)
-}
-
-// containerInspectOperation extracts the response as a JSON object, verify that the user
-// has access to the container based on resource control (check are done based on the containerID and optional Swarm service ID)
-// and either rewrite an access denied response or a decorated container.
-func containerInspectOperation(response *http.Response, executor *operationExecutor) error {
-	// ContainerInspect response is a JSON object
-	// https://docs.docker.com/engine/api/v1.28/#operation/ContainerInspect
-	responseObject, err := getResponseAsJSONOBject(response)
-	if err != nil {
-		return err
-	}
-
-	if responseObject[containerIdentifier] == nil {
-		return ErrDockerContainerIdentifierNotFound
-	}
-
-	containerID := responseObject[containerIdentifier].(string)
-	responseObject, access := applyResourceAccessControl(responseObject, containerID, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	containerLabels := extractContainerLabelsFromContainerInspectObject(responseObject)
-	responseObject, access = applyResourceAccessControlFromLabel(containerLabels, responseObject, containerLabelForServiceIdentifier, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	responseObject, access = applyResourceAccessControlFromLabel(containerLabels, responseObject, containerLabelForStackIdentifier, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	return rewriteResponse(response, responseObject, http.StatusOK)
-}
-
-// extractContainerLabelsFromContainerInspectObject retrieve the Labels of the container if present.
-// Container schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ContainerInspect
-func extractContainerLabelsFromContainerInspectObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Config.Labels
-	containerConfigObject := extractJSONField(responseObject, "Config")
-	if containerConfigObject != nil {
-		containerLabelsObject := extractJSONField(containerConfigObject, "Labels")
-		return containerLabelsObject
-	}
-	return nil
-}
-
-// extractContainerLabelsFromContainerListObject retrieve the Labels of the container if present.
-// Container schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ContainerList
-func extractContainerLabelsFromContainerListObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Labels
-	containerLabelsObject := extractJSONField(responseObject, "Labels")
-	return containerLabelsObject
-}
-
-// decorateContainerList loops through all containers and decorates any container with an existing resource control.
-// Resource controls checks are based on: resource identifier, service identifier (from label), stack identifier (from label).
-// Container object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ContainerList
-func decorateContainerList(containerData []interface{}, resourceControls []portainer.ResourceControl) ([]interface{}, error) {
-	decoratedContainerData := make([]interface{}, 0)
-
-	for _, container := range containerData {
-
-		containerObject := container.(map[string]interface{})
-		if containerObject[containerIdentifier] == nil {
-			return nil, ErrDockerContainerIdentifierNotFound
-		}
-
-		containerID := containerObject[containerIdentifier].(string)
-		containerObject = decorateResourceWithAccessControl(containerObject, containerID, resourceControls)
-
-		containerLabels := extractContainerLabelsFromContainerListObject(containerObject)
-		containerObject = decorateResourceWithAccessControlFromLabel(containerLabels, containerObject, containerLabelForServiceIdentifier, resourceControls)
-		containerObject = decorateResourceWithAccessControlFromLabel(containerLabels, containerObject, containerLabelForStackIdentifier, resourceControls)
-
-		decoratedContainerData = append(decoratedContainerData, containerObject)
-	}
-
-	return decoratedContainerData, nil
-}
-
-// filterContainerList loops through all containers and filters public containers (no associated resource control)
-// as well as authorized containers (access granted to the user based on existing resource control).
-// Authorized containers are decorated during the process.
-// Resource controls checks are based on: resource identifier, service identifier (from label), stack identifier (from label).
-// Container object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ContainerList
-func filterContainerList(containerData []interface{}, context *restrictedOperationContext) ([]interface{}, error) {
-	filteredContainerData := make([]interface{}, 0)
-
-	for _, container := range containerData {
-		containerObject := container.(map[string]interface{})
-		if containerObject[containerIdentifier] == nil {
-			return nil, ErrDockerContainerIdentifierNotFound
-		}
-
-		containerID := containerObject[containerIdentifier].(string)
-		containerObject, access := applyResourceAccessControl(containerObject, containerID, context)
-		if access {
-			containerLabels := extractContainerLabelsFromContainerListObject(containerObject)
-			containerObject, access = applyResourceAccessControlFromLabel(containerLabels, containerObject, containerLabelForServiceIdentifier, context)
-			if access {
-				containerObject, access = applyResourceAccessControlFromLabel(containerLabels, containerObject, containerLabelForStackIdentifier, context)
-				if access {
-					filteredContainerData = append(filteredContainerData, containerObject)
-				}
-			}
-		}
-	}
-
-	return filteredContainerData, nil
-}
-
-// filterContainersWithLabels loops through a list of containers, and filters containers that do not contains
-// any labels in the labels black list.
-func filterContainersWithBlackListedLabels(containerData []interface{}, labelBlackList []portainer.Pair) ([]interface{}, error) {
-	filteredContainerData := make([]interface{}, 0)
-
-	for _, container := range containerData {
-		containerObject := container.(map[string]interface{})
-
-		containerLabels := extractContainerLabelsFromContainerListObject(containerObject)
-		if containerLabels != nil {
-			if !containerHasBlackListedLabel(containerLabels, labelBlackList) {
-				filteredContainerData = append(filteredContainerData, containerObject)
-			}
-		} else {
-			filteredContainerData = append(filteredContainerData, containerObject)
-		}
-	}
-
-	return filteredContainerData, nil
-}
-
-func containerHasBlackListedLabel(containerLabels map[string]interface{}, labelBlackList []portainer.Pair) bool {
-	for key, value := range containerLabels {
-		labelName := key
-		labelValue := value.(string)
-
-		for _, blackListedLabel := range labelBlackList {
-			if blackListedLabel.Name == labelName && blackListedLabel.Value == labelValue {
-				return true
-			}
-		}
-	}
-
-	return false
-}

api/http/proxy/factory.go

@@ -1,87 +0,0 @@
-package proxy
-
-import (
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/crypto"
-)
-
-// proxyFactory is a factory to create reverse proxies to Docker endpoints
-type proxyFactory struct {
-	ResourceControlService portainer.ResourceControlService
-	TeamMembershipService  portainer.TeamMembershipService
-	SettingsService        portainer.SettingsService
-	RegistryService        portainer.RegistryService
-	DockerHubService       portainer.DockerHubService
-	SignatureService       portainer.DigitalSignatureService
-}
-
-func (factory *proxyFactory) newExtensionHTTPPRoxy(u *url.URL) http.Handler {
-	u.Scheme = "http"
-	return newSingleHostReverseProxyWithHostHeader(u)
-}
-
-func (factory *proxyFactory) newDockerHTTPSProxy(u *url.URL, tlsConfig *portainer.TLSConfiguration, enableSignature bool) (http.Handler, error) {
-	u.Scheme = "https"
-
-	proxy := factory.createDockerReverseProxy(u, enableSignature)
-	config, err := crypto.CreateTLSConfiguration(tlsConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	proxy.Transport.(*proxyTransport).dockerTransport.TLSClientConfig = config
-	return proxy, nil
-}
-
-func (factory *proxyFactory) newDockerHTTPProxy(u *url.URL, enableSignature bool) http.Handler {
-	u.Scheme = "http"
-	return factory.createDockerReverseProxy(u, enableSignature)
-}
-
-func (factory *proxyFactory) newDockerSocketProxy(path string) http.Handler {
-	proxy := &socketProxy{}
-	transport := &proxyTransport{
-		enableSignature:        false,
-		ResourceControlService: factory.ResourceControlService,
-		TeamMembershipService:  factory.TeamMembershipService,
-		SettingsService:        factory.SettingsService,
-		RegistryService:        factory.RegistryService,
-		DockerHubService:       factory.DockerHubService,
-		dockerTransport:        newSocketTransport(path),
-	}
-	proxy.Transport = transport
-	return proxy
-}
-
-func (factory *proxyFactory) createDockerReverseProxy(u *url.URL, enableSignature bool) *httputil.ReverseProxy {
-	proxy := newSingleHostReverseProxyWithHostHeader(u)
-	transport := &proxyTransport{
-		enableSignature:        enableSignature,
-		ResourceControlService: factory.ResourceControlService,
-		TeamMembershipService:  factory.TeamMembershipService,
-		SettingsService:        factory.SettingsService,
-		RegistryService:        factory.RegistryService,
-		DockerHubService:       factory.DockerHubService,
-		dockerTransport:        &http.Transport{},
-	}
-
-	if enableSignature {
-		transport.SignatureService = factory.SignatureService
-	}
-
-	proxy.Transport = transport
-	return proxy
-}
-
-func newSocketTransport(socketPath string) *http.Transport {
-	return &http.Transport{
-		Dial: func(proto, addr string) (conn net.Conn, err error) {
-			return net.Dial("unix", socketPath)
-		},
-	}
-}

api/http/proxy/manager.go

@@ -1,123 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/orcaman/concurrent-map"
-	"github.com/portainer/portainer"
-)
-
-type (
-	// Manager represents a service used to manage Docker proxies.
-	Manager struct {
-		proxyFactory     *proxyFactory
-		proxies          cmap.ConcurrentMap
-		extensionProxies cmap.ConcurrentMap
-	}
-
-	// ManagerParams represents the required parameters to create a new Manager instance.
-	ManagerParams struct {
-		ResourceControlService portainer.ResourceControlService
-		TeamMembershipService  portainer.TeamMembershipService
-		SettingsService        portainer.SettingsService
-		RegistryService        portainer.RegistryService
-		DockerHubService       portainer.DockerHubService
-		SignatureService       portainer.DigitalSignatureService
-	}
-)
-
-// NewManager initializes a new proxy Service
-func NewManager(parameters *ManagerParams) *Manager {
-	return &Manager{
-		proxies:          cmap.New(),
-		extensionProxies: cmap.New(),
-		proxyFactory: &proxyFactory{
-			ResourceControlService: parameters.ResourceControlService,
-			TeamMembershipService:  parameters.TeamMembershipService,
-			SettingsService:        parameters.SettingsService,
-			RegistryService:        parameters.RegistryService,
-			DockerHubService:       parameters.DockerHubService,
-			SignatureService:       parameters.SignatureService,
-		},
-	}
-}
-
-// CreateAndRegisterProxy creates a new HTTP reverse proxy and adds it to the registered proxies.
-// It can also be used to create a new HTTP reverse proxy and replace an already registered proxy.
-func (manager *Manager) CreateAndRegisterProxy(endpoint *portainer.Endpoint) (http.Handler, error) {
-	var proxy http.Handler
-
-	endpointURL, err := url.Parse(endpoint.URL)
-	if err != nil {
-		return nil, err
-	}
-
-	enableSignature := false
-	if endpoint.Type == portainer.AgentOnDockerEnvironment {
-		enableSignature = true
-	}
-
-	if endpointURL.Scheme == "tcp" {
-		if endpoint.TLSConfig.TLS || endpoint.TLSConfig.TLSSkipVerify {
-			proxy, err = manager.proxyFactory.newDockerHTTPSProxy(endpointURL, &endpoint.TLSConfig, enableSignature)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			proxy = manager.proxyFactory.newDockerHTTPProxy(endpointURL, enableSignature)
-		}
-	} else {
-		// Assume unix:// scheme
-		proxy = manager.proxyFactory.newDockerSocketProxy(endpointURL.Path)
-	}
-
-	manager.proxies.Set(string(endpoint.ID), proxy)
-	return proxy, nil
-}
-
-// GetProxy returns the proxy associated to a key
-func (manager *Manager) GetProxy(key string) http.Handler {
-	proxy, ok := manager.proxies.Get(key)
-	if !ok {
-		return nil
-	}
-	return proxy.(http.Handler)
-}
-
-// DeleteProxy deletes the proxy associated to a key
-func (manager *Manager) DeleteProxy(key string) {
-	manager.proxies.Remove(key)
-}
-
-// CreateAndRegisterExtensionProxy creates a new HTTP reverse proxy for an extension and adds it to the registered proxies.
-func (manager *Manager) CreateAndRegisterExtensionProxy(key, extensionAPIURL string) (http.Handler, error) {
-
-	extensionURL, err := url.Parse(extensionAPIURL)
-	if err != nil {
-		return nil, err
-	}
-
-	proxy := manager.proxyFactory.newExtensionHTTPPRoxy(extensionURL)
-	manager.extensionProxies.Set(key, proxy)
-	return proxy, nil
-}
-
-// GetExtensionProxy returns the extension proxy associated to a key
-func (manager *Manager) GetExtensionProxy(key string) http.Handler {
-	proxy, ok := manager.extensionProxies.Get(key)
-	if !ok {
-		return nil
-	}
-	return proxy.(http.Handler)
-}
-
-// DeleteExtensionProxies deletes all the extension proxies associated to a key
-func (manager *Manager) DeleteExtensionProxies(key string) {
-	for _, k := range manager.extensionProxies.Keys() {
-		if strings.Contains(k, key+"_") {
-			manager.extensionProxies.Remove(k)
-		}
-	}
-}

api/http/proxy/networks.go

@@ -1,134 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrDockerNetworkIdentifierNotFound defines an error raised when Portainer is unable to find a network identifier
-	ErrDockerNetworkIdentifierNotFound = portainer.Error("Docker network identifier not found")
-	networkIdentifier                  = "Id"
-	networkLabelForStackIdentifier     = "com.docker.stack.namespace"
-)
-
-// networkListOperation extracts the response as a JSON object, loop through the networks array
-// decorate and/or filter the networks based on resource controls before rewriting the response
-func networkListOperation(response *http.Response, executor *operationExecutor) error {
-	var err error
-	// NetworkList response is a JSON array
-	// https://docs.docker.com/engine/api/v1.28/#operation/NetworkList
-	responseArray, err := getResponseAsJSONArray(response)
-	if err != nil {
-		return err
-	}
-
-	if executor.operationContext.isAdmin {
-		responseArray, err = decorateNetworkList(responseArray, executor.operationContext.resourceControls)
-	} else {
-		responseArray, err = filterNetworkList(responseArray, executor.operationContext)
-	}
-	if err != nil {
-		return err
-	}
-
-	return rewriteResponse(response, responseArray, http.StatusOK)
-}
-
-// networkInspectOperation extracts the response as a JSON object, verify that the user
-// has access to the network based on resource control and either rewrite an access denied response
-// or a decorated network.
-func networkInspectOperation(response *http.Response, executor *operationExecutor) error {
-	// NetworkInspect response is a JSON object
-	// https://docs.docker.com/engine/api/v1.28/#operation/NetworkInspect
-	responseObject, err := getResponseAsJSONOBject(response)
-	if err != nil {
-		return err
-	}
-
-	if responseObject[networkIdentifier] == nil {
-		return ErrDockerNetworkIdentifierNotFound
-	}
-
-	networkID := responseObject[networkIdentifier].(string)
-	responseObject, access := applyResourceAccessControl(responseObject, networkID, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	networkLabels := extractNetworkLabelsFromNetworkInspectObject(responseObject)
-	responseObject, access = applyResourceAccessControlFromLabel(networkLabels, responseObject, networkLabelForStackIdentifier, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	return rewriteResponse(response, responseObject, http.StatusOK)
-}
-
-// extractNetworkLabelsFromNetworkInspectObject retrieve the Labels of the network if present.
-// Container schema reference: https://docs.docker.com/engine/api/v1.28/#operation/NetworkInspect
-func extractNetworkLabelsFromNetworkInspectObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Labels
-	return extractJSONField(responseObject, "Labels")
-}
-
-// extractNetworkLabelsFromNetworkListObject retrieve the Labels of the network if present.
-// Network schema reference: https://docs.docker.com/engine/api/v1.28/#operation/NetworkList
-func extractNetworkLabelsFromNetworkListObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Labels
-	return extractJSONField(responseObject, "Labels")
-}
-
-// decorateNetworkList loops through all networks and decorates any network with an existing resource control.
-// Resource controls checks are based on: resource identifier, stack identifier (from label).
-// Network object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/NetworkList
-func decorateNetworkList(networkData []interface{}, resourceControls []portainer.ResourceControl) ([]interface{}, error) {
-	decoratedNetworkData := make([]interface{}, 0)
-
-	for _, network := range networkData {
-
-		networkObject := network.(map[string]interface{})
-		if networkObject[networkIdentifier] == nil {
-			return nil, ErrDockerNetworkIdentifierNotFound
-		}
-
-		networkID := networkObject[networkIdentifier].(string)
-		networkObject = decorateResourceWithAccessControl(networkObject, networkID, resourceControls)
-
-		networkLabels := extractNetworkLabelsFromNetworkListObject(networkObject)
-		networkObject = decorateResourceWithAccessControlFromLabel(networkLabels, networkObject, networkLabelForStackIdentifier, resourceControls)
-
-		decoratedNetworkData = append(decoratedNetworkData, networkObject)
-	}
-
-	return decoratedNetworkData, nil
-}
-
-// filterNetworkList loops through all networks and filters public networks (no associated resource control)
-// as well as authorized networks (access granted to the user based on existing resource control).
-// Authorized networks are decorated during the process.
-// Resource controls checks are based on: resource identifier, stack identifier (from label).
-// Network object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/NetworkList
-func filterNetworkList(networkData []interface{}, context *restrictedOperationContext) ([]interface{}, error) {
-	filteredNetworkData := make([]interface{}, 0)
-
-	for _, network := range networkData {
-		networkObject := network.(map[string]interface{})
-		if networkObject[networkIdentifier] == nil {
-			return nil, ErrDockerNetworkIdentifierNotFound
-		}
-
-		networkID := networkObject[networkIdentifier].(string)
-		networkObject, access := applyResourceAccessControl(networkObject, networkID, context)
-		if access {
-			networkLabels := extractNetworkLabelsFromNetworkListObject(networkObject)
-			networkObject, access = applyResourceAccessControlFromLabel(networkLabels, networkObject, networkLabelForStackIdentifier, context)
-			if access {
-				filteredNetworkData = append(filteredNetworkData, networkObject)
-			}
-		}
-	}
-
-	return filteredNetworkData, nil
-}

api/http/proxy/registry.go

@@ -1,37 +0,0 @@
-package proxy
-
-import (
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/http/security"
-)
-
-func createRegistryAuthenticationHeader(serverAddress string, accessContext *registryAccessContext) *registryAuthenticationHeader {
-	var authenticationHeader *registryAuthenticationHeader
-
-	if serverAddress == "" {
-		authenticationHeader = &registryAuthenticationHeader{
-			Username:      accessContext.dockerHub.Username,
-			Password:      accessContext.dockerHub.Password,
-			Serveraddress: "docker.io",
-		}
-	} else {
-		var matchingRegistry *portainer.Registry
-		for _, registry := range accessContext.registries {
-			if registry.URL == serverAddress &&
-				(accessContext.isAdmin || (!accessContext.isAdmin && security.AuthorizedRegistryAccess(&registry, accessContext.userID, accessContext.teamMemberships))) {
-				matchingRegistry = &registry
-				break
-			}
-		}
-
-		if matchingRegistry != nil {
-			authenticationHeader = &registryAuthenticationHeader{
-				Username:      matchingRegistry.Username,
-				Password:      matchingRegistry.Password,
-				Serveraddress: matchingRegistry.URL,
-			}
-		}
-	}
-
-	return authenticationHeader
-}

api/http/proxy/response.go

@@ -1,106 +0,0 @@
-package proxy
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	"strconv"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrEmptyResponseBody defines an error raised when portainer excepts to parse the body of a HTTP response and there is nothing to parse
-	ErrEmptyResponseBody = portainer.Error("Empty response body")
-	// ErrInvalidResponseContent defines an error raised when Portainer excepts a JSON array and get something else.
-	ErrInvalidResponseContent = portainer.Error("Invalid Docker response")
-)
-
-func extractJSONField(jsonObject map[string]interface{}, key string) map[string]interface{} {
-	object := jsonObject[key]
-	if object != nil {
-		return object.(map[string]interface{})
-	}
-	return nil
-}
-
-func getResponseAsJSONOBject(response *http.Response) (map[string]interface{}, error) {
-	responseData, err := getResponseBodyAsGenericJSON(response)
-	if err != nil {
-		return nil, err
-	}
-
-	responseObject := responseData.(map[string]interface{})
-	return responseObject, nil
-}
-
-func getResponseAsJSONArray(response *http.Response) ([]interface{}, error) {
-	responseData, err := getResponseBodyAsGenericJSON(response)
-	if err != nil {
-		return nil, err
-	}
-
-	switch responseObject := responseData.(type) {
-	case []interface{}:
-		return responseObject, nil
-	case map[string]interface{}:
-		if responseObject["message"] != nil {
-			return nil, portainer.Error(responseObject["message"].(string))
-		}
-		return nil, ErrInvalidResponseContent
-	default:
-		return nil, ErrInvalidResponseContent
-	}
-}
-
-func getResponseBodyAsGenericJSON(response *http.Response) (interface{}, error) {
-	var data interface{}
-	if response.Body != nil {
-		body, err := ioutil.ReadAll(response.Body)
-		if err != nil {
-			return nil, err
-		}
-
-		err = response.Body.Close()
-		if err != nil {
-			return nil, err
-		}
-
-		err = json.Unmarshal(body, &data)
-		if err != nil {
-			return nil, err
-		}
-
-		return data, nil
-	}
-	return nil, ErrEmptyResponseBody
-}
-
-func writeAccessDeniedResponse() (*http.Response, error) {
-	response := &http.Response{}
-	err := rewriteResponse(response, portainer.ErrResourceAccessDenied, http.StatusForbidden)
-	return response, err
-}
-
-func rewriteAccessDeniedResponse(response *http.Response) error {
-	return rewriteResponse(response, portainer.ErrResourceAccessDenied, http.StatusForbidden)
-}
-
-func rewriteResponse(response *http.Response, newResponseData interface{}, statusCode int) error {
-	jsonData, err := json.Marshal(newResponseData)
-	if err != nil {
-		return err
-	}
-	body := ioutil.NopCloser(bytes.NewReader(jsonData))
-	response.StatusCode = statusCode
-	response.Body = body
-	response.ContentLength = int64(len(jsonData))
-
-	if response.Header == nil {
-		response.Header = make(http.Header)
-	}
-	response.Header.Set("Content-Length", strconv.Itoa(len(jsonData)))
-
-	return nil
-}

api/http/proxy/reverse_proxy.go

@@ -1,46 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"strings"
-)
-
-// NewSingleHostReverseProxyWithHostHeader is based on NewSingleHostReverseProxy
-// from golang.org/src/net/http/httputil/reverseproxy.go and merely sets the Host
-// HTTP header, which NewSingleHostReverseProxy deliberately preserves.
-func newSingleHostReverseProxyWithHostHeader(target *url.URL) *httputil.ReverseProxy {
-	targetQuery := target.RawQuery
-	director := func(req *http.Request) {
-		req.URL.Scheme = target.Scheme
-		req.URL.Host = target.Host
-		req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)
-		req.Host = req.URL.Host
-		if targetQuery == "" || req.URL.RawQuery == "" {
-			req.URL.RawQuery = targetQuery + req.URL.RawQuery
-		} else {
-			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
-		}
-		if _, ok := req.Header["User-Agent"]; !ok {
-			// explicitly disable User-Agent so it's not set to default value
-			req.Header.Set("User-Agent", "")
-		}
-	}
-	return &httputil.ReverseProxy{Director: director}
-}
-
-// singleJoiningSlash from golang.org/src/net/http/httputil/reverseproxy.go
-// included here for use in NewSingleHostReverseProxyWithHostHeader
-// because its used in NewSingleHostReverseProxy from golang.org/src/net/http/httputil/reverseproxy.go
-func singleJoiningSlash(a, b string) string {
-	aslash := strings.HasSuffix(a, "/")
-	bslash := strings.HasPrefix(b, "/")
-	switch {
-	case aslash && bslash:
-		return a + b[1:]
-	case !aslash && !bslash:
-		return a + "/" + b
-	}
-	return a + b
-}

api/http/proxy/secrets.go

@@ -1,107 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrDockerSecretIdentifierNotFound defines an error raised when Portainer is unable to find a secret identifier
-	ErrDockerSecretIdentifierNotFound = portainer.Error("Docker secret identifier not found")
-	secretIdentifier                  = "ID"
-)
-
-// secretListOperation extracts the response as a JSON object, loop through the secrets array
-// decorate and/or filter the secrets based on resource controls before rewriting the response
-func secretListOperation(response *http.Response, executor *operationExecutor) error {
-	var err error
-
-	// SecretList response is a JSON array
-	// https://docs.docker.com/engine/api/v1.28/#operation/SecretList
-	responseArray, err := getResponseAsJSONArray(response)
-	if err != nil {
-		return err
-	}
-
-	if executor.operationContext.isAdmin {
-		responseArray, err = decorateSecretList(responseArray, executor.operationContext.resourceControls)
-	} else {
-		responseArray, err = filterSecretList(responseArray, executor.operationContext)
-	}
-	if err != nil {
-		return err
-	}
-
-	return rewriteResponse(response, responseArray, http.StatusOK)
-}
-
-// secretInspectOperation extracts the response as a JSON object, verify that the user
-// has access to the secret based on resource control (check are done based on the secretID and optional Swarm service ID)
-// and either rewrite an access denied response or a decorated secret.
-func secretInspectOperation(response *http.Response, executor *operationExecutor) error {
-	// SecretInspect response is a JSON object
-	// https://docs.docker.com/engine/api/v1.28/#operation/SecretInspect
-	responseObject, err := getResponseAsJSONOBject(response)
-	if err != nil {
-		return err
-	}
-
-	if responseObject[secretIdentifier] == nil {
-		return ErrDockerSecretIdentifierNotFound
-	}
-
-	secretID := responseObject[secretIdentifier].(string)
-	responseObject, access := applyResourceAccessControl(responseObject, secretID, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	return rewriteResponse(response, responseObject, http.StatusOK)
-}
-
-// decorateSecretList loops through all secrets and decorates any secret with an existing resource control.
-// Resource controls checks are based on: resource identifier.
-// Secret object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/SecretList
-func decorateSecretList(secretData []interface{}, resourceControls []portainer.ResourceControl) ([]interface{}, error) {
-	decoratedSecretData := make([]interface{}, 0)
-
-	for _, secret := range secretData {
-
-		secretObject := secret.(map[string]interface{})
-		if secretObject[secretIdentifier] == nil {
-			return nil, ErrDockerSecretIdentifierNotFound
-		}
-
-		secretID := secretObject[secretIdentifier].(string)
-		secretObject = decorateResourceWithAccessControl(secretObject, secretID, resourceControls)
-
-		decoratedSecretData = append(decoratedSecretData, secretObject)
-	}
-
-	return decoratedSecretData, nil
-}
-
-// filterSecretList loops through all secrets and filters public secrets (no associated resource control)
-// as well as authorized secrets (access granted to the user based on existing resource control).
-// Authorized secrets are decorated during the process.
-// Resource controls checks are based on: resource identifier.
-// Secret object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/SecretList
-func filterSecretList(secretData []interface{}, context *restrictedOperationContext) ([]interface{}, error) {
-	filteredSecretData := make([]interface{}, 0)
-
-	for _, secret := range secretData {
-		secretObject := secret.(map[string]interface{})
-		if secretObject[secretIdentifier] == nil {
-			return nil, ErrDockerSecretIdentifierNotFound
-		}
-
-		secretID := secretObject[secretIdentifier].(string)
-		secretObject, access := applyResourceAccessControl(secretObject, secretID, context)
-		if access {
-			filteredSecretData = append(filteredSecretData, secretObject)
-		}
-	}
-
-	return filteredSecretData, nil
-}

api/http/proxy/services.go

@@ -1,142 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrDockerServiceIdentifierNotFound defines an error raised when Portainer is unable to find a service identifier
-	ErrDockerServiceIdentifierNotFound = portainer.Error("Docker service identifier not found")
-	serviceIdentifier                  = "ID"
-	serviceLabelForStackIdentifier     = "com.docker.stack.namespace"
-)
-
-// serviceListOperation extracts the response as a JSON array, loop through the service array
-// decorate and/or filter the services based on resource controls before rewriting the response
-func serviceListOperation(response *http.Response, executor *operationExecutor) error {
-	var err error
-	// ServiceList response is a JSON array
-	// https://docs.docker.com/engine/api/v1.28/#operation/ServiceList
-	responseArray, err := getResponseAsJSONArray(response)
-	if err != nil {
-		return err
-	}
-
-	if executor.operationContext.isAdmin {
-		responseArray, err = decorateServiceList(responseArray, executor.operationContext.resourceControls)
-	} else {
-		responseArray, err = filterServiceList(responseArray, executor.operationContext)
-	}
-	if err != nil {
-		return err
-	}
-
-	return rewriteResponse(response, responseArray, http.StatusOK)
-}
-
-// serviceInspectOperation extracts the response as a JSON object, verify that the user
-// has access to the service based on resource control and either rewrite an access denied response
-// or a decorated service.
-func serviceInspectOperation(response *http.Response, executor *operationExecutor) error {
-	// ServiceInspect response is a JSON object
-	// https://docs.docker.com/engine/api/v1.28/#operation/ServiceInspect
-	responseObject, err := getResponseAsJSONOBject(response)
-	if err != nil {
-		return err
-	}
-
-	if responseObject[serviceIdentifier] == nil {
-		return ErrDockerServiceIdentifierNotFound
-	}
-
-	serviceID := responseObject[serviceIdentifier].(string)
-	responseObject, access := applyResourceAccessControl(responseObject, serviceID, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	serviceLabels := extractServiceLabelsFromServiceInspectObject(responseObject)
-	responseObject, access = applyResourceAccessControlFromLabel(serviceLabels, responseObject, serviceLabelForStackIdentifier, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	return rewriteResponse(response, responseObject, http.StatusOK)
-}
-
-// extractServiceLabelsFromServiceInspectObject retrieve the Labels of the service if present.
-// Service schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ServiceInspect
-func extractServiceLabelsFromServiceInspectObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Spec.Labels
-	serviceSpecObject := extractJSONField(responseObject, "Spec")
-	if serviceSpecObject != nil {
-		return extractJSONField(serviceSpecObject, "Labels")
-	}
-	return nil
-}
-
-// extractServiceLabelsFromServiceListObject retrieve the Labels of the service if present.
-// Service schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ServiceList
-func extractServiceLabelsFromServiceListObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Spec.Labels
-	serviceSpecObject := extractJSONField(responseObject, "Spec")
-	if serviceSpecObject != nil {
-		return extractJSONField(serviceSpecObject, "Labels")
-	}
-	return nil
-}
-
-// decorateServiceList loops through all services and decorates any service with an existing resource control.
-// Resource controls checks are based on: resource identifier, stack identifier (from label).
-// Service object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ServiceList
-func decorateServiceList(serviceData []interface{}, resourceControls []portainer.ResourceControl) ([]interface{}, error) {
-	decoratedServiceData := make([]interface{}, 0)
-
-	for _, service := range serviceData {
-
-		serviceObject := service.(map[string]interface{})
-		if serviceObject[serviceIdentifier] == nil {
-			return nil, ErrDockerServiceIdentifierNotFound
-		}
-
-		serviceID := serviceObject[serviceIdentifier].(string)
-		serviceObject = decorateResourceWithAccessControl(serviceObject, serviceID, resourceControls)
-
-		serviceLabels := extractServiceLabelsFromServiceListObject(serviceObject)
-		serviceObject = decorateResourceWithAccessControlFromLabel(serviceLabels, serviceObject, serviceLabelForStackIdentifier, resourceControls)
-
-		decoratedServiceData = append(decoratedServiceData, serviceObject)
-	}
-
-	return decoratedServiceData, nil
-}
-
-// filterServiceList loops through all services and filters public services (no associated resource control)
-// as well as authorized services (access granted to the user based on existing resource control).
-// Authorized services are decorated during the process.
-// Resource controls checks are based on: resource identifier, stack identifier (from label).
-// Service object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/ServiceList
-func filterServiceList(serviceData []interface{}, context *restrictedOperationContext) ([]interface{}, error) {
-	filteredServiceData := make([]interface{}, 0)
-
-	for _, service := range serviceData {
-		serviceObject := service.(map[string]interface{})
-		if serviceObject[serviceIdentifier] == nil {
-			return nil, ErrDockerServiceIdentifierNotFound
-		}
-
-		serviceID := serviceObject[serviceIdentifier].(string)
-		serviceObject, access := applyResourceAccessControl(serviceObject, serviceID, context)
-		if access {
-			serviceLabels := extractServiceLabelsFromServiceListObject(serviceObject)
-			serviceObject, access = applyResourceAccessControlFromLabel(serviceLabels, serviceObject, serviceLabelForStackIdentifier, context)
-			if access {
-				filteredServiceData = append(filteredServiceData, serviceObject)
-			}
-		}
-	}
-
-	return filteredServiceData, nil
-}

api/http/proxy/socket.go

@@ -1,43 +0,0 @@
-package proxy
-
-// unixSocketHandler represents a handler to proxy HTTP requests via a unix:// socket
-import (
-	"io"
-	"net/http"
-
-	httperror "github.com/portainer/portainer/http/error"
-)
-
-type socketProxy struct {
-	Transport *proxyTransport
-}
-
-func (proxy *socketProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Force URL/domain to http/unixsocket to be able to
-	// use http.Transport RoundTrip to do the requests via the socket
-	r.URL.Scheme = "http"
-	r.URL.Host = "unixsocket"
-
-	res, err := proxy.Transport.proxyDockerRequest(r)
-	if err != nil {
-		code := http.StatusInternalServerError
-		if res != nil && res.StatusCode != 0 {
-			code = res.StatusCode
-		}
-		httperror.WriteErrorResponse(w, err, code, nil)
-		return
-	}
-	defer res.Body.Close()
-
-	for k, vv := range res.Header {
-		for _, v := range vv {
-			w.Header().Add(k, v)
-		}
-	}
-
-	w.WriteHeader(res.StatusCode)
-
-	if _, err := io.Copy(w, res.Body); err != nil {
-		httperror.WriteErrorResponse(w, err, http.StatusInternalServerError, nil)
-	}
-}

api/http/proxy/tasks.go

@@ -1,78 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrDockerTaskServiceIdentifierNotFound defines an error raised when Portainer is unable to find the service identifier associated to a task
-	ErrDockerTaskServiceIdentifierNotFound = portainer.Error("Docker task service identifier not found")
-	taskServiceIdentifier                  = "ServiceID"
-	taskLabelForStackIdentifier            = "com.docker.stack.namespace"
-)
-
-// taskListOperation extracts the response as a JSON object, loop through the tasks array
-// and filter the tasks based on resource controls before rewriting the response
-func taskListOperation(response *http.Response, executor *operationExecutor) error {
-	var err error
-
-	// TaskList response is a JSON array
-	// https://docs.docker.com/engine/api/v1.28/#operation/TaskList
-	responseArray, err := getResponseAsJSONArray(response)
-	if err != nil {
-		return err
-	}
-
-	if !executor.operationContext.isAdmin {
-		responseArray, err = filterTaskList(responseArray, executor.operationContext)
-		if err != nil {
-			return err
-		}
-	}
-
-	return rewriteResponse(response, responseArray, http.StatusOK)
-}
-
-// extractTaskLabelsFromTaskListObject retrieve the Labels of the task if present.
-// Task schema reference: https://docs.docker.com/engine/api/v1.28/#operation/TaskList
-func extractTaskLabelsFromTaskListObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Spec.ContainerSpec.Labels
-	taskSpecObject := extractJSONField(responseObject, "Spec")
-	if taskSpecObject != nil {
-		containerSpecObject := extractJSONField(taskSpecObject, "ContainerSpec")
-		if containerSpecObject != nil {
-			return extractJSONField(containerSpecObject, "Labels")
-		}
-	}
-	return nil
-}
-
-// filterTaskList loops through all tasks and filters public tasks (no associated resource control)
-// as well as authorized tasks (access granted to the user based on existing resource control).
-// Resource controls checks are based on: service identifier, stack identifier (from label).
-// Task object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/TaskList
-// any resource control giving access to the user based on the associated service identifier.
-func filterTaskList(taskData []interface{}, context *restrictedOperationContext) ([]interface{}, error) {
-	filteredTaskData := make([]interface{}, 0)
-
-	for _, task := range taskData {
-		taskObject := task.(map[string]interface{})
-		if taskObject[taskServiceIdentifier] == nil {
-			return nil, ErrDockerTaskServiceIdentifierNotFound
-		}
-
-		serviceID := taskObject[taskServiceIdentifier].(string)
-		taskObject, access := applyResourceAccessControl(taskObject, serviceID, context)
-		if access {
-			taskLabels := extractTaskLabelsFromTaskListObject(taskObject)
-			taskObject, access = applyResourceAccessControlFromLabel(taskLabels, taskObject, taskLabelForStackIdentifier, context)
-			if access {
-				filteredTaskData = append(filteredTaskData, taskObject)
-			}
-		}
-	}
-
-	return filteredTaskData, nil
-}

api/http/proxy/transport.go

@@ -1,497 +0,0 @@
-package proxy
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"net/http"
-	"path"
-	"regexp"
-	"strings"
-
-	"github.com/portainer/portainer"
-	"github.com/portainer/portainer/http/security"
-)
-
-var apiVersionRe = regexp.MustCompile(`(/v[0-9]\.[0-9]*)?`)
-
-type (
-	proxyTransport struct {
-		dockerTransport        *http.Transport
-		enableSignature        bool
-		ResourceControlService portainer.ResourceControlService
-		TeamMembershipService  portainer.TeamMembershipService
-		RegistryService        portainer.RegistryService
-		DockerHubService       portainer.DockerHubService
-		SettingsService        portainer.SettingsService
-		SignatureService       portainer.DigitalSignatureService
-	}
-	restrictedOperationContext struct {
-		isAdmin          bool
-		userID           portainer.UserID
-		userTeamIDs      []portainer.TeamID
-		resourceControls []portainer.ResourceControl
-	}
-	registryAccessContext struct {
-		isAdmin         bool
-		userID          portainer.UserID
-		teamMemberships []portainer.TeamMembership
-		registries      []portainer.Registry
-		dockerHub       *portainer.DockerHub
-	}
-	registryAuthenticationHeader struct {
-		Username      string `json:"username"`
-		Password      string `json:"password"`
-		Serveraddress string `json:"serveraddress"`
-	}
-	operationExecutor struct {
-		operationContext *restrictedOperationContext
-		labelBlackList   []portainer.Pair
-	}
-	restrictedOperationRequest func(*http.Response, *operationExecutor) error
-	operationRequest           func(*http.Request) error
-)
-
-func (p *proxyTransport) RoundTrip(request *http.Request) (*http.Response, error) {
-	return p.proxyDockerRequest(request)
-}
-
-func (p *proxyTransport) executeDockerRequest(request *http.Request) (*http.Response, error) {
-	return p.dockerTransport.RoundTrip(request)
-}
-
-func (p *proxyTransport) proxyDockerRequest(request *http.Request) (*http.Response, error) {
-	path := apiVersionRe.ReplaceAllString(request.URL.Path, "")
-	request.URL.Path = path
-
-	if p.enableSignature {
-		signature, err := p.SignatureService.Sign(portainer.PortainerAgentSignatureMessage)
-		if err != nil {
-			return nil, err
-		}
-
-		request.Header.Set(portainer.PortainerAgentPublicKeyHeader, p.SignatureService.EncodedPublicKey())
-		request.Header.Set(portainer.PortainerAgentSignatureHeader, signature)
-	}
-
-	switch {
-	case strings.HasPrefix(path, "/configs"):
-		return p.proxyConfigRequest(request)
-	case strings.HasPrefix(path, "/containers"):
-		return p.proxyContainerRequest(request)
-	case strings.HasPrefix(path, "/services"):
-		return p.proxyServiceRequest(request)
-	case strings.HasPrefix(path, "/volumes"):
-		return p.proxyVolumeRequest(request)
-	case strings.HasPrefix(path, "/networks"):
-		return p.proxyNetworkRequest(request)
-	case strings.HasPrefix(path, "/secrets"):
-		return p.proxySecretRequest(request)
-	case strings.HasPrefix(path, "/swarm"):
-		return p.proxySwarmRequest(request)
-	case strings.HasPrefix(path, "/nodes"):
-		return p.proxyNodeRequest(request)
-	case strings.HasPrefix(path, "/tasks"):
-		return p.proxyTaskRequest(request)
-	case strings.HasPrefix(path, "/build"):
-		return p.proxyBuildRequest(request)
-	case strings.HasPrefix(path, "/images"):
-		return p.proxyImageRequest(request)
-	default:
-		return p.executeDockerRequest(request)
-	}
-}
-
-func (p *proxyTransport) proxyConfigRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/configs/create":
-		return p.executeDockerRequest(request)
-
-	case "/configs":
-		return p.rewriteOperation(request, configListOperation)
-
-	default:
-		// assume /configs/{id}
-		if request.Method == http.MethodGet {
-			return p.rewriteOperation(request, configInspectOperation)
-		}
-		configID := path.Base(requestPath)
-		return p.restrictedOperation(request, configID)
-	}
-}
-
-func (p *proxyTransport) proxyContainerRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/containers/create":
-		return p.executeDockerRequest(request)
-
-	case "/containers/prune":
-		return p.administratorOperation(request)
-
-	case "/containers/json":
-		return p.rewriteOperationWithLabelFiltering(request, containerListOperation)
-
-	default:
-		// This section assumes /containers/**
-		if match, _ := path.Match("/containers/*/*", requestPath); match {
-			// Handle /containers/{id}/{action} requests
-			containerID := path.Base(path.Dir(requestPath))
-			action := path.Base(requestPath)
-
-			if action == "json" {
-				return p.rewriteOperation(request, containerInspectOperation)
-			}
-			return p.restrictedOperation(request, containerID)
-		} else if match, _ := path.Match("/containers/*", requestPath); match {
-			// Handle /containers/{id} requests
-			containerID := path.Base(requestPath)
-			return p.restrictedOperation(request, containerID)
-		}
-		return p.executeDockerRequest(request)
-	}
-}
-
-func (p *proxyTransport) proxyServiceRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/services/create":
-		return p.replaceRegistryAuthenticationHeader(request)
-
-	case "/services":
-		return p.rewriteOperation(request, serviceListOperation)
-
-	default:
-		// This section assumes /services/**
-		if match, _ := path.Match("/services/*/*", requestPath); match {
-			// Handle /services/{id}/{action} requests
-			serviceID := path.Base(path.Dir(requestPath))
-			return p.restrictedOperation(request, serviceID)
-		} else if match, _ := path.Match("/services/*", requestPath); match {
-			// Handle /services/{id} requests
-			serviceID := path.Base(requestPath)
-
-			if request.Method == http.MethodGet {
-				return p.rewriteOperation(request, serviceInspectOperation)
-			}
-			return p.restrictedOperation(request, serviceID)
-		}
-		return p.executeDockerRequest(request)
-	}
-}
-
-func (p *proxyTransport) proxyVolumeRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/volumes/create":
-		return p.executeDockerRequest(request)
-
-	case "/volumes/prune":
-		return p.administratorOperation(request)
-
-	case "/volumes":
-		return p.rewriteOperation(request, volumeListOperation)
-
-	default:
-		// assume /volumes/{name}
-		if request.Method == http.MethodGet {
-			return p.rewriteOperation(request, volumeInspectOperation)
-		}
-		volumeID := path.Base(requestPath)
-		return p.restrictedOperation(request, volumeID)
-	}
-}
-
-func (p *proxyTransport) proxyNetworkRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/networks/create":
-		return p.executeDockerRequest(request)
-
-	case "/networks":
-		return p.rewriteOperation(request, networkListOperation)
-
-	default:
-		// assume /networks/{id}
-		if request.Method == http.MethodGet {
-			return p.rewriteOperation(request, networkInspectOperation)
-		}
-		networkID := path.Base(requestPath)
-		return p.restrictedOperation(request, networkID)
-	}
-}
-
-func (p *proxyTransport) proxySecretRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/secrets/create":
-		return p.executeDockerRequest(request)
-
-	case "/secrets":
-		return p.rewriteOperation(request, secretListOperation)
-
-	default:
-		// assume /secrets/{id}
-		if request.Method == http.MethodGet {
-			return p.rewriteOperation(request, secretInspectOperation)
-		}
-		secretID := path.Base(requestPath)
-		return p.restrictedOperation(request, secretID)
-	}
-}
-
-func (p *proxyTransport) proxyNodeRequest(request *http.Request) (*http.Response, error) {
-	requestPath := request.URL.Path
-
-	// assume /nodes/{id}
-	if path.Base(requestPath) != "nodes" {
-		return p.administratorOperation(request)
-	}
-
-	return p.executeDockerRequest(request)
-}
-
-func (p *proxyTransport) proxySwarmRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/swarm":
-		return p.executeDockerRequest(request)
-	default:
-		// assume /swarm/{action}
-		return p.administratorOperation(request)
-	}
-}
-
-func (p *proxyTransport) proxyTaskRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/tasks":
-		return p.rewriteOperation(request, taskListOperation)
-	default:
-		// assume /tasks/{id}
-		return p.executeDockerRequest(request)
-	}
-}
-
-func (p *proxyTransport) proxyBuildRequest(request *http.Request) (*http.Response, error) {
-	return p.interceptAndRewriteRequest(request, buildOperation)
-}
-
-func (p *proxyTransport) proxyImageRequest(request *http.Request) (*http.Response, error) {
-	switch requestPath := request.URL.Path; requestPath {
-	case "/images/create":
-		return p.replaceRegistryAuthenticationHeader(request)
-	default:
-		if path.Base(requestPath) == "push" && request.Method == http.MethodPost {
-			return p.replaceRegistryAuthenticationHeader(request)
-		}
-		return p.executeDockerRequest(request)
-	}
-}
-
-func (p *proxyTransport) replaceRegistryAuthenticationHeader(request *http.Request) (*http.Response, error) {
-	accessContext, err := p.createRegistryAccessContext(request)
-	if err != nil {
-		return nil, err
-	}
-
-	originalHeader := request.Header.Get("X-Registry-Auth")
-
-	if originalHeader != "" {
-
-		decodedHeaderData, err := base64.StdEncoding.DecodeString(originalHeader)
-		if err != nil {
-			return nil, err
-		}
-
-		var originalHeaderData registryAuthenticationHeader
-		err = json.Unmarshal(decodedHeaderData, &originalHeaderData)
-		if err != nil {
-			return nil, err
-		}
-
-		authenticationHeader := createRegistryAuthenticationHeader(originalHeaderData.Serveraddress, accessContext)
-
-		headerData, err := json.Marshal(authenticationHeader)
-		if err != nil {
-			return nil, err
-		}
-
-		header := base64.StdEncoding.EncodeToString(headerData)
-
-		request.Header.Set("X-Registry-Auth", header)
-	}
-
-	return p.executeDockerRequest(request)
-}
-
-// restrictedOperation ensures that the current user has the required authorizations
-// before executing the original request.
-func (p *proxyTransport) restrictedOperation(request *http.Request, resourceID string) (*http.Response, error) {
-	var err error
-	tokenData, err := security.RetrieveTokenData(request)
-	if err != nil {
-		return nil, err
-	}
-
-	if tokenData.Role != portainer.AdministratorRole {
-
-		teamMemberships, err := p.TeamMembershipService.TeamMembershipsByUserID(tokenData.ID)
-		if err != nil {
-			return nil, err
-		}
-
-		userTeamIDs := make([]portainer.TeamID, 0)
-		for _, membership := range teamMemberships {
-			userTeamIDs = append(userTeamIDs, membership.TeamID)
-		}
-
-		resourceControls, err := p.ResourceControlService.ResourceControls()
-		if err != nil {
-			return nil, err
-		}
-
-		resourceControl := getResourceControlByResourceID(resourceID, resourceControls)
-		if resourceControl != nil && !canUserAccessResource(tokenData.ID, userTeamIDs, resourceControl) {
-			return writeAccessDeniedResponse()
-		}
-	}
-
-	return p.executeDockerRequest(request)
-}
-
-// rewriteOperationWithLabelFiltering will create a new operation context with data that will be used
-// to decorate the original request's response as well as retrieve all the black listed labels
-// to filter the resources.
-func (p *proxyTransport) rewriteOperationWithLabelFiltering(request *http.Request, operation restrictedOperationRequest) (*http.Response, error) {
-	operationContext, err := p.createOperationContext(request)
-	if err != nil {
-		return nil, err
-	}
-
-	settings, err := p.SettingsService.Settings()
-	if err != nil {
-		return nil, err
-	}
-
-	executor := &operationExecutor{
-		operationContext: operationContext,
-		labelBlackList:   settings.BlackListedLabels,
-	}
-
-	return p.executeRequestAndRewriteResponse(request, operation, executor)
-}
-
-// rewriteOperation will create a new operation context with data that will be used
-// to decorate the original request's response.
-func (p *proxyTransport) rewriteOperation(request *http.Request, operation restrictedOperationRequest) (*http.Response, error) {
-	operationContext, err := p.createOperationContext(request)
-	if err != nil {
-		return nil, err
-	}
-
-	executor := &operationExecutor{
-		operationContext: operationContext,
-	}
-
-	return p.executeRequestAndRewriteResponse(request, operation, executor)
-}
-
-func (p *proxyTransport) interceptAndRewriteRequest(request *http.Request, operation operationRequest) (*http.Response, error) {
-	err := operation(request)
-	if err != nil {
-		return nil, err
-	}
-
-	return p.executeDockerRequest(request)
-}
-
-func (p *proxyTransport) executeRequestAndRewriteResponse(request *http.Request, operation restrictedOperationRequest, executor *operationExecutor) (*http.Response, error) {
-	response, err := p.executeDockerRequest(request)
-	if err != nil {
-		return response, err
-	}
-
-	err = operation(response, executor)
-	return response, err
-}
-
-// administratorOperation ensures that the user has administrator privileges
-// before executing the original request.
-func (p *proxyTransport) administratorOperation(request *http.Request) (*http.Response, error) {
-	tokenData, err := security.RetrieveTokenData(request)
-	if err != nil {
-		return nil, err
-	}
-
-	if tokenData.Role != portainer.AdministratorRole {
-		return writeAccessDeniedResponse()
-	}
-
-	return p.executeDockerRequest(request)
-}
-
-func (p *proxyTransport) createRegistryAccessContext(request *http.Request) (*registryAccessContext, error) {
-	tokenData, err := security.RetrieveTokenData(request)
-	if err != nil {
-		return nil, err
-	}
-
-	accessContext := &registryAccessContext{
-		isAdmin: true,
-		userID:  tokenData.ID,
-	}
-
-	hub, err := p.DockerHubService.DockerHub()
-	if err != nil {
-		return nil, err
-	}
-	accessContext.dockerHub = hub
-
-	registries, err := p.RegistryService.Registries()
-	if err != nil {
-		return nil, err
-	}
-	accessContext.registries = registries
-
-	if tokenData.Role != portainer.AdministratorRole {
-		accessContext.isAdmin = false
-
-		teamMemberships, err := p.TeamMembershipService.TeamMembershipsByUserID(tokenData.ID)
-		if err != nil {
-			return nil, err
-		}
-
-		accessContext.teamMemberships = teamMemberships
-	}
-
-	return accessContext, nil
-}
-
-func (p *proxyTransport) createOperationContext(request *http.Request) (*restrictedOperationContext, error) {
-	var err error
-	tokenData, err := security.RetrieveTokenData(request)
-	if err != nil {
-		return nil, err
-	}
-
-	resourceControls, err := p.ResourceControlService.ResourceControls()
-	if err != nil {
-		return nil, err
-	}
-
-	operationContext := &restrictedOperationContext{
-		isAdmin:          true,
-		userID:           tokenData.ID,
-		resourceControls: resourceControls,
-	}
-
-	if tokenData.Role != portainer.AdministratorRole {
-		operationContext.isAdmin = false
-
-		teamMemberships, err := p.TeamMembershipService.TeamMembershipsByUserID(tokenData.ID)
-		if err != nil {
-			return nil, err
-		}
-
-		userTeamIDs := make([]portainer.TeamID, 0)
-		for _, membership := range teamMemberships {
-			userTeamIDs = append(userTeamIDs, membership.TeamID)
-		}
-		operationContext.userTeamIDs = userTeamIDs
-	}
-
-	return operationContext, nil
-}

api/http/proxy/volumes.go

@@ -1,143 +0,0 @@
-package proxy
-
-import (
-	"net/http"
-
-	"github.com/portainer/portainer"
-)
-
-const (
-	// ErrDockerVolumeIdentifierNotFound defines an error raised when Portainer is unable to find a volume identifier
-	ErrDockerVolumeIdentifierNotFound = portainer.Error("Docker volume identifier not found")
-	volumeIdentifier                  = "Name"
-	volumeLabelForStackIdentifier     = "com.docker.stack.namespace"
-)
-
-// volumeListOperation extracts the response as a JSON object, loop through the volume array
-// decorate and/or filter the volumes based on resource controls before rewriting the response
-func volumeListOperation(response *http.Response, executor *operationExecutor) error {
-	var err error
-	// VolumeList response is a JSON object
-	// https://docs.docker.com/engine/api/v1.28/#operation/VolumeList
-	responseObject, err := getResponseAsJSONOBject(response)
-	if err != nil {
-		return err
-	}
-
-	// The "Volumes" field contains the list of volumes as an array of JSON objects
-	// Response schema reference: https://docs.docker.com/engine/api/v1.28/#operation/VolumeList
-	if responseObject["Volumes"] != nil {
-		volumeData := responseObject["Volumes"].([]interface{})
-
-		if executor.operationContext.isAdmin {
-			volumeData, err = decorateVolumeList(volumeData, executor.operationContext.resourceControls)
-		} else {
-			volumeData, err = filterVolumeList(volumeData, executor.operationContext)
-		}
-		if err != nil {
-			return err
-		}
-
-		// Overwrite the original volume list
-		responseObject["Volumes"] = volumeData
-	}
-
-	return rewriteResponse(response, responseObject, http.StatusOK)
-}
-
-// volumeInspectOperation extracts the response as a JSON object, verify that the user
-// has access to the volume based on any existing resource control and either rewrite an access denied response
-// or a decorated volume.
-func volumeInspectOperation(response *http.Response, executor *operationExecutor) error {
-	// VolumeInspect response is a JSON object
-	// https://docs.docker.com/engine/api/v1.28/#operation/VolumeInspect
-	responseObject, err := getResponseAsJSONOBject(response)
-	if err != nil {
-		return err
-	}
-
-	if responseObject[volumeIdentifier] == nil {
-		return ErrDockerVolumeIdentifierNotFound
-	}
-
-	volumeID := responseObject[volumeIdentifier].(string)
-	responseObject, access := applyResourceAccessControl(responseObject, volumeID, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	volumeLabels := extractVolumeLabelsFromVolumeInspectObject(responseObject)
-	responseObject, access = applyResourceAccessControlFromLabel(volumeLabels, responseObject, volumeLabelForStackIdentifier, executor.operationContext)
-	if !access {
-		return rewriteAccessDeniedResponse(response)
-	}
-
-	return rewriteResponse(response, responseObject, http.StatusOK)
-}
-
-// extractVolumeLabelsFromVolumeInspectObject retrieve the Labels of the volume if present.
-// Volume schema reference: https://docs.docker.com/engine/api/v1.28/#operation/VolumeInspect
-func extractVolumeLabelsFromVolumeInspectObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Labels
-	return extractJSONField(responseObject, "Labels")
-}
-
-// extractVolumeLabelsFromVolumeListObject retrieve the Labels of the volume if present.
-// Volume schema reference: https://docs.docker.com/engine/api/v1.28/#operation/VolumeList
-func extractVolumeLabelsFromVolumeListObject(responseObject map[string]interface{}) map[string]interface{} {
-	// Labels are stored under Labels
-	return extractJSONField(responseObject, "Labels")
-}
-
-// decorateVolumeList loops through all volumes and decorates any volume with an existing resource control.
-// Resource controls checks are based on: resource identifier, stack identifier (from label).
-// Volume object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/VolumeList
-func decorateVolumeList(volumeData []interface{}, resourceControls []portainer.ResourceControl) ([]interface{}, error) {
-	decoratedVolumeData := make([]interface{}, 0)
-
-	for _, volume := range volumeData {
-
-		volumeObject := volume.(map[string]interface{})
-		if volumeObject[volumeIdentifier] == nil {
-			return nil, ErrDockerVolumeIdentifierNotFound
-		}
-
-		volumeID := volumeObject[volumeIdentifier].(string)
-		volumeObject = decorateResourceWithAccessControl(volumeObject, volumeID, resourceControls)
-
-		volumeLabels := extractVolumeLabelsFromVolumeListObject(volumeObject)
-		volumeObject = decorateResourceWithAccessControlFromLabel(volumeLabels, volumeObject, volumeLabelForStackIdentifier, resourceControls)
-
-		decoratedVolumeData = append(decoratedVolumeData, volumeObject)
-	}
-
-	return decoratedVolumeData, nil
-}
-
-// filterVolumeList loops through all volumes and filters public volumes (no associated resource control)
-// as well as authorized volumes (access granted to the user based on existing resource control).
-// Authorized volumes are decorated during the process.
-// Resource controls checks are based on: resource identifier, stack identifier (from label).
-// Volume object schema reference: https://docs.docker.com/engine/api/v1.28/#operation/VolumeList
-func filterVolumeList(volumeData []interface{}, context *restrictedOperationContext) ([]interface{}, error) {
-	filteredVolumeData := make([]interface{}, 0)
-
-	for _, volume := range volumeData {
-		volumeObject := volume.(map[string]interface{})
-		if volumeObject[volumeIdentifier] == nil {
-			return nil, ErrDockerVolumeIdentifierNotFound
-		}
-
-		volumeID := volumeObject[volumeIdentifier].(string)
-		volumeObject, access := applyResourceAccessControl(volumeObject, volumeID, context)
-		if access {
-			volumeLabels := extractVolumeLabelsFromVolumeListObject(volumeObject)
-			volumeObject, access = applyResourceAccessControlFromLabel(volumeLabels, volumeObject, volumeLabelForStackIdentifier, context)
-			if access {
-				filteredVolumeData = append(filteredVolumeData, volumeObject)
-			}
-		}
-	}
-
-	return filteredVolumeData, nil
-}

api/http/security/authorization.go

@@ -1,164 +0,0 @@
-package security
-
-import "github.com/portainer/portainer"
-
-// AuthorizedResourceControlDeletion ensure that the user can delete a resource control object.
-// A non-administrator user cannot delete a resource control where:
-// * the AdministratorsOnly flag is set
-// * he is not one of the users in the user accesses
-// * he is not a member of any team within the team accesses
-func AuthorizedResourceControlDeletion(resourceControl *portainer.ResourceControl, context *RestrictedRequestContext) bool {
-	if context.IsAdmin {
-		return true
-	}
-
-	if resourceControl.AdministratorsOnly {
-		return false
-	}
-
-	userAccessesCount := len(resourceControl.UserAccesses)
-	teamAccessesCount := len(resourceControl.TeamAccesses)
-
-	if teamAccessesCount > 0 {
-		for _, access := range resourceControl.TeamAccesses {
-			for _, membership := range context.UserMemberships {
-				if membership.TeamID == access.TeamID {
-					return true
-				}
-			}
-		}
-	}
-
-	if userAccessesCount > 0 {
-		for _, access := range resourceControl.UserAccesses {
-			if access.UserID == context.UserID {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-// AuthorizedResourceControlUpdate ensure that the user can update a resource control object.
-// It reuses the creation restrictions and adds extra checks.
-// A non-administrator user cannot update a resource control where:
-// * he wants to put one or more user in the user accesses
-func AuthorizedResourceControlUpdate(resourceControl *portainer.ResourceControl, context *RestrictedRequestContext) bool {
-	userAccessesCount := len(resourceControl.UserAccesses)
-	if !context.IsAdmin && userAccessesCount > 0 {
-		return false
-	}
-
-	return AuthorizedResourceControlCreation(resourceControl, context)
-}
-
-// AuthorizedResourceControlCreation ensure that the user can create a resource control object.
-// A non-administrator user cannot create a resource control where:
-// * the AdministratorsOnly flag is set
-// * he wants to add more than one user in the user accesses
-// * he wants to add a team he is not a member of
-func AuthorizedResourceControlCreation(resourceControl *portainer.ResourceControl, context *RestrictedRequestContext) bool {
-	if context.IsAdmin {
-		return true
-	}
-
-	if resourceControl.AdministratorsOnly {
-		return false
-	}
-
-	userAccessesCount := len(resourceControl.UserAccesses)
-	teamAccessesCount := len(resourceControl.TeamAccesses)
-	if userAccessesCount > 1 || (userAccessesCount == 1 && teamAccessesCount == 1) {
-		return false
-	}
-
-	if userAccessesCount == 1 {
-		access := resourceControl.UserAccesses[0]
-		if access.UserID == context.UserID {
-			return true
-		}
-	}
-
-	if teamAccessesCount > 0 {
-		for _, access := range resourceControl.TeamAccesses {
-			isMember := false
-			for _, membership := range context.UserMemberships {
-				if membership.TeamID == access.TeamID {
-					isMember = true
-				}
-			}
-			if !isMember {
-				return false
-			}
-		}
-	}
-
-	return true
-}
-
-// AuthorizedTeamManagement ensure that access to the management of the specified team is granted.
-// It will check if the user is either administrator or leader of that team.
-func AuthorizedTeamManagement(teamID portainer.TeamID, context *RestrictedRequestContext) bool {
-	if context.IsAdmin {
-		return true
-	}
-
-	for _, membership := range context.UserMemberships {
-		if membership.TeamID == teamID && membership.Role == portainer.TeamLeader {
-			return true
-		}
-	}
-
-	return false
-}
-
-// AuthorizedUserManagement ensure that access to the management of the specified user is granted.
-// It will check if the user is either administrator or the owner of the user account.
-func AuthorizedUserManagement(userID portainer.UserID, context *RestrictedRequestContext) bool {
-	if context.IsAdmin || context.UserID == userID {
-		return true
-	}
-	return false
-}
-
-// AuthorizedEndpointAccess ensure that the user can access the specified endpoint.
-// It will check if the user is part of the authorized users or part of a team that is
-// listed in the authorized teams of the endpoint and the associated group.
-func AuthorizedEndpointAccess(endpoint *portainer.Endpoint, endpointGroup *portainer.EndpointGroup, userID portainer.UserID, memberships []portainer.TeamMembership) bool {
-	groupAccess := authorizedAccess(userID, memberships, endpointGroup.AuthorizedUsers, endpointGroup.AuthorizedTeams)
-	if !groupAccess {
-		return authorizedAccess(userID, memberships, endpoint.AuthorizedUsers, endpoint.AuthorizedTeams)
-	}
-	return true
-}
-
-// AuthorizedEndpointGroupAccess ensure that the user can access the specified endpoint group.
-// It will check if the user is part of the authorized users or part of a team that is
-// listed in the authorized teams.
-func AuthorizedEndpointGroupAccess(endpointGroup *portainer.EndpointGroup, userID portainer.UserID, memberships []portainer.TeamMembership) bool {
-	return authorizedAccess(userID, memberships, endpointGroup.AuthorizedUsers, endpointGroup.AuthorizedTeams)
-}
-
-// AuthorizedRegistryAccess ensure that the user can access the specified registry.
-// It will check if the user is part of the authorized users or part of a team that is
-// listed in the authorized teams.
-func AuthorizedRegistryAccess(registry *portainer.Registry, userID portainer.UserID, memberships []portainer.TeamMembership) bool {
-	return authorizedAccess(userID, memberships, registry.AuthorizedUsers, registry.AuthorizedTeams)
-}
-
-func authorizedAccess(userID portainer.UserID, memberships []portainer.TeamMembership, authorizedUsers []portainer.UserID, authorizedTeams []portainer.TeamID) bool {
-	for _, authorizedUserID := range authorizedUsers {
-		if authorizedUserID == userID {
-			return true
-		}
-	}
-	for _, membership := range memberships {
-		for _, authorizedTeamID := range authorizedTeams {
-			if membership.TeamID == authorizedTeamID {
-				return true
-			}
-		}
-	}
-	return false
-}