finish (#742)

Signed-off-by: link <a624669980@163.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -28,5 +28,19 @@ If applicable, add screenshots to help explain your problem.
  - Browser [e.g. chrome, safari]
  - Version [e.g. 22]
 
+**Logs**
+
+run following command to collect corresponding logs:
+
+```bash
+sudo journalctl -xef -u casaos-gateway
+sudo journalctl -xef -u casaos-user-service
+sudo journalctl -xef -u casaos-local-storage
+sudo journalctl -xef -u casaos.service
+```
+
+
+
+
 **Additional context**
 Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feedback.yml

@@ -0,0 +1,23 @@
+name: "Feedback"
+description: Feedback, showcases, thoughts, needs and questions, etc.
+title: "[Feedback] "
+labels: ["feedback"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### ❤️ Thanks for your feedback!
+        > Come join our [Discord community](https://discord.gg/knqAbbBbeX) and paint the ideal home cloud with us.
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      placeholder: What do you want to tell us?
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional Information
+      description: Please add logs/files/screenshots if you have them to help us better understanding.
+

.github/workflows/demo.yml

@@ -33,7 +33,7 @@ jobs:
           
       - name: Get old instance and snapshot name, create new instance name
         run: | 
-          echo "OLD_INSTANCE_SNAPSHOT_NAME=$(aws lightsail get-instance-snapshots | grep '"name": "0.3.3-demo-1658402149' | sed 's/ //g' | sed 's/"//g' | sed 's/,//g' | sed 's/name://g')" >> $GITHUB_ENV
+          echo "OLD_INSTANCE_SNAPSHOT_NAME=$(aws lightsail get-instance-snapshots | grep '"name": "casaos-0.3.6-1666150291' | sed 's/ //g' | sed 's/"//g' | sed 's/,//g' | sed 's/name://g')" >> $GITHUB_ENV
           echo "OLD_INSTANCE_NAME=$(aws lightsail get-instances | grep '"name": "CasaOS-Demo-[0-9]' | sed 's/ //g' | sed 's/"//g' | sed 's/,//g' | sed 's/name://g')" >> $GITHUB_ENV
           echo "NEW_INSTANCE_NAME=CasaOS-Demo-$(date +%s)" >> $GITHUB_ENV
           

.github/workflows/release.yml

@@ -0,0 +1,71 @@
+name: goreleaser
+
+on:
+  push:
+    tags:
+      - v*.*.*
+
+permissions:
+  contents: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-22.04
+    steps:
+      -
+        name: Install dependencies for cross-compiling
+        run: |
+          sudo apt update 
+          sudo apt-get --no-install-recommends --yes install \
+            libc6-dev-amd64-cross \
+            gcc-aarch64-linux-gnu libc6-dev-arm64-cross \
+            gcc-arm-linux-gnueabihf libc6-dev-armhf-cross
+      -
+        name: Checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      -
+        name: Fetch all tags
+        run: git fetch --force --tags
+        
+      - name: Get version
+        id: get_version
+        run: echo ::set-output name=VERSION::${GITHUB_REF/refs\/tags\//}
+      -
+        name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.19
+      -
+        name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v2
+        with:
+          # either 'goreleaser' (default) or 'goreleaser-pro'
+          distribution: goreleaser
+          version: latest
+          args: release --rm-dist
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # Your GoReleaser Pro key, if you are using the 'goreleaser-pro' distribution
+          # GORELEASER_KEY: ${{ secrets.GORELEASER_KEY }}
+      
+      - name: Upload to oss
+        id: upload_to_oss
+        uses: tvrcgo/upload-to-oss@master
+        with:
+          key-id: ${{ secrets.OSS_KEY_ID }}
+          key-secret: ${{ secrets.OSS_KEY_SECRET }}
+          region: oss-cn-shanghai
+          bucket: casaos
+          assets: |
+            dist/checksums.txt:/IceWhaleTech/CasaOS/releases/download/${{ steps.get_version.outputs.VERSION }}/checksums.txt
+            dist/linux-arm-7-casaos-${{ steps.get_version.outputs.VERSION }}.tar.gz:/IceWhaleTech/CasaOS/releases/download/${{ steps.get_version.outputs.VERSION }}/linux-arm-7-casaos-${{ steps.get_version.outputs.VERSION }}.tar.gz
+            dist/linux-arm64-casaos-${{ steps.get_version.outputs.VERSION }}.tar.gz:/IceWhaleTech/CasaOS/releases/download/${{ steps.get_version.outputs.VERSION }}/linux-arm64-casaos-${{ steps.get_version.outputs.VERSION }}.tar.gz
+            dist/linux-amd64-casaos-${{ steps.get_version.outputs.VERSION }}.tar.gz:/IceWhaleTech/CasaOS/releases/download/${{ steps.get_version.outputs.VERSION }}/linux-amd64-casaos-${{ steps.get_version.outputs.VERSION }}.tar.gz
+            dist/linux-arm-7-casaos-migration-tool-${{ steps.get_version.outputs.VERSION }}.tar.gz:/IceWhaleTech/CasaOS/releases/download/${{ steps.get_version.outputs.VERSION }}/linux-arm-7-casaos-migration-tool-${{ steps.get_version.outputs.VERSION }}.tar.gz
+            dist/linux-arm64-casaos-migration-tool-${{ steps.get_version.outputs.VERSION }}.tar.gz:/IceWhaleTech/CasaOS/releases/download/${{ steps.get_version.outputs.VERSION }}/linux-arm64-casaos-migration-tool-${{ steps.get_version.outputs.VERSION }}.tar.gz
+            dist/linux-amd64-casaos-migration-tool-${{ steps.get_version.outputs.VERSION }}.tar.gz:/IceWhaleTech/CasaOS/releases/download/${{ steps.get_version.outputs.VERSION }}/linux-amd64-casaos-migration-tool-${{ steps.get_version.outputs.VERSION }}.tar.gz
+
+
+

.gitignore

@@ -28,16 +28,15 @@ gen
 /sql/
 /out/
 /db/
-/docs/
-/web/
 /conf/conf.ini
 /conf/conf.conf
 /conf/conf.json
 __debug_bin
 main
-CasaOS
 github.com
 .all-contributorsrc
-build
 dist
-.goreleaser.yaml
+CasaOS
+
+# System Files
+.DS_Store

.goreleaser.debug.yaml

@@ -0,0 +1,167 @@
+# This is an example .goreleaser.yml file with some sensible defaults.
+# Make sure to check the documentation at https://goreleaser.com
+project_name: casaos
+before:
+  hooks:
+    # You may remove this if you don't use go modules.
+    - go mod tidy
+builds:
+  - id: casaos-amd64
+    binary: build/sysroot/usr/bin/casaos
+    env:
+      - CC=x86_64-linux-gnu-gcc
+    gcflags:
+      - all=-N -l
+    ldflags:
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - amd64
+    hooks:
+      post:
+        - find build/sysroot -type f | xargs -L 1 realpath --relative-to=build/sysroot > build/sysroot.manifest
+  - id: casaos-arm64
+    binary: build/sysroot/usr/bin/casaos
+    env:
+      - CC=aarch64-linux-gnu-gcc
+    gcflags:
+      - all=-N -l
+    ldflags:
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm64
+    hooks:
+      post:
+        - find build/sysroot -type f | xargs -L 1 realpath --relative-to=build/sysroot > build/sysroot.manifest
+  - id: casaos-arm-7
+    binary: build/sysroot/usr/bin/casaos
+    env:
+      - CC=arm-linux-gnueabihf-gcc
+    gcflags:
+      - all=-N -l
+    ldflags:
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm
+    goarm:
+      - "7"
+    hooks:
+      post:
+        - find build/sysroot -type f | xargs -L 1 realpath --relative-to=build/sysroot > build/sysroot.manifest
+  - id: casaos-migration-tool-amd64
+    binary: build/sysroot/usr/bin/casaos-migration-tool
+    main: ./cmd/migration-tool
+    env:
+      - CC=x86_64-linux-gnu-gcc
+    gcflags:
+      - all=-N -l
+    ldflags:
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - amd64
+  - id: casaos-migration-tool-arm64
+    binary: build/sysroot/usr/bin/casaos-migration-tool
+    main: ./cmd/migration-tool
+    env:
+      - CC=aarch64-linux-gnu-gcc
+    gcflags:
+      - all=-N -l
+    ldflags:
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm64
+  - id: casaos-migration-tool-arm-7
+    binary: build/sysroot/usr/bin/casaos-migration-tool
+    main: ./cmd/migration-tool
+    env:
+      - CC=arm-linux-gnueabihf-gcc
+    gcflags:
+      - all=-N -l
+    ldflags:
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm
+    goarm:
+      - "7"
+archives:
+  - name_template: "{{ .Os }}-{{ .Arch }}-{{ .ProjectName }}-v{{ .Version }}"
+    id: casaos
+    builds:
+      - casaos-amd64
+      - casaos-arm64
+      - casaos-arm-7
+    replacements:
+      arm: arm-7
+    files:
+      - build/**/*
+  - name_template: "{{ .Os }}-{{ .Arch }}-{{ .ProjectName }}-migration-tool-v{{ .Version }}"
+    id: casaos-migration-tool
+    builds:
+      - casaos-migration-tool-amd64
+      - casaos-migration-tool-arm64
+      - casaos-migration-tool-arm-7
+    replacements:
+      arm: arm-7
+    files:
+      - build/sysroot/etc/**/*
+checksum:
+  name_template: "checksums.txt"
+snapshot:
+  name_template: "{{ incpatch .Version }}"
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - "^docs:"
+      - "^test:"
+# release:
+#   github:
+#     owner: IceWhaleTech
+#     name: CasaOS
+#   draft: true
+#   prerelease: auto
+#   mode: replace
+#   name_template: "v{{ .Version }}"
+release:
+  github:
+    owner: IceWhaleTech
+    name: CasaOS
+  draft: true
+  prerelease: auto
+  mode: replace
+  name_template: "v{{ .Version }}"

.goreleaser.yaml

@@ -0,0 +1,167 @@
+# This is an example .goreleaser.yml file with some sensible defaults.
+# Make sure to check the documentation at https://goreleaser.com
+project_name: casaos
+before:
+  hooks:
+    # You may remove this if you don't use go modules.
+    - go mod tidy
+builds:
+  - id: casaos-amd64
+    binary: build/sysroot/usr/bin/casaos
+    env:
+      - CC=x86_64-linux-gnu-gcc
+    ldflags:
+      - -s
+      - -w
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - amd64
+    hooks:
+      post:
+        - find build/sysroot -type f | xargs -L 1 realpath --relative-to=build/sysroot > build/sysroot.manifest
+  - id: casaos-arm64
+    binary: build/sysroot/usr/bin/casaos
+    env:
+      - CC=aarch64-linux-gnu-gcc
+    ldflags:
+      - -s
+      - -w
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm64
+    hooks:
+      post:
+        - find build/sysroot -type f | xargs -L 1 realpath --relative-to=build/sysroot > build/sysroot.manifest
+  - id: casaos-arm-7
+    binary: build/sysroot/usr/bin/casaos
+    env:
+      - CC=arm-linux-gnueabihf-gcc
+    ldflags:
+      - -s
+      - -w
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm
+    goarm:
+      - "7"
+    hooks:
+      post:
+        - find build/sysroot -type f | xargs -L 1 realpath --relative-to=build/sysroot > build/sysroot.manifest
+  - id: casaos-migration-tool-amd64
+    binary: build/sysroot/usr/bin/casaos-migration-tool
+    main: ./cmd/migration-tool
+    env:
+      - CC=x86_64-linux-gnu-gcc
+    ldflags:
+      - -s
+      - -w
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - amd64
+  - id: casaos-migration-tool-arm64
+    binary: build/sysroot/usr/bin/casaos-migration-tool
+    main: ./cmd/migration-tool
+    env:
+      - CC=aarch64-linux-gnu-gcc
+    ldflags:
+      - -s
+      - -w
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm64
+  - id: casaos-migration-tool-arm-7
+    binary: build/sysroot/usr/bin/casaos-migration-tool
+    main: ./cmd/migration-tool
+    env:
+      - CC=arm-linux-gnueabihf-gcc
+    ldflags:
+      - -s
+      - -w
+      - -extldflags "-static"
+    tags:
+      - musl
+      - netgo
+      - osusergo
+    goos:
+      - linux
+    goarch:
+      - arm
+    goarm:
+      - "7"
+archives:
+  - name_template: "{{ .Os }}-{{ .Arch }}-{{ .ProjectName }}-v{{ .Version }}"
+    id: casaos
+    builds:
+      - casaos-amd64
+      - casaos-arm64
+      - casaos-arm-7
+    replacements:
+      arm: arm-7
+    files:
+      - build/**/*
+  - name_template: "{{ .Os }}-{{ .Arch }}-{{ .ProjectName }}-migration-tool-v{{ .Version }}"
+    id: casaos-migration-tool
+    builds:
+      - casaos-migration-tool-amd64
+      - casaos-migration-tool-arm64
+      - casaos-migration-tool-arm-7
+    replacements:
+      arm: arm-7
+    files:
+      - build/sysroot/etc/**/*
+checksum:
+  name_template: "checksums.txt"
+snapshot:
+  name_template: "{{ incpatch .Version }}"
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - "^docs:"
+      - "^test:"
+# release:
+#   github:
+#     owner: IceWhaleTech
+#     name: CasaOS
+#   draft: true
+#   prerelease: auto
+#   mode: replace
+#   name_template: "v{{ .Version }}"
+release:
+  github:
+    owner: IceWhaleTech
+    name: CasaOS
+  draft: true
+  prerelease: auto
+  mode: replace
+  name_template: "v{{ .Version }}"

CHANGELOG.md

@@ -16,9 +16,88 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Security
 
+## [0.4.0 - alpha]
+### Added
+
+- [Developer] Included `casaos-cli` command tool for debugging
+- [Developer] Added message bus for events and actions - Use `casaos-cli message-bus` to manage.
+- [Disk] Disk notification in Dashboard
+- [System] Restart/shutdown directly from CasaOS Dashboard
+### Changed
+
+- [General] CasaOS new logo!
+- [App] Redesign of Featured App
+- [App] Now you can choose to delete userdata along with app uninstallation
+
+### Security
+
+- [System] Fixed a shell injection issue for better security
+
 ### Fixed
 
-## [0.3.5-alpha] - 2022-08-08
+- [System] Re-instate default zone0 for CPU Temp ([#694](https://github.com/IceWhaleTech/CasaOS/issues/694))
+- [Disk] Fixed storage name with extra `-1` after rebooting ([#698](https://github.com/IceWhaleTech/CasaOS/issues/698))
+- [Disk] Fixed disk check so it does not impact disk going into idle ([#704](https://github.com/IceWhaleTech/CasaOS/issues/704))
+
+## [0.3.8] 2022-11-21
+
+### Added
+- [System] Add system announcement
+- [App] Allow to turn off the display of "Existing Docker Apps" in the settings.
+
+### Changed
+- [System] Improve the feedback function, you can submit feedback in the bottom right corner of WebUI.
+
+### Fixed
+- [System] Fix CPU Temp for other platforms ([#661](https://github.com/IceWhaleTech/CasaOS/issues/661))
+
+## [0.3.7.1] 2022-11-04
+
+### Fixed
+
+- Fix memory leak issue ([#658](https://github.com/IceWhaleTech/CasaOS/issues/658)[#646](https://github.com/IceWhaleTech/CasaOS/issues/646))
+- Solve the problem of local application import failure ([#490](https://github.com/IceWhaleTech/CasaOS/issues/490))
+
+## [0.3.7] 2022-10-28
+
+### Added
+- [Storage] Disk merge (Beta), you can merge multiple disks into a single storage space (currently you need to enable this feature from the command line)
+
+### Changed
+- [Files] Changed the cache file storage location, now the file upload size is not limited by the system disk capacity.
+- [Scripts] Updated installation and upgrade scripts to support more Debian-based Linux distributions.
+- [Engineering] Refactored Local Storage into a standalone service as part of CasaOS modularization.
+
+### Fixed
+- [Apps] App list update mechanism improved, now you can see the latest apps in App Store immediately.
+- [Storage] Fixed a lot of known issues
+
+### Added
+- [Storage] Disk merge (Beta), you can merge multiple disks into a single storage space (currently you need to enable this feature from the command line)
+
+### Changed
+- [Files] Changed the cache file storage location, now the file upload size is not limited by the system disk capacity.
+- [Scripts] Updated installation and upgrade scripts to support more Debian-based Linux distributions.
+- [Engineering] Refactored Local Storage into a standalone service as part of CasaOS modularization.
+
+### Fixed
+- [Apps] App list update mechanism improved, now you can see the latest apps in App Store immediately.
+- [Storage] Fixed a lot of known issues
+
+
+## [0.3.6] - 2022-09-06
+
+###  Added
+- [System] Added power and temperature info to performance widget (Intel)
+- [Apps] Custom links can be added to Apps section
+
+### Fixed
+- [Apps] Fixed the problem of not being able to modify some App settings ([#510](https://github.com/IceWhaleTech/CasaOS/issues/510))
+
+### Changed
+- [System] Architecture optimization. Improved performance.
+
+## [0.3.5] - 2022-08-23
 
 ### Added
 

README.md

@@ -114,19 +114,20 @@ Community Support
 - Armbian 22.04 (✅ Tested)
 - Alpine (🚧 Not Fully Tested Yet)
 - OpenWrt (🚧 Not Fully Tested Yet)
+- ArchLinux (🚧 Not Fully Tested Yet)
 
 ### Quick Setup CasaOS
 
 Freshly install a system from the list above and run this command:
 
 ```sh
-wget -qO- https://get.casaos.io | bash
+wget -qO- https://get.casaos.io | sudo bash
 ```
 
 or
 
 ```sh
-curl -fsSL https://get.casaos.io | bash
+curl -fsSL https://get.casaos.io | sudo bash
 ```
 
 ### Uninstall CasaOS
@@ -141,7 +142,7 @@ casaos-uninstall
 Before v0.3.3
 
 ```sh
-curl -fsSL https://get.icewhale.io/casaos-uninstall.sh | bash
+curl -fsSL https://get.icewhale.io/casaos-uninstall.sh | sudo bash
 ```
 
 ## Community 
@@ -162,38 +163,8 @@ We believes that through community-driven collaborative innovation and open comm
 
 CasaOS is a community-driven open source project and the people involved are CasaOS users. That means CasaOS will always need contributions from community members just like you!
 
-<details>
-  <summary><b>How can I get involved? 🧐</b></summary>
-  <p>
-
-### Coding 💻 (WIP)
-
-We are refining documentation that can be used for effective community collaboration. Feel free to start a discussion if you have a good idea.
-
-### Helping Users 💬
-
-If you have extensive knowledge of CasaOS and related areas. We highly encourage you to help others as much as you can in Discord and Discussions.
-
-Discord: [https://discord.gg/knqAbbBbeX](https://discord.gg/knqAbbBbeX)
-
-GitHub Discussions: [https://github.com/IceWhaleTech/CasaOS/discussions](https://github.com/IceWhaleTech/CasaOS/discussions)
-
-### Helping with Translations 🌍 (WIP)
-
-CasaOS officially supports English and Chinese. You are welcome to help make CasaOS available in more languages.
-
-### Performing Alpha Testing ⚠️
-
-Alpha testing is quality assurance testing that is engaged and driven by the community. It's a great way to get involved in contributing and experiencing the latest features before a new release.
-
-The documentation is being refined and you can contact @JohnGuan via [Discord](https://discord.gg/knqAbbBbeX). Ask to join the #casaos-alpha channel.
-
-### Writing Documentation 📖 (WIP)
-
-Help make our documentation better by writing new content for the CasaOS Wiki, correcting existing material, or translating content into new languages.
-
-  </p>
-</details>
+- See <https://wiki.casaos.io/en/contribute> for ways of contribution to CasaOS
+- See <https://wiki.casaos.io/en/contribute/development> if you want to be involved in code contribution specificially
 
 ## Credits
 

build/scripts/migration/script.d/03-migrate-casaos.sh

@@ -0,0 +1,177 @@
+#!/bin/bash
+
+set -e
+
+# functions
+__info() {
+    echo -e "🟩 ${1}"
+}
+
+__info_done() {
+    echo -e "✅ ${1}"
+}
+
+__warning() {
+    echo -e "🟨 ${1}"
+}
+
+__error() {
+    echo "🟥 ${1}"
+    exit 1
+}
+
+__is_version_gt() {
+    test "$(echo "$@" | tr " " "\n" | sort -V | head -n 1)" != "$1"
+}
+__normalize_version() {
+    local version
+    if [ "${1::1}" = "v" ]; then
+        version="${1:1}"
+    else
+        version="${1}"
+    fi
+
+    echo "$version"
+}
+
+__is_migration_needed() {
+    local version1
+    local version2
+
+    version1=$(__normalize_version "${1}")
+    version2=$(__normalize_version "${2}")
+
+    if [ "${version1}" = "${version2}" ]; then
+        return 1
+    fi
+
+    if [ "CURRENT_VERSION_NOT_FOUND" = "${version1}" ]; then
+        return 1
+    fi
+
+    if [ "LEGACY_WITHOUT_VERSION" = "${version1}" ]; then
+        return 0
+    fi
+
+    __is_version_gt "${version2}" "${version1}"
+}
+
+BUILD_PATH=$(dirname "${BASH_SOURCE[0]}")/../../..
+SOURCE_ROOT=${BUILD_PATH}/sysroot
+
+APP_NAME="casaos"
+
+# check if migration is needed
+SOURCE_BIN_PATH=${SOURCE_ROOT}/usr/bin
+SOURCE_BIN_FILE=${SOURCE_BIN_PATH}/${APP_NAME}
+
+CURRENT_BIN_PATH=/usr/bin
+CURRENT_BIN_PATH_LEGACY=/usr/local/bin
+CURRENT_BIN_FILE=${CURRENT_BIN_PATH}/${APP_NAME}
+CURRENT_BIN_FILE_LEGACY=$(realpath -e ${CURRENT_BIN_PATH_LEGACY}/${APP_NAME} || which ${APP_NAME} || echo CURRENT_BIN_FILE_LEGACY_NOT_FOUND)
+
+SOURCE_VERSION="$(${SOURCE_BIN_FILE} -v)"
+CURRENT_VERSION="$(${CURRENT_BIN_FILE} -v || ${CURRENT_BIN_FILE_LEGACY} -v || (stat "${CURRENT_BIN_FILE_LEGACY}" > /dev/null && echo LEGACY_WITHOUT_VERSION) || echo CURRENT_VERSION_NOT_FOUND)"
+
+__info_done "CURRENT_VERSION: ${CURRENT_VERSION}"
+__info_done "SOURCE_VERSION: ${SOURCE_VERSION}"
+
+NEED_MIGRATION=$(__is_migration_needed "${CURRENT_VERSION}" "${SOURCE_VERSION}" && echo "true" || echo "false")
+
+if [ "${NEED_MIGRATION}" = "false" ]; then
+    __info_done "Migration is not needed."
+    exit 0
+fi
+
+ARCH="unknown"
+
+case $(uname -m) in
+    x86_64)
+        ARCH="amd64"
+        ;;
+    aarch64)
+        ARCH="arm64"
+        ;;
+    armv7l)
+        ARCH="arm-7"
+        ;;
+    *)
+        __error "Unsupported architecture"
+        ;;
+esac
+
+__info "ARCH: ${ARCH}"
+
+MIGRATION_SERVICE_DIR=${1}
+
+if [ -z "${MIGRATION_SERVICE_DIR}" ]; then
+    MIGRATION_SERVICE_DIR=${BUILD_PATH}/scripts/migration/service.d/${APP_NAME}
+fi
+MIGRATION_LIST_FILE=${MIGRATION_SERVICE_DIR}/migration.list
+MIGRATION_PATH=()
+
+CURRENT_VERSION_FOUND="false"
+
+# a VERSION_PAIR looks like "v0.3.5 <url>"
+#
+# - "v0.3.5" is the current version installed on this host
+# - "<url>" is the url of the migration tool
+while read -r VERSION_PAIR; do
+    if [ -z "${VERSION_PAIR}" ]; then
+        continue
+    fi
+
+    # obtain "v0.3.5" from "v0.3.5 v0.3.6-alpha2"
+    VER1=$(echo "${VERSION_PAIR}" | cut -d' ' -f1)
+
+    # obtain "<url>" from "v0.3.5 <url>"
+    URL=$(eval echo "${VERSION_PAIR}" | cut -d' ' -f2)
+
+    if [ "${CURRENT_VERSION}" = "${VER1// /}" ] || [ "${CURRENT_VERSION}" = "LEGACY_WITHOUT_VERSION" ]; then
+        CURRENT_VERSION_FOUND="true"
+    fi
+
+    if [ "${CURRENT_VERSION_FOUND}" = "true" ]; then
+        MIGRATION_PATH+=("${URL// /}")
+    fi
+done < "${MIGRATION_LIST_FILE}"
+
+if [ ${#MIGRATION_PATH[@]} -eq 0 ]; then
+    __warning "No migration path found from ${CURRENT_VERSION} to ${SOURCE_VERSION}"
+    exit 0
+fi
+
+pushd "${MIGRATION_SERVICE_DIR}"
+
+{ for URL in "${MIGRATION_PATH[@]}"; do
+        MIGRATION_TOOL_FILE=$(basename "${URL}")
+
+        if [ -f "${MIGRATION_TOOL_FILE}" ]; then
+            __info "Migration tool ${MIGRATION_TOOL_FILE} exists. Skip downloading."
+            continue
+        fi
+
+        __info "Dowloading ${URL}..."
+        curl -fsSL -o "${MIGRATION_TOOL_FILE}" -O "${URL}"
+    done
+} || {
+    popd
+    __error "Failed to download migration tools"
+}
+
+{
+    for URL in "${MIGRATION_PATH[@]}"; do
+        MIGRATION_TOOL_FILE=$(basename "${URL}")
+        __info "Extracting ${MIGRATION_TOOL_FILE}..."
+        tar zxvf "${MIGRATION_TOOL_FILE}" || __error "Failed to extract ${MIGRATION_TOOL_FILE}"
+
+        MIGRATION_TOOL_PATH=build/sysroot/usr/bin/${APP_NAME}-migration-tool
+        __info "Running ${MIGRATION_TOOL_PATH}..."
+        ${MIGRATION_TOOL_PATH}
+    done
+} || {
+    popd
+    __error "Failed to extract and run migration tools"
+}
+
+popd

build/scripts/migration/service.d/casaos/migration.list

@@ -0,0 +1,3 @@
+LEGACY_WITHOUT_VERSION https://github.com/IceWhaleTech/CasaOS/releases/download/v0.3.6/linux-${ARCH}-casaos-migration-tool-v0.3.6.tar.gz
+v0.3.5 https://github.com/IceWhaleTech/CasaOS/releases/download/v0.3.6/linux-${ARCH}-casaos-migration-tool-v0.3.6.tar.gz
+v0.3.5.1 https://github.com/IceWhaleTech/CasaOS/releases/download/v0.3.6/linux-${ARCH}-casaos-migration-tool-v0.3.6.tar.gz

build/scripts/setup/script.d/03-setup-casaos.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+set -e
+
+BUILD_PATH=$(dirname "${BASH_SOURCE[0]}")/../../..
+
+APP_NAME_SHORT=casaos
+
+__get_setup_script_directory_by_os_release() {
+	pushd "$(dirname "${BASH_SOURCE[0]}")/../service.d/${APP_NAME_SHORT}" >/dev/null
+
+	{
+		# shellcheck source=/dev/null
+		{
+			source /etc/os-release
+			{
+				pushd "${ID}"/"${VERSION_CODENAME}" >/dev/null
+			} || {
+				pushd "${ID}" >/dev/null
+			} || {
+				pushd "${ID_LIKE}" >/dev/null
+			} || {
+				echo "Unsupported OS: ${ID} ${VERSION_CODENAME} (${ID_LIKE})"
+				exit 1
+			}
+
+			pwd
+
+			popd >/dev/null
+
+		} || {
+			echo "Unsupported OS: unknown"
+			exit 1
+		}
+
+	}
+
+	popd >/dev/null
+}
+
+SETUP_SCRIPT_DIRECTORY=$(__get_setup_script_directory_by_os_release)
+SETUP_SCRIPT_FILENAME="setup-${APP_NAME_SHORT}.sh"
+
+SETUP_SCRIPT_FILEPATH="${SETUP_SCRIPT_DIRECTORY}/${SETUP_SCRIPT_FILENAME}"
+
+{
+    echo "🟩 Running ${SETUP_SCRIPT_FILENAME}..."
+    $BASH "${SETUP_SCRIPT_FILEPATH}" "${BUILD_PATH}"
+} || {
+    echo "🟥 ${SETUP_SCRIPT_FILENAME} failed."
+    exit 1
+}
+
+echo "✅ ${SETUP_SCRIPT_FILENAME} finished."

build/scripts/setup/service.d/casaos/arch/setup-casaos.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+###
+# @Author: LinkLeong link@icewhale.org
+# @Date: 2022-08-25 11:41:22
+ # @LastEditors: LinkLeong
+ # @LastEditTime: 2022-08-31 17:54:17
+ # @FilePath: /CasaOS/build/scripts/setup/service.d/casaos/debian/setup-casaos.sh
+# @Description:
+
+# @Website: https://www.casaos.io
+# Copyright (c) 2022 by icewhale, All Rights Reserved.
+###
+
+set -e
+
+APP_NAME="casaos"
+
+# copy config files
+CONF_PATH=/etc/casaos
+OLD_CONF_PATH=/etc/casaos.conf
+CONF_FILE=${CONF_PATH}/${APP_NAME}.conf
+CONF_FILE_SAMPLE=${CONF_PATH}/${APP_NAME}.conf.sample
+
+
+if [ -f "${OLD_CONF_PATH}" ]; then
+    echo "copy old conf"
+    cp "${OLD_CONF_PATH}" "${CONF_FILE}"
+fi
+if [ ! -f "${CONF_FILE}" ]; then
+    echo "Initializing config file..."
+    cp -v "${CONF_FILE_SAMPLE}" "${CONF_FILE}"
+fi
+
+rm -rf /etc/systemd/system/casaos.service # remove old service file
+
+systemctl daemon-reload
+
+# enable service (without starting)
+echo "Enabling service..."
+systemctl enable --force --no-ask-password "${APP_NAME}.service"

build/scripts/setup/service.d/casaos/debian/bullseye/setup-casaos.sh

@@ -0,0 +1 @@
+../setup-casaos.sh

build/scripts/setup/service.d/casaos/debian/setup-casaos.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+###
+# @Author: LinkLeong link@icewhale.org
+# @Date: 2022-08-25 11:41:22
+ # @LastEditors: LinkLeong
+ # @LastEditTime: 2022-08-31 17:54:17
+ # @FilePath: /CasaOS/build/scripts/setup/service.d/casaos/debian/setup-casaos.sh
+# @Description:
+
+# @Website: https://www.casaos.io
+# Copyright (c) 2022 by icewhale, All Rights Reserved.
+###
+
+set -e
+
+APP_NAME="casaos"
+
+# copy config files
+CONF_PATH=/etc/casaos
+OLD_CONF_PATH=/etc/casaos.conf
+CONF_FILE=${CONF_PATH}/${APP_NAME}.conf
+CONF_FILE_SAMPLE=${CONF_PATH}/${APP_NAME}.conf.sample
+
+
+if [ -f "${OLD_CONF_PATH}" ]; then
+    echo "copy old conf"
+    cp "${OLD_CONF_PATH}" "${CONF_FILE}"
+fi
+if [ ! -f "${CONF_FILE}" ]; then
+    echo "Initializing config file..."
+    cp -v "${CONF_FILE_SAMPLE}" "${CONF_FILE}"
+fi
+
+rm -rf /etc/systemd/system/casaos.service # remove old service file
+
+systemctl daemon-reload
+
+# enable service (without starting)
+echo "Enabling service..."
+systemctl enable --force --no-ask-password "${APP_NAME}.service"

build/scripts/setup/service.d/casaos/ubuntu/jammy/setup-casaos.sh

@@ -0,0 +1 @@
+../setup-casaos.sh

build/scripts/setup/service.d/casaos/ubuntu/setup-casaos.sh

@@ -0,0 +1 @@
+../debian/setup-casaos.sh

build/sysroot/etc/casaos/casaos.conf.sample

@@ -0,0 +1,22 @@
+[app]
+PAGE_SIZE = 10
+RuntimeRootPath = runtime/
+LogPath = /var/log/casaos/
+LogSaveName = log
+LogFileExt = log
+DateStrFormat = 20060102
+DateTimeFormat = 2006-01-02 15:04:05
+TimeFormat = 15:04:05
+DateFormat = 2006-01-02
+DBPath     = /var/lib/casaos
+ShellPath  = /usr/share/casaos/shell
+UserDataPath = /var/lib/casaos/conf
+
+[server]
+RunMode = release
+ServerApi = https://api.casaos.io/casaos-api
+Handshake = socket.casaos.io
+Token = 
+USBAutoMount =
+
+[system]

build/sysroot/usr/lib/systemd/system/casaos.service

@@ -0,0 +1,13 @@
+[Unit]
+After=casaos-gateway.service
+ConditionFileNotEmpty=/etc/casaos/casaos.conf
+Description=CasaOS Main Service
+
+[Service]
+ExecStart=/usr/bin/casaos -c /etc/casaos/casaos.conf
+PIDFile=/var/run/casaos/casaos.pid
+Restart=always
+Type=notify
+
+[Install]
+WantedBy=multi-user.target

build/sysroot/usr/share/casaos/cleanup/script.d/03-cleanup-casaos.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+###
+ # @Author: LinkLeong link@icewhale.org
+ # @Date: 2022-11-15 15:51:44
+ # @LastEditors: LinkLeong
+ # @LastEditTime: 2022-11-15 15:53:37
+ # @FilePath: /CasaOS/build/sysroot/usr/share/casaos/cleanup/script.d/03-cleanup-casaos.sh
+ # @Description: 
+ # @Website: https://www.casaos.io
+ # Copyright (c) 2022 by icewhale, All Rights Reserved. 
+### 
+
+set -e
+
+readonly APP_NAME_SHORT=casaos
+
+__get_setup_script_directory_by_os_release() {
+	pushd "$(dirname "${BASH_SOURCE[0]}")/../service.d/${APP_NAME_SHORT}" &>/dev/null
+
+	{
+		# shellcheck source=/dev/null
+		{
+			source /etc/os-release
+			{
+				pushd "${ID}"/"${VERSION_CODENAME}" &>/dev/null
+			} || {
+				pushd "${ID}" &>/dev/null
+			} || {
+				pushd "${ID_LIKE}" &>/dev/null
+			} || {
+				echo "Unsupported OS: ${ID} ${VERSION_CODENAME} (${ID_LIKE})"
+				exit 1
+			}
+
+			pwd
+
+			popd &>/dev/null
+
+		} || {
+			echo "Unsupported OS: unknown"
+			exit 1
+		}
+
+	}
+
+	popd &>/dev/null
+}
+
+SETUP_SCRIPT_DIRECTORY=$(__get_setup_script_directory_by_os_release)
+
+readonly SETUP_SCRIPT_DIRECTORY
+readonly SETUP_SCRIPT_FILENAME="cleanup-${APP_NAME_SHORT}.sh"
+readonly SETUP_SCRIPT_FILEPATH="${SETUP_SCRIPT_DIRECTORY}/${SETUP_SCRIPT_FILENAME}"
+
+echo "🟩 Running ${SETUP_SCRIPT_FILENAME}..."
+$SHELL "${SETUP_SCRIPT_FILEPATH}" "${BUILD_PATH}"

build/sysroot/usr/share/casaos/cleanup/service.d/casaos/arch/cleanup-casaos.sh

@@ -0,0 +1,204 @@
+#!/bin/bash
+
+set -e
+
+readonly CASA_SERVICES=(
+    "casaos.service"
+    "devmon@devmon.service"
+)
+
+readonly CASA_EXEC=casaos
+readonly CASA_CONF=/etc/casaos/casaos.conf
+readonly CASA_URL=/var/run/casaos/casaos.url
+readonly CASA_SERVICE_USR=/usr/lib/systemd/system/casaos.service
+readonly CASA_SERVICE_LIB=/lib/systemd/system/casaos.service
+readonly CASA_SERVICE_ETC=/etc/systemd/system/casaos.service
+
+# Old Casa Files
+readonly CASA_PATH=/casaOS
+readonly CASA_CONF_PATH_OLD=/etc/casaos.conf
+
+readonly aCOLOUR=(
+    '\e[38;5;154m' # green  	| Lines, bullets and separators
+    '\e[1m'        # Bold white	| Main descriptions
+    '\e[90m'       # Grey		| Credits
+    '\e[91m'       # Red		| Update notifications Alert
+    '\e[33m'       # Yellow		| Emphasis
+)
+
+Show() {
+    # OK
+    if (($1 == 0)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[0]}  OK  $COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    # FAILED
+    elif (($1 == 1)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[3]}FAILED$COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    # INFO
+    elif (($1 == 2)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[0]} INFO $COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    # NOTICE
+    elif (($1 == 3)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[4]}NOTICE$COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    fi
+}
+
+Warn() {
+    echo -e "${aCOLOUR[3]}$1$COLOUR_RESET"
+}
+
+trap 'onCtrlC' INT
+onCtrlC() {
+    echo -e "${COLOUR_RESET}"
+    exit 1
+}
+
+Detecting_CasaOS() {
+    if [[ ! -x "$(command -v ${CASA_EXEC})" ]]; then
+        Show 2 "CasaOS is not detected, exit the script."
+        exit 1
+    else
+        Show 0 "This script will delete the containers you no longer use, and the CasaOS configuration files."
+    fi
+}
+
+Uninstall_Container() {
+    if [[ ${UNINSTALL_ALL_CONTAINER} == true && "$(docker ps -aq)" != "" ]]; then
+        Show 2 "Start deleting containers."
+        docker stop "$(docker ps -aq)" || Show 1 "Failed to stop all containers."
+        docker rm "$(docker ps -aq)" || Show 1 "Failed to delete all containers."
+    fi
+}
+
+Remove_Images() {
+    if [[ ${REMOVE_IMAGES} == "all" && "$(docker images -q)" != "" ]]; then
+        Show 2 "Start deleting all images."
+        docker rmi "$(docker images -q)" || Show 1 "Failed to delete all images."
+    elif [[ ${REMOVE_IMAGES} == "unuse" && "$(docker images -q)" != "" ]]; then
+        Show 2 "Start deleting unuse images."
+        docker image prune -af || Show 1 "Failed to delete unuse images."
+    fi
+}
+
+
+Uninstall_Casaos() {
+
+    for SERVICE in "${CASA_SERVICES[@]}"; do
+        Show 2 "Stopping ${SERVICE}..."
+        systemctl disable --now "${SERVICE}" || Show 3 "Failed to disable ${SERVICE}"
+    done
+
+    # Remove Service file
+    if [[ -f ${CASA_SERVICE_USR} ]]; then
+        rm -rvf ${CASA_SERVICE_USR}
+    fi
+
+    if [[ -f ${CASA_SERVICE_LIB} ]]; then
+        rm -rvf ${CASA_SERVICE_LIB}
+    fi
+
+    if [[ -f ${CASA_SERVICE_ETC} ]]; then
+        rm -rvf ${CASA_SERVICE_ETC}
+    fi
+
+    # Old Casa Files
+    if [[ -d ${CASA_PATH} ]]; then
+        rm -rvf ${CASA_PATH} || Show 1 "Failed to delete legacy CasaOS files."
+    fi
+
+    if [[ -f ${CASA_CONF_PATH_OLD} ]]; then
+        rm -rvf ${CASA_CONF_PATH_OLD}
+    fi
+
+    # New Casa Files
+    if [[ ${REMOVE_APP_DATA} = true ]]; then
+        rm -rvf /DATA/AppData || Show 1 "Failed to delete AppData."
+    fi
+
+    rm -rvf "$(which ${CASA_EXEC})" || Show 3 "Failed to remove ${CASA_EXEC}"
+    rm -rvf ${CASA_CONF} || Show 3 "Failed to remove ${CASA_CONF}"
+    rm -rvf ${CASA_URL} || Show 3 "Failed to remove ${CASA_URL}"
+
+    rm -rvf /var/lib/casaos/app_category.json
+    rm -rvf /var/lib/casaos/app_list.json
+    rm -rvf /var/lib/casaos/docker_root
+}
+
+Detecting_CasaOS
+
+while true; do
+    echo -n -e "         ${aCOLOUR[4]}Do you want delete all containers? Y/n :${COLOUR_RESET}"
+    read -r input
+    case $input in
+    [yY][eE][sS] | [yY])
+        UNINSTALL_ALL_CONTAINER=true
+        break
+        ;;
+    [nN][oO] | [nN])
+        UNINSTALL_ALL_CONTAINER=false
+        break
+        ;;
+    *)
+        Warn "         Invalid input..."
+        ;;
+    esac
+done
+
+if [[ ${UNINSTALL_ALL_CONTAINER} == true ]]; then
+    while true; do
+        echo -n -e "         ${aCOLOUR[4]}Do you want delete all images? Y/n :${COLOUR_RESET}"
+        read -r input
+        case $input in
+        [yY][eE][sS] | [yY])
+            REMOVE_IMAGES="all"
+            break
+            ;;
+        [nN][oO] | [nN])
+            REMOVE_IMAGES="none"
+            break
+            ;;
+        *)
+            Warn "         Invalid input..."
+            ;;
+        esac
+    done
+
+    while true; do
+        echo -n -e "         ${aCOLOUR[4]}Do you want delete all AppData of CasaOS? Y/n :${COLOUR_RESET}"
+        read -r input
+        case $input in
+        [yY][eE][sS] | [yY])
+            REMOVE_APP_DATA=true
+            break
+            ;;
+        [nN][oO] | [nN])
+            REMOVE_APP_DATA=false
+            break
+            ;;
+        *)
+            Warn "         Invalid input..."
+            ;;
+        esac
+    done
+else
+    while true; do
+        echo -n -e "         ${aCOLOUR[4]}Do you want to delete all images that are not used by the container? Y/n :${COLOUR_RESET}"
+        read -r input
+        case $input in
+        [yY][eE][sS] | [yY])
+            REMOVE_IMAGES="unuse"
+            break
+            ;;
+        [nN][oO] | [nN])
+            REMOVE_IMAGES="none"
+            break
+            ;;
+        *)
+            Warn "         Invalid input..."
+            ;;
+        esac
+    done
+fi
+
+Uninstall_Container
+Remove_Images
+Uninstall_Casaos

build/sysroot/usr/share/casaos/cleanup/service.d/casaos/debian/bullseye/cleanup-casaos.sh

@@ -0,0 +1 @@
+../cleanup-casaos.sh

build/sysroot/usr/share/casaos/cleanup/service.d/casaos/debian/cleanup-casaos.sh

@@ -0,0 +1,204 @@
+#!/bin/bash
+
+set -e
+
+readonly CASA_SERVICES=(
+    "casaos.service"
+    "devmon@devmon.service"
+)
+
+readonly CASA_EXEC=casaos
+readonly CASA_CONF=/etc/casaos/casaos.conf
+readonly CASA_URL=/var/run/casaos/casaos.url
+readonly CASA_SERVICE_USR=/usr/lib/systemd/system/casaos.service
+readonly CASA_SERVICE_LIB=/lib/systemd/system/casaos.service
+readonly CASA_SERVICE_ETC=/etc/systemd/system/casaos.service
+
+# Old Casa Files
+readonly CASA_PATH=/casaOS
+readonly CASA_CONF_PATH_OLD=/etc/casaos.conf
+
+readonly aCOLOUR=(
+    '\e[38;5;154m' # green  	| Lines, bullets and separators
+    '\e[1m'        # Bold white	| Main descriptions
+    '\e[90m'       # Grey		| Credits
+    '\e[91m'       # Red		| Update notifications Alert
+    '\e[33m'       # Yellow		| Emphasis
+)
+
+Show() {
+    # OK
+    if (($1 == 0)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[0]}  OK  $COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    # FAILED
+    elif (($1 == 1)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[3]}FAILED$COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    # INFO
+    elif (($1 == 2)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[0]} INFO $COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    # NOTICE
+    elif (($1 == 3)); then
+        echo -e "${aCOLOUR[2]}[$COLOUR_RESET${aCOLOUR[4]}NOTICE$COLOUR_RESET${aCOLOUR[2]}]$COLOUR_RESET $2"
+    fi
+}
+
+Warn() {
+    echo -e "${aCOLOUR[3]}$1$COLOUR_RESET"
+}
+
+trap 'onCtrlC' INT
+onCtrlC() {
+    echo -e "${COLOUR_RESET}"
+    exit 1
+}
+
+Detecting_CasaOS() {
+    if [[ ! -x "$(command -v ${CASA_EXEC})" ]]; then
+        Show 2 "CasaOS is not detected, exit the script."
+        exit 1
+    else
+        Show 0 "This script will delete the containers you no longer use, and the CasaOS configuration files."
+    fi
+}
+
+Uninstall_Container() {
+    if [[ ${UNINSTALL_ALL_CONTAINER} == true && "$(docker ps -aq)" != "" ]]; then
+        Show 2 "Start deleting containers."
+        docker stop "$(docker ps -aq)" || Show 1 "Failed to stop all containers."
+        docker rm "$(docker ps -aq)" || Show 1 "Failed to delete all containers."
+    fi
+}
+
+Remove_Images() {
+    if [[ ${REMOVE_IMAGES} == "all" && "$(docker images -q)" != "" ]]; then
+        Show 2 "Start deleting all images."
+        docker rmi "$(docker images -q)" || Show 1 "Failed to delete all images."
+    elif [[ ${REMOVE_IMAGES} == "unuse" && "$(docker images -q)" != "" ]]; then
+        Show 2 "Start deleting unuse images."
+        docker image prune -af || Show 1 "Failed to delete unuse images."
+    fi
+}
+
+
+Uninstall_Casaos() {
+
+    for SERVICE in "${CASA_SERVICES[@]}"; do
+        Show 2 "Stopping ${SERVICE}..."
+        systemctl disable --now "${SERVICE}" || Show 3 "Failed to disable ${SERVICE}"
+    done
+
+    # Remove Service file
+    if [[ -f ${CASA_SERVICE_USR} ]]; then
+        rm -rvf ${CASA_SERVICE_USR}
+    fi
+
+    if [[ -f ${CASA_SERVICE_LIB} ]]; then
+        rm -rvf ${CASA_SERVICE_LIB}
+    fi
+
+    if [[ -f ${CASA_SERVICE_ETC} ]]; then
+        rm -rvf ${CASA_SERVICE_ETC}
+    fi
+
+    # Old Casa Files
+    if [[ -d ${CASA_PATH} ]]; then
+        rm -rvf ${CASA_PATH} || Show 1 "Failed to delete legacy CasaOS files."
+    fi
+
+    if [[ -f ${CASA_CONF_PATH_OLD} ]]; then
+        rm -rvf ${CASA_CONF_PATH_OLD}
+    fi
+
+    # New Casa Files
+    if [[ ${REMOVE_APP_DATA} = true ]]; then
+        rm -rvf /DATA/AppData || Show 1 "Failed to delete AppData."
+    fi
+
+    rm -rvf "$(which ${CASA_EXEC})" || Show 3 "Failed to remove ${CASA_EXEC}"
+    rm -rvf ${CASA_CONF} || Show 3 "Failed to remove ${CASA_CONF}"
+    rm -rvf ${CASA_URL} || Show 3 "Failed to remove ${CASA_URL}"
+
+    rm -rvf /var/lib/casaos/app_category.json
+    rm -rvf /var/lib/casaos/app_list.json
+    rm -rvf /var/lib/casaos/docker_root
+}
+
+Detecting_CasaOS
+
+while true; do
+    echo -n -e "         ${aCOLOUR[4]}Do you want delete all containers? Y/n :${COLOUR_RESET}"
+    read -r input
+    case $input in
+    [yY][eE][sS] | [yY])
+        UNINSTALL_ALL_CONTAINER=true
+        break
+        ;;
+    [nN][oO] | [nN])
+        UNINSTALL_ALL_CONTAINER=false
+        break
+        ;;
+    *)
+        Warn "         Invalid input..."
+        ;;
+    esac
+done
+
+if [[ ${UNINSTALL_ALL_CONTAINER} == true ]]; then
+    while true; do
+        echo -n -e "         ${aCOLOUR[4]}Do you want delete all images? Y/n :${COLOUR_RESET}"
+        read -r input
+        case $input in
+        [yY][eE][sS] | [yY])
+            REMOVE_IMAGES="all"
+            break
+            ;;
+        [nN][oO] | [nN])
+            REMOVE_IMAGES="none"
+            break
+            ;;
+        *)
+            Warn "         Invalid input..."
+            ;;
+        esac
+    done
+
+    while true; do
+        echo -n -e "         ${aCOLOUR[4]}Do you want delete all AppData of CasaOS? Y/n :${COLOUR_RESET}"
+        read -r input
+        case $input in
+        [yY][eE][sS] | [yY])
+            REMOVE_APP_DATA=true
+            break
+            ;;
+        [nN][oO] | [nN])
+            REMOVE_APP_DATA=false
+            break
+            ;;
+        *)
+            Warn "         Invalid input..."
+            ;;
+        esac
+    done
+else
+    while true; do
+        echo -n -e "         ${aCOLOUR[4]}Do you want to delete all images that are not used by the container? Y/n :${COLOUR_RESET}"
+        read -r input
+        case $input in
+        [yY][eE][sS] | [yY])
+            REMOVE_IMAGES="unuse"
+            break
+            ;;
+        [nN][oO] | [nN])
+            REMOVE_IMAGES="none"
+            break
+            ;;
+        *)
+            Warn "         Invalid input..."
+            ;;
+        esac
+    done
+fi
+
+Uninstall_Container
+Remove_Images
+Uninstall_Casaos

build/sysroot/usr/share/casaos/cleanup/service.d/casaos/ubuntu/cleanup-casaos.sh

@@ -0,0 +1 @@
+../debian/cleanup-casaos.sh

build/sysroot/usr/share/casaos/cleanup/service.d/casaos/ubuntu/jammy/cleanup-casaos.sh

@@ -0,0 +1 @@
+../../debian/bullseye/cleanup-casaos.sh

build/sysroot/usr/share/casaos/shell/helper.sh

@@ -385,5 +385,4 @@ CheckServiceStatus(){
 }
 UDEVILUmount(){
   $sudo_cmd udevil umount -f $1
-}
-
+}

build/sysroot/usr/share/casaos/shell/update.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+###
+ # @Author:  LinkLeong link@icewhale.com
+ # @Date: 2022-06-30 10:08:33
+ # @LastEditors: LinkLeong
+ # @LastEditTime: 2022-09-01 22:33:06
+ # @FilePath: /CasaOS/build/sysroot/usr/share/casaos/shell/update.sh
+ # @Description:
+### 
+
+
+curl -fsSL https://raw.githubusercontent.com/IceWhaleTech/get/main/update.sh | bash

cmd/migration-tool/log.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+type Logger struct {
+	DebugMode bool
+
+	_debug *log.Logger
+	_info  *log.Logger
+	_error *log.Logger
+}
+
+func NewLogger() *Logger {
+	return &Logger{
+		DebugMode: false,
+		_debug:    log.New(os.Stdout, "DEBUG: ", 0),
+		_info:     log.New(os.Stdout, "", 0),
+		_error:    log.New(os.Stderr, "ERROR: ", 0),
+	}
+}
+
+func (l *Logger) Debug(format string, v ...interface{}) {
+	if l.DebugMode {
+		l._debug.Printf(format, v...)
+	}
+}
+
+func (l *Logger) Info(format string, v ...interface{}) {
+	l._info.Printf(format, v...)
+}
+
+func (l *Logger) Error(format string, v ...interface{}) {
+	l._error.Printf(format, v...)
+}

cmd/migration-tool/main.go

@@ -0,0 +1,120 @@
+/*
+ * @Author: LinkLeong link@icewhale.org
+ * @Date: 2022-08-23 18:09:11
+ * @LastEditors: LinkLeong
+ * @LastEditTime: 2022-08-31 14:17:51
+ * @FilePath: /CasaOS/cmd/migration-tool/main.go
+ * @Description:
+ * @Website: https://www.casaos.io
+ * Copyright (c) 2022 by icewhale, All Rights Reserved.
+ */
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	interfaces "github.com/IceWhaleTech/CasaOS-Common"
+	"github.com/IceWhaleTech/CasaOS-Common/utils/systemctl"
+	"github.com/IceWhaleTech/CasaOS-Gateway/common"
+	"github.com/IceWhaleTech/CasaOS/pkg/config"
+	"github.com/IceWhaleTech/CasaOS/pkg/sqlite"
+	"github.com/IceWhaleTech/CasaOS/service"
+	"gorm.io/gorm"
+)
+
+const (
+	casaosServiceName = "casaos.service"
+)
+
+var (
+	_logger  *Logger
+	sqliteDB *gorm.DB
+)
+
+var (
+	configFlag = ""
+	dbFlag     = ""
+)
+
+func init() {
+	config.InitSetup(configFlag)
+
+	if len(dbFlag) == 0 {
+		dbFlag = config.AppInfo.DBPath + "/db"
+	}
+
+	sqliteDB = sqlite.GetDb(dbFlag)
+	// gredis.GetRedisConn(config.RedisInfo),
+
+	service.MyService = service.NewService(sqliteDB, "")
+}
+
+func main() {
+	versionFlag := flag.Bool("v", false, "version")
+	debugFlag := flag.Bool("d", true, "debug")
+	forceFlag := flag.Bool("f", true, "force")
+	flag.Parse()
+	_logger = NewLogger()
+	if *versionFlag {
+		fmt.Println(common.Version)
+		os.Exit(0)
+	}
+
+	if os.Getuid() != 0 {
+		os.Exit(1)
+	}
+
+	if *debugFlag {
+		_logger.DebugMode = true
+	}
+
+	if !*forceFlag {
+		serviceEnabled, err := systemctl.IsServiceEnabled(casaosServiceName)
+		if err != nil {
+			panic(err)
+		}
+
+		if serviceEnabled {
+			_logger.Info("%s is already enabled. If migration is still needed, try with -f.", casaosServiceName)
+			os.Exit(1)
+		}
+	}
+
+	migrationTools := []interfaces.MigrationTool{
+		// nothing to migrate from last version
+	}
+
+	var selectedMigrationTool interfaces.MigrationTool
+
+	// look for the right migration tool matching current version
+	for _, tool := range migrationTools {
+		migrationNeeded, err := tool.IsMigrationNeeded()
+		if err != nil {
+			panic(err)
+		}
+
+		if migrationNeeded {
+			selectedMigrationTool = tool
+			break
+		}
+	}
+
+	if selectedMigrationTool == nil {
+		_logger.Error("selectedMigrationTool is null")
+		return
+	}
+
+	if err := selectedMigrationTool.PreMigrate(); err != nil {
+		panic(err)
+	}
+
+	if err := selectedMigrationTool.Migrate(); err != nil {
+		panic(err)
+	}
+
+	if err := selectedMigrationTool.PostMigrate(); err != nil {
+		_logger.Error("Migration succeeded, but post-migration failed: %s", err)
+	}
+}

cmd/migration-tool/migration-sample.go

@@ -0,0 +1,60 @@
+/*
+ * @Author: LinkLeong link@icewhale.org
+ * @Date: 2022-08-24 17:36:00
+ * @LastEditors: LinkLeong
+ * @LastEditTime: 2022-09-05 11:24:27
+ * @FilePath: /CasaOS/cmd/migration-tool/migration-034-035.go
+ * @Description:
+ * @Website: https://www.casaos.io
+ * Copyright (c) 2022 by icewhale, All Rights Reserved.
+ */
+package main
+
+import (
+	interfaces "github.com/IceWhaleTech/CasaOS-Common"
+	"github.com/IceWhaleTech/CasaOS-Common/utils/version"
+)
+
+type migrationTool struct{}
+
+func (u *migrationTool) IsMigrationNeeded() (bool, error) {
+	majorVersion, minorVersion, patchVersion, err := version.DetectLegacyVersion()
+	if err != nil {
+		if err == version.ErrLegacyVersionNotFound {
+			return false, nil
+		}
+
+		return false, err
+	}
+
+	if majorVersion > 0 {
+		return false, nil
+	}
+
+	if minorVersion > 3 {
+		return false, nil
+	}
+
+	if minorVersion == 3 && patchVersion > 5 {
+		return false, nil
+	}
+
+	_logger.Info("Migration is needed for a CasaOS version 0.3.5 and older...")
+	return true, nil
+}
+
+func (u *migrationTool) PreMigrate() error {
+	return nil
+}
+
+func (u *migrationTool) Migrate() error {
+	return nil
+}
+
+func (u *migrationTool) PostMigrate() error {
+	return nil
+}
+
+func NewMigrationToolFor_036() interfaces.MigrationTool {
+	return &migrationTool{}
+}

conf/conf.conf.sample

@@ -11,14 +11,15 @@ DateFormat = 2006-01-02
 DBPath     = /var/lib/casaos
 ShellPath  = /usr/share/casaos/shell
 UserDataPath = /var/lib/casaos/conf
-TempPath    = /var/lib/casaos/temp
 
 [server]
-HttpPort = 80
 RunMode = release
 ServerApi = https://api.casaos.io/casaos-api
 Handshake = socket.casaos.io
 Token = 
 USBAutoMount =
 
-[system]
+[system]
+
+[common]
+RuntimePath=/var/run/casaos

go.mod

@@ -4,77 +4,39 @@ go 1.16
 
 require (
 	github.com/Curtis-Milo/nat-type-identifier-go v0.0.0-20220215191915-18d42168c63d
-	github.com/Microsoft/go-winio v0.5.0 // indirect
-	github.com/Microsoft/hcsshim v0.8.22 // indirect
+	github.com/IceWhaleTech/CasaOS-Common v0.4.0-alpha1
+	github.com/IceWhaleTech/CasaOS-Gateway v0.3.6
 	github.com/ambelovsky/go-structs v1.1.0 // indirect
 	github.com/ambelovsky/gosf v0.0.0-20201109201340-237aea4d6109
 	github.com/ambelovsky/gosf-socketio v0.0.0-20201109193639-add9d32f8b19 // indirect
-	github.com/bits-and-blooms/bitset v1.2.1 // indirect
-	github.com/containerd/containerd v1.5.7
-	github.com/containerd/continuity v0.2.0 // indirect
+	github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e
 	github.com/disintegration/imaging v1.6.2
-	github.com/docker/distribution v2.8.0+incompatible // indirect
-	github.com/docker/docker v20.10.7+incompatible
-	github.com/docker/go-connections v0.4.0
 	github.com/dsoprea/go-exif/v3 v3.0.0-20210625224831-a6301f85c82b
 	github.com/dsoprea/go-logging v0.0.0-20200710184922-b02d349568dd // indirect
-	github.com/gin-contrib/gzip v0.0.2
-	github.com/gin-gonic/gin v1.7.2
+	github.com/gin-contrib/gzip v0.0.6
+	github.com/gin-gonic/gin v1.8.1
+	github.com/glebarez/sqlite v1.5.0
 	github.com/go-ini/ini v1.62.0
-	github.com/go-playground/validator/v10 v10.6.1 // indirect
-	github.com/gogo/googleapis v1.4.1 // indirect
-	github.com/golang-jwt/jwt/v4 v4.4.1
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/mock v1.6.0
 	github.com/gomodule/redigo v1.8.5
 	github.com/google/go-github/v36 v36.0.0
-	github.com/google/uuid v1.3.0 // indirect
 	github.com/googollee/go-socket.io v1.6.2
-	github.com/gorilla/mux v1.8.0 // indirect
-	github.com/gorilla/websocket v1.4.2
+	github.com/gorilla/websocket v1.5.0
 	github.com/hirochachacha/go-smb2 v1.1.0
-	github.com/jinzhu/copier v0.3.2
-	github.com/json-iterator/go v1.1.11 // indirect
-	github.com/klauspost/compress v1.13.6 // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/lucas-clemente/quic-go v0.25.0
-	github.com/mattn/go-isatty v0.0.14 // indirect
-	github.com/mattn/go-sqlite3 v1.14.11 // indirect
 	github.com/mholt/archiver/v3 v3.5.1
-	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.0.2 // indirect
-	github.com/opencontainers/selinux v1.8.5 // indirect
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pilebones/go-udev v0.9.0
-	github.com/pkg/errors v0.9.1
-	github.com/prometheus/procfs v0.7.3 // indirect
 	github.com/robfig/cron v1.2.0
 	github.com/satori/go.uuid v1.2.0
 	github.com/shirou/gopsutil/v3 v3.22.7
-	github.com/sirupsen/logrus v1.8.1
 	github.com/smartystreets/assertions v1.2.0 // indirect
 	github.com/smartystreets/goconvey v1.6.4 // indirect
 	github.com/stretchr/testify v1.8.0
 	github.com/tidwall/gjson v1.10.2
-	github.com/ugorji/go v1.2.6 // indirect
-	go.opencensus.io v0.23.0 // indirect
-	go.uber.org/zap v1.10.0
-	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
+	go.uber.org/zap v1.21.0
+	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
 	golang.org/x/mod v0.5.0 // indirect
-	golang.org/x/net v0.0.0-20211020060615-d418f374d309 // indirect
-	golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f
-	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
-	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect
+	golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5
 	golang.org/x/tools v0.1.7 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0 // indirect
-	google.golang.org/grpc v1.41.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
-	gopkg.in/ini.v1 v1.62.0 // indirect
-	gopkg.in/natefinch/lumberjack.v2 v2.0.0
-	gorm.io/driver/sqlite v1.2.6
-	gorm.io/gorm v1.22.5
+	gorm.io/gorm v1.24.0
 )

interfaces/migrationTool.go

@@ -0,0 +1,18 @@
+/*
+ * @Author: LinkLeong link@icewhale.org
+ * @Date: 2022-08-24 17:37:36
+ * @LastEditors: LinkLeong
+ * @LastEditTime: 2022-08-24 17:38:48
+ * @FilePath: /CasaOS/interfaces/migrationTool.go
+ * @Description:
+ * @Website: https://www.casaos.io
+ * Copyright (c) 2022 by icewhale, All Rights Reserved.
+ */
+package interfaces
+
+type MigrationTool interface {
+	IsMigrationNeeded() (bool, error)
+	PostMigrate() error
+	Migrate() error
+	PreMigrate() error
+}

main.go

@@ -3,61 +3,61 @@ package main
 import (
 	"flag"
 	"fmt"
+	"net"
 	"net/http"
+	"path/filepath"
 	"time"
 
+	"github.com/IceWhaleTech/CasaOS-Common/model"
+	"github.com/IceWhaleTech/CasaOS-Common/utils/logger"
 	"github.com/IceWhaleTech/CasaOS/model/notify"
 	"github.com/IceWhaleTech/CasaOS/pkg/cache"
 	"github.com/IceWhaleTech/CasaOS/pkg/config"
 	"github.com/IceWhaleTech/CasaOS/pkg/sqlite"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/encryption"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/random"
+	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
 	"github.com/IceWhaleTech/CasaOS/route"
 	"github.com/IceWhaleTech/CasaOS/service"
 	"github.com/IceWhaleTech/CasaOS/types"
+	"github.com/coreos/go-systemd/daemon"
+	"go.uber.org/zap"
 
 	"github.com/robfig/cron"
 	"gorm.io/gorm"
 )
 
+const LOCALHOST = "127.0.0.1"
+
 var sqliteDB *gorm.DB
 
-var configFlag = flag.String("c", "", "config address")
-var dbFlag = flag.String("db", "", "db path")
-var resetUser = flag.Bool("ru", false, "reset user")
-var user = flag.String("user", "", "user name")
-var version = flag.Bool("v", false, "show version")
+var (
+	configFlag  = flag.String("c", "", "config address")
+	dbFlag      = flag.String("db", "", "db path")
+	versionFlag = flag.Bool("v", false, "version")
+)
 
 func init() {
 	flag.Parse()
-	if *version {
+	if *versionFlag {
 		fmt.Println("v" + types.CURRENTVERSION)
 		return
 	}
 	config.InitSetup(*configFlag)
-	config.UpdateSetup()
 
-	loger.LogInit()
+	logger.LogInit(config.AppInfo.LogPath, config.AppInfo.LogSaveName, config.AppInfo.LogFileExt)
 	if len(*dbFlag) == 0 {
 		*dbFlag = config.AppInfo.DBPath + "/db"
 	}
 
 	sqliteDB = sqlite.GetDb(*dbFlag)
-	//gredis.GetRedisConn(config.RedisInfo),
+	// gredis.GetRedisConn(config.RedisInfo),
 
-	service.MyService = service.NewService(sqliteDB)
+	service.MyService = service.NewService(sqliteDB, config.CommonInfo.RuntimePath)
 
 	service.Cache = cache.Init()
 
-	service.GetToken()
+	service.GetCPUThermalZone()
 
-	service.NewVersionApp = make(map[string]string)
 	route.InitFunction()
-
-	// go service.LoopFriend()
-	// go service.MyService.App().CheckNewImage()
-
 }
 
 // @title casaOS API
@@ -73,43 +73,25 @@ func init() {
 // @BasePath /v1
 func main() {
 	service.NotifyMsg = make(chan notify.Message, 10)
-	if *version {
-		return
-	}
-	if *resetUser {
-		if user == nil || len(*user) == 0 {
-			fmt.Println("user is empty")
-			return
-		}
-		userData := service.MyService.User().GetUserAllInfoByName(*user)
-		if userData.Id == 0 {
-			fmt.Println("user not exist")
-			return
-		}
-		password := random.RandomString(6, false)
-		userData.Password = encryption.GetMD5ByStr(password)
-		service.MyService.User().UpdateUserPassword(userData)
-		fmt.Println("User reset successful")
-		fmt.Println("UserName:" + userData.Username)
-		fmt.Println("Password:" + password)
+	if *versionFlag {
 		return
 	}
 	go route.SocketInit(service.NotifyMsg)
-	go route.MonitoryUSB()
-	//model.Setup()
-	//gredis.Setup()
+	// model.Setup()
+	// gredis.Setup()
+
 	r := route.InitRouter()
-	//service.SyncTask(sqliteDB)
+	// service.SyncTask(sqliteDB)
 	cron2 := cron.New()
-	//every day execution
+	// every day execution
 
 	err := cron2.AddFunc("0/5 * * * * *", func() {
 		if service.ClientCount > 0 {
-			//route.SendNetINfoBySocket()
-			//route.SendCPUBySocket()
-			//route.SendMemBySocket()
+			// route.SendNetINfoBySocket()
+			// route.SendCPUBySocket()
+			// route.SendMemBySocket()
 			// route.SendDiskBySocket()
-			//route.SendUSBBySocket()
+			// route.SendUSBBySocket()
 			route.SendAllHardwareStatusBySocket()
 		}
 	})
@@ -117,18 +99,64 @@ func main() {
 		fmt.Println(err)
 	}
 	cron2.Start()
+
 	defer cron2.Stop()
-	s := &http.Server{
-		Addr:           fmt.Sprintf(":%v", config.ServerInfo.HttpPort),
-		Handler:        r,
-		ReadTimeout:    60 * time.Second,
-		WriteTimeout:   60 * time.Second,
-		MaxHeaderBytes: 1 << 20,
+
+	listener, err := net.Listen("tcp", net.JoinHostPort(LOCALHOST, "0"))
+	if err != nil {
+		panic(err)
+	}
+	routers := []string{"sys", "port", "file", "folder", "batch", "image", "samba", "notify"}
+	for _, v := range routers {
+		err = service.MyService.Gateway().CreateRoute(&model.Route{
+			Path:   "/v1/" + v,
+			Target: "http://" + listener.Addr().String(),
+		})
+
+		if err != nil {
+			fmt.Println("err", err)
+			panic(err)
+		}
+	}
+	go func() {
+		time.Sleep(time.Second * 2)
+		// v0.3.6
+		if config.ServerInfo.HttpPort != "" {
+			changePort := model.ChangePortRequest{}
+			changePort.Port = config.ServerInfo.HttpPort
+			err := service.MyService.Gateway().ChangePort(&changePort)
+			if err == nil {
+				config.Cfg.Section("server").Key("HttpPort").SetValue("")
+				config.Cfg.SaveTo(config.SystemConfigInfo.ConfigPath)
+			}
+		}
+	}()
+
+	urlFilePath := filepath.Join(config.CommonInfo.RuntimePath, "casaos.url")
+	if err := file.CreateFileAndWriteContent(urlFilePath, "http://"+listener.Addr().String()); err != nil {
+		logger.Error("error when creating address file", zap.Error(err),
+			zap.Any("address", listener.Addr().String()),
+			zap.Any("filepath", urlFilePath),
+		)
 	}
 
-	s.ListenAndServe()
+	if supported, err := daemon.SdNotify(false, daemon.SdNotifyReady); err != nil {
+		logger.Error("Failed to notify systemd that casaos main service is ready", zap.Any("error", err))
+	} else if supported {
+		logger.Info("Notified systemd that casaos main service is ready")
+	} else {
+		logger.Info("This process is not running as a systemd service.")
+	}
 
-	// if err := r.Run(fmt.Sprintf(":%v", config.ServerInfo.HttpPort)); err != nil {
-	// 	fmt.Println("failed run app: ", err)
-	// }
+	s := &http.Server{
+		Handler:           r,
+		ReadHeaderTimeout: 5 * time.Second, // fix G112: Potential slowloris attack (see https://github.com/securego/gosec)
+	}
+
+	logger.Info("CasaOS main service is listening...", zap.Any("address", listener.Addr().String()))
+
+	err = s.Serve(listener) // not using http.serve() to fix G114: Use of net/http serve function that has no support for setting timeouts (see https://github.com/securego/gosec)
+	if err != nil {
+		panic(err)
+	}
 }

middleware/gin.go

@@ -1,62 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2021-10-08 10:29:08
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-22 11:06:07
- * @FilePath: /CasaOS/middleware/gin.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package middleware
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-	"github.com/gin-gonic/gin"
-	"go.uber.org/zap"
-)
-
-func Cors() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		method := c.Request.Method
-
-		c.Header("Access-Control-Allow-Origin", "*")
-		c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE,UPDATE")
-		//允许跨域设置可以返回其他子段，可以自定义字段
-		c.Header("Access-Control-Allow-Headers", "Authorization, Content-Length, X-CSRF-Token, Token,session,Language,Content-Type,Access-Control-Allow-Origin,Access-Control-Allow-Headers,Access-Control-Allow-Methods,Connection,Host,Origin,Referer,User-Agent,X-Requested-With")
-		// 允许浏览器（客户端）可以解析的头部 （重要）
-		c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers")
-		//c.Writer.Header().Set("Access-Control-Allow-Headers", "Accept, Authorization, Content-Type, Content-Length, X-CSRF-Token, Token, session, Origin, Host, Connection, Accept-Encoding, Accept-Language, X-Requested-With")
-		//设置缓存时间
-		c.Header("Access-Control-Max-Age", "172800")
-		c.Header("Access-Control-Allow-Credentials", "true")
-		c.Set("Content-Type", "application/json")
-		//}
-
-		//允许类型校验
-		if method == "OPTIONS" {
-			c.JSON(http.StatusOK, "ok!")
-		}
-
-		defer func() {
-			if err := recover(); err != nil {
-				fmt.Println(err)
-			}
-		}()
-
-		c.Next()
-	}
-}
-func WriteLog() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		if !strings.Contains(c.Request.URL.String(), "password") {
-			loger.Info("request:", zap.Any("path", c.Request.URL.String()), zap.Any("param", c.Params), zap.Any("query", c.Request.URL.Query()), zap.Any("method", c.Request.Method))
-			c.Next()
-		}
-
-	}
-}

model/app.go

@@ -1,128 +0,0 @@
-package model
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-	"time"
-)
-
-type ServerAppListCollection struct {
-	List      []ServerAppList `json:"list"`
-	Recommend []ServerAppList `json:"recommend"`
-	Community []ServerAppList `json:"community"`
-	Version   string          `json:"version"`
-}
-
-// @tiger - 对于用于出参的数据结构，静态信息（例如 title）和
-//          动态信息（例如 state、query_count）应该划分到不同的数据结构中
-//
-//          这样的好处是
-//          1 - 多次获取动态信息时可以减少出参复杂度，因为静态信息只获取一次就好
-//          2 - 在未来的迭代中，可以降低维护成本（所有字段都展开放在一个层级维护成本略高）
-//
-//          另外，一些针对性字段，例如 Docker 相关的，可以用 map 来保存。
-//          这样在未来增加多态 App，例如 Snap，不需要维护多个结构，或者一个结构保存不必要的字段
-type ServerAppList struct {
-	Id             uint      `gorm:"column:id;primary_key" json:"id"`
-	Title          string    `json:"title"`
-	Description    string    `json:"description"`
-	Tagline        string    `json:"tagline"`
-	Tags           Strings   `gorm:"type:json" json:"tags"`
-	Icon           string    `json:"icon"`
-	ScreenshotLink Strings   `gorm:"type:json" json:"screenshot_link"`
-	Category       string    `json:"category"`
-	CategoryId     int       `json:"category_id"`
-	CategoryFont   string    `json:"category_font"`
-	PortMap        string    `json:"port_map"`
-	ImageVersion   string    `json:"image_version"`
-	Tip            string    `json:"tip"`
-	Envs           EnvArray  `json:"envs"`
-	Ports          PortArray `json:"ports"`
-	Volumes        PathArray `json:"volumes"`
-	Devices        PathArray `json:"devices"`
-	NetworkModel   string    `json:"network_model"`
-	Image          string    `json:"image"`
-	Index          string    `json:"index"`
-	CreatedAt      time.Time `json:"created_at"`
-	UpdatedAt      time.Time `json:"updated_at"`
-	State          int       `json:"state"`
-	Author         string    `json:"author"`
-	MinMemory      int       `json:"min_memory"`
-	MinDisk        int       `json:"min_disk"`
-	MaxMemory      uint64    `json:"max_memory"`
-	Thumbnail      string    `json:"thumbnail"`
-	Healthy        string    `json:"healthy"`
-	Plugins        Strings   `json:"plugins"`
-	Origin         string    `json:"origin"`
-	Type           int       `json:"type"`
-	QueryCount     int       `json:"query_count"`
-	Developer      string    `json:"developer"`
-	HostName       string    `json:"host_name"`
-	Privileged     bool      `json:"privileged"`
-	CapAdd         Strings   `json:"cap_add"`
-	Cmd            Strings   `json:"cmd"`
-}
-
-type Ports struct {
-	ContainerPort uint   `json:"container_port"`
-	CommendPort   int    `json:"commend_port"`
-	Desc          string `json:"desc"`
-	Type          int    `json:"type"` //  1:必选 2:可选 3:默认值不必显示 4:系统处理  5:container内容也可编辑
-}
-
-type Volume struct {
-	ContainerPath string `json:"container_path"`
-	Path          string `json:"path"`
-	Desc          string `json:"desc"`
-	Type          int    `json:"type"` //  1:必选 2:可选 3:默认值不必显示 4:系统处理   5:container内容也可编辑
-}
-
-type Envs struct {
-	Name  string `json:"name"`
-	Value string `json:"value"`
-	Desc  string `json:"desc"`
-	Type  int    `json:"type"` //  1:必选 2:可选 3:默认值不必显示 4:系统处理 5:container内容也可编辑
-}
-
-type Devices struct {
-	ContainerPath string `json:"container_path"`
-	Path          string `json:"path"`
-	Desc          string `json:"desc"`
-	Type          int    `json:"type"` //  1:必选 2:可选 3:默认值不必显示 4:系统处理 5:container内容也可编辑
-}
-
-type configures struct {
-	TcpPorts []Ports   `json:"tcp_ports"`
-	UdpPorts []Ports   `json:"udp_ports"`
-	Envs     []Envs    `json:"envs"`
-	Volumes  []Volume  `json:"volumes"`
-	Devices  []Devices `json:"devices"`
-}
-
-/****************使gorm支持[]string结构*******************/
-type Strings []string
-
-func (c Strings) Value() (driver.Value, error) {
-	b, err := json.Marshal(c)
-	return string(b), err
-}
-
-func (c *Strings) Scan(input interface{}) error {
-	return json.Unmarshal(input.([]byte), c)
-}
-
-/****************使gorm支持[]string结构*******************/
-
-/****************使gorm支持[]string结构*******************/
-type MapStrings []map[string]string
-
-func (c MapStrings) Value() (driver.Value, error) {
-	b, err := json.Marshal(c)
-	return string(b), err
-}
-
-func (c *MapStrings) Scan(input interface{}) error {
-	return json.Unmarshal(input.([]byte), c)
-}
-
-/****************使gorm支持[]string结构*******************/

model/category.go

@@ -1,23 +0,0 @@
-/*
- * @Author: link a624669980@163.com
- * @Date: 2022-05-16 17:37:08
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-13 10:46:38
- * @FilePath: /CasaOS/model/category.go
- * @Description:
- */
-package model
-
-type ServerCategoryList struct {
-	Version string         `json:"version"`
-	Item    []CategoryList `json:"item"`
-}
-type CategoryList struct {
-	Id uint `gorm:"column:id;primary_key" json:"id"`
-	//CreatedAt time.Time `json:"created_at"`
-	//
-	//UpdatedAt time.Time `json:"updated_at"`
-	Font  string `json:"font"` // @tiger - 如果这个和前端有关，应该不属于后端的出参范围，而是前端去界定
-	Name  string `json:"name"`
-	Count uint   `json:"count"` // @tiger - count 属于动态信息，应该单独放在一个出参结构中（原因见另外一个关于 静态/动态 出参的注释）
-}

model/disk.go

@@ -1,98 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-07-13 10:43:45
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-08-03 14:45:35
- * @FilePath: /CasaOS/model/disk.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package model
-
-type LSBLKModel struct {
-	Name        string       `json:"name"`
-	FsType      string       `json:"fstype"`
-	Size        uint64       `json:"size"`
-	FSSize      string       `json:"fssize"`
-	Path        string       `json:"path"`
-	Model       string       `json:"model"` //设备标识符
-	RM          bool         `json:"rm"`    //是否为可移动设备
-	RO          bool         `json:"ro"`    //是否为只读设备
-	State       string       `json:"state"`
-	PhySec      int          `json:"phy-sec"` //物理扇区大小
-	Type        string       `json:"type"`
-	Vendor      string       `json:"vendor"`  //供应商
-	Rev         string       `json:"rev"`     //修订版本
-	FSAvail     string       `json:"fsavail"` //可用空间
-	FSUse       string       `json:"fsuse%"`  //已用百分比
-	MountPoint  string       `json:"mountpoint"`
-	Format      string       `json:"format"`
-	Health      string       `json:"health"`
-	HotPlug     bool         `json:"hotplug"`
-	UUID        string       `json:"uuid"`
-	FSUsed      string       `json:"fsused"`
-	Temperature int          `json:"temperature"`
-	Tran        string       `json:"tran"`
-	MinIO       uint64       `json:"min-io"`
-	UsedPercent float64      `json:"used_percent"`
-	Serial      string       `json:"serial"`
-	Children    []LSBLKModel `json:"children"`
-	SubSystems  string       `json:"subsystems"`
-	Label       string       `json:"label"`
-	//详情特有
-	StartSector uint64 `json:"start_sector,omitempty"`
-	Rota        bool   `json:"rota"` //true(hhd) false(ssd)
-	DiskType    string `json:"disk_type"`
-	EndSector   uint64 `json:"end_sector,omitempty"`
-}
-
-type Drive struct {
-	Name           string `json:"name"`
-	Size           uint64 `json:"size"`
-	Model          string `json:"model"`
-	Health         string `json:"health"`
-	Temperature    int    `json:"temperature"`
-	DiskType       string `json:"disk_type"`
-	NeedFormat     bool   `json:"need_format"`
-	Serial         string `json:"serial"`
-	Path           string `json:"path"`
-	ChildrenNumber int    `json:"children_number"`
-}
-
-type DriveUSB struct {
-	Name     string        `json:"name"`
-	Size     uint64        `json:"size"`
-	Model    string        `json:"model"`
-	Avail    uint64        `json:"avail"`
-	Children []USBChildren `json:"children"`
-}
-type USBChildren struct {
-	Name       string `json:"name"`
-	Size       uint64 `json:"size"`
-	Avail      uint64 `json:"avail"`
-	MountPoint string `json:"mount_point"`
-}
-
-type Storage struct {
-	MountPoint string `json:"mount_point"`
-	Size       string `json:"size"`
-	Avail      string `json:"avail"` //可用空间
-	Type       string `json:"type"`
-	Path       string `json:"path"`
-	DriveName  string `json:"drive_name"`
-	Label      string `json:"label"`
-}
-type Storages struct {
-	DiskName string    `json:"disk_name"`
-	Size     uint64    `json:"size"`
-	Path     string    `json:"path"`
-	Children []Storage `json:"children"`
-}
-
-type Summary struct {
-	Size   uint64 `json:"size"`
-	Avail  uint64 `json:"avail"` //可用空间
-	Health bool   `json:"health"`
-	Used   uint64 `json:"used"`
-}

model/docker.go

@@ -1,18 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2021-12-08 18:10:25
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-13 10:49:16
- * @FilePath: /CasaOS/model/docker.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package model
-
-type DockerStatsModel struct {
-	Icon     string      `json:"icon"`
-	Title    string      `json:"title"`
-	Data     interface{} `json:"data"`
-	Previous interface{} `json:"previous"`
-}

model/manifest.go

@@ -1,133 +0,0 @@
-package model
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-)
-
-type TcpPorts struct {
-	Desc          string `json:"desc"`
-	ContainerPort int    `json:"container_port"`
-}
-type UdpPorts struct {
-	Desc          string `json:"desc"`
-	ContainerPort int    `json:"container_port"`
-}
-
-/*******************使用gorm支持json************************************/
-
-type PortMap struct {
-	ContainerPort string `json:"container"`
-	CommendPort   string `json:"host"`
-	Protocol      string `json:"protocol"`
-	Desc          string `json:"desc"`
-	Type          int    `json:"type"`
-}
-
-type PortArray []PortMap
-
-// Value 实现方法
-func (p PortArray) Value() (driver.Value, error) {
-	return json.Marshal(p)
-}
-
-// Scan 实现方法
-func (p *PortArray) Scan(input interface{}) error {
-	return json.Unmarshal(input.([]byte), p)
-}
-
-/************************************************************************/
-
-/*******************使用gorm支持json************************************/
-
-type Env struct {
-	Name  string `json:"container"`
-	Value string `json:"host"`
-	Desc  string `json:"desc"`
-	Type  int    `json:"type"`
-}
-
-type JSON json.RawMessage
-
-type EnvArray []Env
-
-// Value 实现方法
-func (p EnvArray) Value() (driver.Value, error) {
-	return json.Marshal(p)
-	//return .MarshalJSON()
-}
-
-// Scan 实现方法
-func (p *EnvArray) Scan(input interface{}) error {
-	return json.Unmarshal(input.([]byte), p)
-}
-
-/************************************************************************/
-
-/*******************使用gorm支持json************************************/
-
-type PathMap struct {
-	ContainerPath string `json:"container"`
-	Path          string `json:"host"`
-	Type          int    `json:"type"`
-	Desc          string `json:"desc"`
-}
-
-type PathArray []PathMap
-
-// Value 实现方法
-func (p PathArray) Value() (driver.Value, error) {
-	return json.Marshal(p)
-}
-
-// Scan 实现方法
-func (p *PathArray) Scan(input interface{}) error {
-	return json.Unmarshal(input.([]byte), p)
-}
-
-/************************************************************************/
-
-//type PostData struct {
-//	Envs       EnvArrey  `json:"envs,omitempty"`
-//	Udp        PortArrey `json:"udp_ports"`
-//	Tcp        PortArrey `json:"tcp_ports"`
-//	Volumes    PathArrey `json:"volumes"`
-//	Devices    PathArrey `json:"devices"`
-//	Port       string    `json:"port,omitempty"`
-//	PortMap    string    `json:"port_map"`
-//	CpuShares  int64     `json:"cpu_shares,omitempty"`
-//	Memory     int64     `json:"memory,omitempty"`
-//	Restart    string    `json:"restart,omitempty"`
-//	EnableUPNP bool      `json:"enable_upnp"`
-//	Label      string    `json:"label"`
-//	Position   bool      `json:"position"`
-//}
-
-type CustomizationPostData struct {
-	ContainerName string    `json:"container_name"`
-	CustomId      string    `json:"custom_id"`
-	Origin        string    `json:"origin"`
-	NetworkModel  string    `json:"network_model"`
-	Index         string    `json:"index"`
-	Icon          string    `json:"icon"`
-	Image         string    `json:"image"`
-	Envs          EnvArray  `json:"envs"`
-	Ports         PortArray `json:"ports"`
-	Volumes       PathArray `json:"volumes"`
-	Devices       PathArray `json:"devices"`
-	//Port         string    `json:"port,omitempty"`
-	PortMap     string   `json:"port_map"`
-	CpuShares   int64    `json:"cpu_shares"`
-	Memory      int64    `json:"memory"`
-	Restart     string   `json:"restart"`
-	EnableUPNP  bool     `json:"enable_upnp"`
-	Label       string   `json:"label"`
-	Description string   `json:"description"`
-	Position    bool     `json:"position"`
-	HostName    string   `json:"host_name"`
-	Privileged  bool     `json:"privileged"`
-	CapAdd      []string `json:"cap_add"`
-	Cmd         []string `json:"cmd"`
-	Protocol    string   `json:"protocol"`
-	Host        string   `json:"host"`
-}

model/notify/application.go

@@ -1,21 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-05-27 15:01:58
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-05-31 14:51:21
- * @FilePath: /CasaOS/model/notify/application.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package notify
-
-type Application struct {
-	Name     string `json:"name"`
-	State    string `json:"state"`
-	Type     string `json:"type"`
-	Icon     string `json:"icon"`
-	Message  string `json:"message"`
-	Finished bool   `json:"finished"`
-	Success  bool   `json:"success"`
-}

model/receive/app.go

@@ -1 +0,0 @@
-package receive

model/sys_common.go

@@ -2,7 +2,7 @@
  * @Author: LinkLeong link@icewhale.com
  * @Date: 2022-05-13 18:15:46
  * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-14 11:02:06
+ * @LastEditTime: 2022-09-02 22:12:34
  * @FilePath: /CasaOS/model/sys_common.go
  * @Description:
  * @Website: https://www.casaos.io
@@ -12,26 +12,12 @@ package model
 
 import "time"
 
-//系统配置
+// 系统配置
 type SysInfoModel struct {
-	Name string //系统名称
+	Name string // 系统名称
 }
 
-//用户相关
-type UserModel struct {
-	UserName    string
-	PWD         string
-	Token       string
-	Head        string
-	Email       string
-	Description string
-	Initialized bool
-	Avatar      string
-	NickName    string
-	Public      string
-}
-
-//服务配置
+// 服务配置
 type ServerModel struct {
 	HttpPort     string
 	RunMode      string
@@ -40,9 +26,10 @@ type ServerModel struct {
 	Token        string
 	USBAutoMount string
 	SocketPort   string
+	UpdateUrl    string
 }
 
-//服务配置
+// 服务配置
 type APPModel struct {
 	LogPath        string
 	LogSaveName    string
@@ -54,17 +41,19 @@ type APPModel struct {
 	DateFormat     string
 	DBPath         string
 	ShellPath      string
-	TempPath       string
+}
+type CommonModel struct {
+	RuntimePath string
 }
 
-//公共返回模型
+// 公共返回模型
 type Result struct {
 	Success int         `json:"success" example:"200"`
 	Message string      `json:"message" example:"ok"`
 	Data    interface{} `json:"data" example:"返回结果"`
 }
 
-//redis配置文件
+// redis配置文件
 type RedisModel struct {
 	Host        string
 	Password    string
@@ -77,11 +66,12 @@ type SystemConfig struct {
 	ConfigPath string `json:"config_path"`
 }
 
-type CasaOSGlobalVariables struct {
-	AppChange bool
-}
-
 type FileSetting struct {
 	ShareDir    []string `json:"share_dir" delim:"|"`
 	DownloadDir string   `json:"download_dir"`
 }
+type BaseInfo struct {
+	Hash    string `json:"i"`
+	Version string `json:"v"`
+	Channel string `json:"c,omitempty"`
+}

pkg/config/config.go

@@ -2,7 +2,7 @@
  * @Author: LinkLeong link@icewhale.com
  * @Date: 2021-09-30 18:18:14
  * @LastEditors: LinkLeong
- * @LastEditTime: 2022-06-21 11:09:30
+ * @LastEditTime: 2022-08-31 17:04:02
  * @FilePath: /CasaOS/pkg/config/config.go
  * @Description:
  * @Website: https://www.casaos.io
@@ -11,5 +11,5 @@
 package config
 
 const (
-	USERCONFIGURL = "/etc/casaos.conf"
+	USERCONFIGURL = "/etc/casaos/casaos.conf"
 )

pkg/config/init.go

@@ -2,7 +2,7 @@
  * @Author: LinkLeong link@icewhale.com
  * @Date: 2022-05-13 18:15:46
  * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-14 10:58:45
+ * @LastEditTime: 2022-09-05 11:58:02
  * @FilePath: /CasaOS/pkg/config/init.go
  * @Description:
  * @Website: https://www.casaos.io
@@ -23,32 +23,28 @@ import (
 	"github.com/go-ini/ini"
 )
 
-//系统配置
+// 系统配置
 var SysInfo = &model.SysInfoModel{}
 
-//用户相关
-var UserInfo = &model.UserModel{}
-
-//用户相关
+// 用户相关
 var AppInfo = &model.APPModel{}
 
-//var RedisInfo = &model.RedisModel{}
+var CommonInfo = &model.CommonModel{}
 
-//server相关
+// var RedisInfo = &model.RedisModel{}
+
+// server相关
 var ServerInfo = &model.ServerModel{}
 
 var SystemConfigInfo = &model.SystemConfig{}
 
-var CasaOSGlobalVariables = &model.CasaOSGlobalVariables{}
-
 var FileSettingInfo = &model.FileSetting{}
 
 var Cfg *ini.File
 
-//初始化设置，获取系统的部分信息。
+// 初始化设置，获取系统的部分信息。
 func InitSetup(config string) {
-
-	var configDir = USERCONFIGURL
+	configDir := USERCONFIGURL
 	if len(config) > 0 {
 		configDir = config
 	}
@@ -56,45 +52,45 @@ func InitSetup(config string) {
 		configDir = "./conf/conf.conf"
 	}
 	var err error
-	//读取文件
+	// 读取文件
 	Cfg, err = ini.Load(configDir)
 	if err != nil {
-		fmt.Printf("Fail to read file: %v", err)
-		os.Exit(1)
+		Cfg, err = ini.Load("/etc/casaos.conf")
+		if err != nil {
+			Cfg, err = ini.Load("/casaOS/server/conf/conf.ini")
+			if err != nil {
+				fmt.Printf("Fail to read file: %v", err)
+				os.Exit(1)
+			}
+		}
 	}
-
-	mapTo("user", UserInfo)
 	mapTo("app", AppInfo)
-	//mapTo("redis", RedisInfo)
+	// mapTo("redis", RedisInfo)
 	mapTo("server", ServerInfo)
 	mapTo("system", SystemConfigInfo)
 	mapTo("file", FileSettingInfo)
+	mapTo("common", CommonInfo)
 	SystemConfigInfo.ConfigPath = configDir
 	if len(AppInfo.DBPath) == 0 {
 		AppInfo.DBPath = "/var/lib/casaos"
-		Cfg.SaveTo(configDir)
 	}
 	if len(AppInfo.LogPath) == 0 {
 		AppInfo.LogPath = "/var/log/casaos/"
-		Cfg.SaveTo(configDir)
 	}
 	if len(AppInfo.ShellPath) == 0 {
 		AppInfo.ShellPath = "/usr/share/casaos/shell"
-		Cfg.SaveTo(configDir)
 	}
 	if len(AppInfo.UserDataPath) == 0 {
 		AppInfo.UserDataPath = "/var/lib/casaos/conf"
-		Cfg.SaveTo(configDir)
 	}
-	if len(AppInfo.TempPath) == 0 {
-		AppInfo.TempPath = "/var/lib/casaos/temp"
-		Cfg.SaveTo(configDir)
+	if len(CommonInfo.RuntimePath) == 0 {
+		CommonInfo.RuntimePath = "/var/run/casaos"
 	}
+	Cfg.SaveTo(configDir)
 	//	AppInfo.ProjectPath = getCurrentDirectory() //os.Getwd()
-
 }
 
-//映射
+// 映射
 func mapTo(section string, v interface{}) {
 	err := Cfg.Section(section).MapTo(v)
 	if err != nil {
@@ -111,6 +107,7 @@ func getCurrentAbPathByCaller() string {
 	}
 	return abPath
 }
+
 func getCurrentDirectory() string {
 	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
 	if err != nil {

pkg/config/update.go

@@ -1,32 +0,0 @@
-package config
-
-import (
-	"runtime"
-
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-)
-
-//检查目录是否存在
-func mkdirDATAAll() {
-	sysType := runtime.GOOS
-	var dirArray []string
-	if sysType == "linux" {
-		dirArray = []string{"/DATA/AppData", "/DATA/Documents", "/DATA/Downloads", "/DATA/Gallery", "/DATA/Media/Movies", "/DATA/Media/TV Shows", "/DATA/Media/Music"}
-	}
-
-	if sysType == "windows" {
-		dirArray = []string{"C:\\CasaOS\\DATA\\AppData", "C:\\CasaOS\\DATA\\Documents", "C:\\CasaOS\\DATA\\Downloads", "C:\\CasaOS\\DATA\\Gallery", "C:\\CasaOS\\DATA\\Media/Movies", "C:\\CasaOS\\DATA\\Media\\TV Shows", "C:\\CasaOS\\DATA\\Media\\Music"}
-	}
-	if sysType == "darwin" {
-		dirArray = []string{"./CasaOS/DATA/AppData", "./CasaOS/DATA/Documents", "./CasaOS/DATA/Downloads", "./CasaOS/DATA/Gallery", "./CasaOS/DATA/Media/Movies", "./CasaOS/DATA/Media/TV Shows", "./CasaOS/DATA/Media/Music"}
-	}
-
-	for _, v := range dirArray {
-		file.IsNotExistMkDir(v)
-	}
-
-}
-
-func UpdateSetup() {
-	mkdirDATAAll()
-}

pkg/docker/emum.go

@@ -1,3 +0,0 @@
-package docker
-
-const NETWORKNAME = "oasis"

pkg/docker/helper.go

@@ -1,402 +0,0 @@
-package docker
-
-import (
-	"bytes"
-	json2 "encoding/json"
-	"fmt"
-	"io"
-	"regexp"
-	"sync"
-	"time"
-
-	"github.com/gorilla/websocket"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/crypto/ssh"
-)
-
-func NewSshClient(user, password string, port string) (*ssh.Client, error) {
-
-	// connet to ssh
-	// addr = fmt.Sprintf("%s:%d", host, port)
-
-	config := &ssh.ClientConfig{
-		Timeout:         time.Second * 5,
-		User:            user,
-		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
-		//HostKeyCallback: ,
-		//HostKeyCallback: hostKeyCallBackFunc(h.Host),
-	}
-	//if h.Type == "password" {
-	config.Auth = []ssh.AuthMethod{ssh.Password(password)}
-	//} else {
-	//	config.Auth = []ssh.AuthMethod{publicKeyAuthFunc(h.Key)}
-	//}
-	addr := fmt.Sprintf("%s:%s", "127.0.0.1", port)
-	c, err := ssh.Dial("tcp", addr, config)
-	if err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-// setup ssh shell session
-// set Session and StdinPipe here,
-// and the Session.Stdout and Session.Sdterr are also set.
-func NewSshConn(cols, rows int, sshClient *ssh.Client) (*SshConn, error) {
-	sshSession, err := sshClient.NewSession()
-	if err != nil {
-		return nil, err
-	}
-
-	stdinP, err := sshSession.StdinPipe()
-	if err != nil {
-		return nil, err
-	}
-	comboWriter := new(wsBufferWriter)
-
-	sshSession.Stdout = comboWriter
-	sshSession.Stderr = comboWriter
-
-	modes := ssh.TerminalModes{
-		ssh.ECHO:          1,     // disable echo
-		ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
-		ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
-	}
-	// Request pseudo terminal
-	if err := sshSession.RequestPty("xterm", rows, cols, modes); err != nil {
-		return nil, err
-	}
-	// Start remote shell
-	if err := sshSession.Shell(); err != nil {
-		return nil, err
-	}
-	return &SshConn{StdinPipe: stdinP, ComboOutput: comboWriter, Session: sshSession}, nil
-}
-
-type SshConn struct {
-	// calling Write() to write data into ssh server
-	StdinPipe io.WriteCloser
-	// Write() be called to receive data from ssh server
-	ComboOutput *wsBufferWriter
-	Session     *ssh.Session
-}
-type wsBufferWriter struct {
-	buffer bytes.Buffer
-	mu     sync.Mutex
-}
-
-func (w *wsBufferWriter) Write(p []byte) (int, error) {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	return w.buffer.Write(p)
-}
-func (s *SshConn) Close() {
-	if s.Session != nil {
-		s.Session.Close()
-	}
-
-}
-
-const (
-	wsMsgCmd    = "cmd"
-	wsMsgResize = "resize"
-)
-
-//ReceiveWsMsg  receive websocket msg do some handling then write into ssh.session.stdin
-func ReceiveWsMsgUser(wsConn *websocket.Conn, logBuff *bytes.Buffer) string {
-	//tells other go routine quit
-	username := ""
-	for {
-
-		//read websocket msg
-		_, wsData, err := wsConn.ReadMessage()
-		if err != nil {
-
-			return ""
-		}
-
-		msgObj := wsMsg{}
-		if err := json2.Unmarshal(wsData, &msgObj); err != nil {
-			msgObj.Type = "cmd"
-			msgObj.Cmd = string(wsData)
-		}
-		//if err := json.Unmarshal(wsData, &msgObj); err != nil {
-		//	logrus.WithError(err).WithField("wsData", string(wsData)).Error("unmarshal websocket message failed")
-		//}
-		switch msgObj.Type {
-		case wsMsgCmd:
-			//handle xterm.js stdin
-			//decodeBytes, err := base64.StdEncoding.DecodeString(msgObj.Cmd)
-			decodeBytes := []byte(msgObj.Cmd)
-			if msgObj.Cmd == "\u007f" {
-				if len(username) == 0 {
-					continue
-				}
-				wsConn.WriteMessage(websocket.TextMessage, []byte("\b\x1b[K"))
-				username = username[:len(username)-1]
-				continue
-			}
-			if msgObj.Cmd == "\r" {
-				return username
-			}
-			username += msgObj.Cmd
-
-			if err := wsConn.WriteMessage(websocket.TextMessage, decodeBytes); err != nil {
-				logrus.WithError(err).Error("ws cmd bytes write to ssh.stdin pipe failed")
-			}
-			//write input cmd to log buffer
-			if _, err := logBuff.Write(decodeBytes); err != nil {
-				logrus.WithError(err).Error("write received cmd into log buffer failed")
-			}
-		}
-
-	}
-}
-
-func ReceiveWsMsgPassword(wsConn *websocket.Conn, logBuff *bytes.Buffer) string {
-	//tells other go routine quit
-	password := ""
-	for {
-
-		//read websocket msg
-		_, wsData, err := wsConn.ReadMessage()
-		if err != nil {
-			logrus.WithError(err).Error("reading webSocket message failed")
-			return ""
-		}
-
-		msgObj := wsMsg{}
-		if err := json2.Unmarshal(wsData, &msgObj); err != nil {
-			msgObj.Type = "cmd"
-			msgObj.Cmd = string(wsData)
-		}
-		//if err := json.Unmarshal(wsData, &msgObj); err != nil {
-		//	logrus.WithError(err).WithField("wsData", string(wsData)).Error("unmarshal websocket message failed")
-		//}
-		switch msgObj.Type {
-		case wsMsgCmd:
-			//handle xterm.js stdin
-			//decodeBytes, err := base64.StdEncoding.DecodeString(msgObj.Cmd)
-			if msgObj.Cmd == "\r" {
-				return password
-			}
-
-			if msgObj.Cmd == "\u007f" {
-				if len(password) == 0 {
-					continue
-				}
-				password = password[:len(password)-1]
-				continue
-			}
-			password += msgObj.Cmd
-		}
-
-	}
-}
-
-//ReceiveWsMsg  receive websocket msg do some handling then write into ssh.session.stdin
-func (ssConn *SshConn) ReceiveWsMsg(wsConn *websocket.Conn, logBuff *bytes.Buffer, exitCh chan bool) {
-	//tells other go routine quit
-	defer setQuit(exitCh)
-	for {
-		select {
-		case <-exitCh:
-			return
-		default:
-			//read websocket msg
-			_, wsData, err := wsConn.ReadMessage()
-			if err != nil {
-				logrus.WithError(err).Error("reading webSocket message failed")
-				return
-			}
-			//unmashal bytes into struct
-			//msgObj := wsMsg{
-			//	Type: "cmd",
-			//	Cmd:  "",
-			//	Rows: 50,
-			//	Cols: 180,
-			//}
-			msgObj := wsMsg{}
-			if err := json2.Unmarshal(wsData, &msgObj); err != nil {
-				msgObj.Type = "cmd"
-				msgObj.Cmd = string(wsData)
-			}
-			//if err := json.Unmarshal(wsData, &msgObj); err != nil {
-			//	logrus.WithError(err).WithField("wsData", string(wsData)).Error("unmarshal websocket message failed")
-			//}
-			switch msgObj.Type {
-
-			case wsMsgResize:
-				//handle xterm.js size change
-				if msgObj.Cols > 0 && msgObj.Rows > 0 {
-					if err := ssConn.Session.WindowChange(msgObj.Rows, msgObj.Cols); err != nil {
-						logrus.WithError(err).Error("ssh pty change windows size failed")
-					}
-				}
-			case wsMsgCmd:
-				//handle xterm.js stdin
-				//decodeBytes, err := base64.StdEncoding.DecodeString(msgObj.Cmd)
-				decodeBytes := []byte(msgObj.Cmd)
-				if err != nil {
-					logrus.WithError(err).Error("websock cmd string base64 decoding failed")
-				}
-				if _, err := ssConn.StdinPipe.Write(decodeBytes); err != nil {
-					logrus.WithError(err).Error("ws cmd bytes write to ssh.stdin pipe failed")
-				}
-				//write input cmd to log buffer
-				if _, err := logBuff.Write(decodeBytes); err != nil {
-					logrus.WithError(err).Error("write received cmd into log buffer failed")
-				}
-			}
-		}
-	}
-}
-
-func (ssConn *SshConn) SendComboOutput(wsConn *websocket.Conn, exitCh chan bool) {
-	//tells other go routine quit
-	//defer setQuit(exitCh)
-
-	//every 120ms write combine output bytes into websocket response
-	tick := time.NewTicker(time.Millisecond * time.Duration(120))
-	//for range time.Tick(120 * time.Millisecond){}
-	defer tick.Stop()
-	for {
-		select {
-		case <-tick.C:
-			//write combine output bytes into websocket response
-			if err := flushComboOutput(ssConn.ComboOutput, wsConn); err != nil {
-				logrus.WithError(err).Error("ssh sending combo output to webSocket failed")
-				return
-			}
-		case <-exitCh:
-			return
-		}
-	}
-}
-func flushComboOutput(w *wsBufferWriter, wsConn *websocket.Conn) error {
-	if w.buffer.Len() != 0 {
-		err := wsConn.WriteMessage(websocket.TextMessage, w.buffer.Bytes())
-		if err != nil {
-			return err
-		}
-		w.buffer.Reset()
-	}
-	return nil
-}
-
-//ReceiveWsMsg  receive websocket msg do some handling then write into ssh.session.stdin
-func (ssConn *SshConn) Login(wsConn *websocket.Conn, logBuff *bytes.Buffer, exitCh chan bool) {
-	//tells other go routine quit
-	defer setQuit(exitCh)
-	for {
-		select {
-		case <-exitCh:
-			return
-		default:
-			//read websocket msg
-			_, wsData, err := wsConn.ReadMessage()
-			if err != nil {
-				logrus.WithError(err).Error("reading webSocket message failed")
-				return
-			}
-			//unmashal bytes into struct
-			//msgObj := wsMsg{
-			//	Type: "cmd",
-			//	Cmd:  "",
-			//	Rows: 50,
-			//	Cols: 180,
-			//}
-			msgObj := wsMsg{}
-			if err := json2.Unmarshal(wsData, &msgObj); err != nil {
-				msgObj.Type = "cmd"
-				msgObj.Cmd = string(wsData)
-			}
-			//if err := json.Unmarshal(wsData, &msgObj); err != nil {
-			//	logrus.WithError(err).WithField("wsData", string(wsData)).Error("unmarshal websocket message failed")
-			//}
-			switch msgObj.Type {
-
-			case wsMsgResize:
-				//handle xterm.js size change
-				if msgObj.Cols > 0 && msgObj.Rows > 0 {
-					if err := ssConn.Session.WindowChange(msgObj.Rows, msgObj.Cols); err != nil {
-						logrus.WithError(err).Error("ssh pty change windows size failed")
-					}
-				}
-			case wsMsgCmd:
-				//handle xterm.js stdin
-				//decodeBytes, err := base64.StdEncoding.DecodeString(msgObj.Cmd)
-				decodeBytes := []byte(msgObj.Cmd)
-				if err != nil {
-					logrus.WithError(err).Error("websock cmd string base64 decoding failed")
-				}
-				if _, err := ssConn.StdinPipe.Write(decodeBytes); err != nil {
-					logrus.WithError(err).Error("ws cmd bytes write to ssh.stdin pipe failed")
-				}
-				//write input cmd to log buffer
-				if _, err := logBuff.Write(decodeBytes); err != nil {
-					logrus.WithError(err).Error("write received cmd into log buffer failed")
-				}
-			}
-		}
-	}
-}
-func (ssConn *SshConn) SessionWait(quitChan chan bool) {
-	if err := ssConn.Session.Wait(); err != nil {
-		logrus.WithError(err).Error("ssh session wait failed")
-		setQuit(quitChan)
-	}
-}
-
-func setQuit(ch chan bool) {
-	ch <- true
-}
-
-type wsMsg struct {
-	Type string `json:"type"`
-	Cmd  string `json:"cmd"`
-	Cols int    `json:"cols"`
-	Rows int    `json:"rows"`
-}
-
-// 将终端的输出转发到前端
-func WsWriterCopy(reader io.Reader, writer *websocket.Conn) {
-	buf := make([]byte, 8192)
-	reg1 := regexp.MustCompile(`stty rows \d+ && stty cols \d+ `)
-	for {
-		nr, err := reader.Read(buf)
-		if nr > 0 {
-			result1 := reg1.FindIndex(buf[0:nr])
-			if len(result1) > 0 {
-				fmt.Println(result1)
-			} else {
-				err := writer.WriteMessage(websocket.BinaryMessage, buf[0:nr])
-				if err != nil {
-					return
-				}
-			}
-
-		}
-		if err != nil {
-			return
-		}
-	}
-}
-
-// 将前端的输入转发到终端
-func WsReaderCopy(reader *websocket.Conn, writer io.Writer) {
-	for {
-		messageType, p, err := reader.ReadMessage()
-		if err != nil {
-			return
-		}
-		if messageType == websocket.TextMessage {
-			msgObj := wsMsg{}
-			if err = json2.Unmarshal(p, &msgObj); err != nil {
-				writer.Write(p)
-			} else if msgObj.Type == wsMsgResize {
-				//writer.Write([]byte("stty rows " + strconv.Itoa(msgObj.Rows) + " && stty cols " + strconv.Itoa(msgObj.Cols) + " \r"))
-			}
-		}
-	}
-}

pkg/docker/volumes.go

@@ -1,11 +0,0 @@
-package docker
-
-import "strings"
-
-func GetDir(id, envName string) string {
-
-	if strings.Contains(envName, "$AppID") && len(id) > 0 {
-		return strings.ReplaceAll(envName, "$AppID", id)
-	}
-	return envName
-}

pkg/docker/volumes_test.go

@@ -1,10 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestGetDir(t *testing.T) {
-	fmt.Println(GetDir("", "config"))
-}

pkg/sqlite/db.go

@@ -2,7 +2,7 @@
  * @Author: LinkLeong link@icewhale.com
  * @Date: 2022-05-13 18:15:46
  * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-27 11:25:26
+ * @LastEditTime: 2022-08-31 13:39:24
  * @FilePath: /CasaOS/pkg/sqlite/db.go
  * @Description:
  * @Website: https://www.casaos.io
@@ -13,11 +13,11 @@ package sqlite
 import (
 	"time"
 
+	"github.com/IceWhaleTech/CasaOS-Common/utils/logger"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
 	model2 "github.com/IceWhaleTech/CasaOS/service/model"
+	"github.com/glebarez/sqlite"
 	"go.uber.org/zap"
-	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 )
 
@@ -28,38 +28,27 @@ func GetDb(dbPath string) *gorm.DB {
 		return gdb
 	}
 	// Refer https://github.com/go-sql-driver/mysql#dsn-data-source-name
-	//dsn := fmt.Sprintf("%v:%v@tcp(%v:%v)/%v?charset=utf8mb4&parseTime=True&loc=Local", m.User, m.PWD, m.IP, m.Port, m.DBName)
-	//db, err := gorm.Open(mysql2.Open(dsn), &gorm.Config{})
+	// dsn := fmt.Sprintf("%v:%v@tcp(%v:%v)/%v?charset=utf8mb4&parseTime=True&loc=Local", m.User, m.PWD, m.IP, m.Port, m.DBName)
+	// db, err := gorm.Open(mysql2.Open(dsn), &gorm.Config{})
 	file.IsNotExistMkDir(dbPath)
 	db, err := gorm.Open(sqlite.Open(dbPath+"/casaOS.db"), &gorm.Config{})
 	c, _ := db.DB()
 	c.SetMaxIdleConns(10)
-	c.SetMaxOpenConns(100)
+	c.SetMaxOpenConns(1)
 	c.SetConnMaxIdleTime(time.Second * 1000)
 	if err != nil {
-		loger.Error("sqlite connect error", zap.Any("db connect error", err))
+		logger.Error("sqlite connect error", zap.Any("db connect error", err))
 		panic("sqlite connect error")
-		return nil
 	}
 	gdb = db
 
-	db.Exec(`alter table o_user rename to old_user;
-
-	create table o_users ( id integer primary key,username text,password text,role text,email text,nickname text,avatar text,description text,created_at datetime,updated_at datetime);
-	
-	insert into o_users select id,user_name,password,role,email,nick_name,avatar,description,created_at,updated_at from old_user;
-	
-	drop table old_user;
-	drop table o_user;	
-	`)
-
-	err = db.AutoMigrate(&model2.AppNotify{}, &model2.AppListDBModel{}, &model2.SerialDisk{}, model2.UserDBModel{}, model2.SharesDBModel{}, model2.ConnectionsDBModel{})
+	err = db.AutoMigrate(&model2.AppNotify{}, model2.SharesDBModel{}, model2.ConnectionsDBModel{})
 	db.Exec("DROP TABLE IF EXISTS o_application")
 	db.Exec("DROP TABLE IF EXISTS o_friend")
 	db.Exec("DROP TABLE IF EXISTS o_person_download")
 	db.Exec("DROP TABLE IF EXISTS o_person_down_record")
 	if err != nil {
-		loger.Error("check or create db error", zap.Any("error", err))
+		logger.Error("check or create db error", zap.Any("error", err))
 	}
 	return db
 }

pkg/utils/command/command_helper.go

@@ -35,8 +35,8 @@ func ExecResultStrArray(cmdStr string) []string {
 		fmt.Println(err)
 		return nil
 	}
-	//str, err := ioutil.ReadAll(stdout)
-	var networklist = []string{}
+	// str, err := ioutil.ReadAll(stdout)
+	networklist := []string{}
 	outputBuf := bufio.NewReader(stdout)
 	for {
 		output, _, err := outputBuf.ReadLine()
@@ -54,6 +54,8 @@ func ExecResultStrArray(cmdStr string) []string {
 
 func ExecResultStr(cmdStr string) string {
 	cmd := exec.Command("/bin/bash", "-c", cmdStr)
+	println(cmd.String())
+
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		fmt.Println(err)
@@ -73,7 +75,7 @@ func ExecResultStr(cmdStr string) string {
 	return string(str)
 }
 
-//执行 lsblk 命令
+// 执行 lsblk 命令
 func ExecLSBLK() []byte {
 	output, err := exec.Command("lsblk", "-O", "-J", "-b").Output()
 	if err != nil {
@@ -83,7 +85,7 @@ func ExecLSBLK() []byte {
 	return output
 }
 
-//执行 lsblk 命令
+// 执行 lsblk 命令
 func ExecLSBLKByPath(path string) []byte {
 	output, err := exec.Command("lsblk", path, "-O", "-J", "-b").Output()
 	if err != nil {
@@ -93,7 +95,7 @@ func ExecLSBLKByPath(path string) []byte {
 	return output
 }
 
-//exec smart
+// exec smart
 func ExecSmartCTLByPath(path string) []byte {
 	timeout := 3
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
@@ -107,6 +109,5 @@ func ExecSmartCTLByPath(path string) []byte {
 }
 
 func ExecEnabledSMART(path string) {
-
 	exec.Command("smartctl", "-s on", path).Output()
 }

pkg/utils/common_err/e.go

@@ -30,6 +30,7 @@ const (
 	Record_NOT_EXIST                = 20007
 	Record_ALREADY_EXIST            = 20008
 	SERVICE_NOT_RUNNING             = 20009
+	CHARACTER_LIMIT                 = 20010
 
 	//disk
 	NAME_NOT_AVAILABLE       = 40001
@@ -85,6 +86,7 @@ var MsgFlags = map[int]string{
 	Record_ALREADY_EXIST: "Record already exists",
 	Record_NOT_EXIST:     "Record does not exist",
 	SERVICE_NOT_RUNNING:  "Service is not running",
+	CHARACTER_LIMIT:      "Only uppercase letters, lowercase letters and numbers are allowed for username and password.",
 
 	//app
 	UNINSTALL_APP_ERROR:  "Error uninstalling app",
@@ -113,7 +115,7 @@ var MsgFlags = map[int]string{
 	COMMAND_ERROR_INVALID_OPERATION: "invalid operation",
 }
 
-//获取错误信息
+// 获取错误信息
 func GetMsg(code int) string {
 	msg, ok := MsgFlags[code]
 	if ok {

pkg/utils/env_helper/env.go

@@ -1,26 +0,0 @@
-package env_helper
-
-import "strings"
-
-func ReplaceDefaultENV(key, tz string) string {
-	temp := ""
-	switch key {
-	case "$DefaultPassword":
-		temp = "casaos"
-	case "$DefaultUserName":
-		temp = "admin"
-
-	case "$PUID":
-		temp = "1000"
-	case "$PGID":
-		temp = "1000"
-	case "$TZ":
-		temp = tz
-	}
-	return temp
-}
-
-//replace env default setting
-func ReplaceStringDefaultENV(str string) string {
-	return strings.ReplaceAll(strings.ReplaceAll(str, "$DefaultPassword", ReplaceDefaultENV("$DefaultPassword", "")), "$DefaultUserName", ReplaceDefaultENV("$DefaultUserName", ""))
-}

pkg/utils/file/file.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"io/ioutil"
 	"log"
 	"mime/multipart"
@@ -60,7 +61,7 @@ func MkDir(src string) error {
 	if err != nil {
 		return err
 	}
-	os.Chmod(src, 0777)
+	os.Chmod(src, 0o777)
 
 	return nil
 }
@@ -103,7 +104,7 @@ func MustOpen(fileName, filePath string) (*os.File, error) {
 		return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
 	}
 
-	f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
+	f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return nil, fmt.Errorf("Fail to OpenFile :%v", err)
 	}
@@ -113,7 +114,7 @@ func MustOpen(fileName, filePath string) (*os.File, error) {
 
 // 判断所给路径文件/文件夹是否存在
 func Exists(path string) bool {
-	_, err := os.Stat(path) //os.Stat获取文件信息
+	_, err := os.Stat(path) // os.Stat获取文件信息
 	if err != nil {
 		if os.IsExist(err) {
 			return true
@@ -147,7 +148,7 @@ func CreateFile(path string) error {
 }
 
 func CreateFileAndWriteContent(path string, content string) error {
-	file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
+	file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0o666)
 	if err != nil {
 		return err
 	}
@@ -163,7 +164,7 @@ func CreateFileAndWriteContent(path string, content string) error {
 
 // IsNotExistMkDir create a directory if it does not exist
 func IsNotExistCreateFile(src string) error {
-	if notExist := CheckNotExist(src); notExist == true {
+	if notExist := CheckNotExist(src); notExist {
 		if err := CreateFile(src); err != nil {
 			return err
 		}
@@ -267,7 +268,7 @@ func CopySingleFile(src, dst, style string) error {
 	return os.Chmod(dst, srcinfo.Mode())
 }
 
-//Check for duplicate file names
+// Check for duplicate file names
 func GetNoDuplicateFileName(fullPath string) string {
 	path, fileName := filepath.Split(fullPath)
 	fileSuffix := path2.Ext(fileName)
@@ -293,7 +294,7 @@ func CopyDir(src string, dst string, style string) error {
 		}
 		return nil
 	}
-	//dstPath := dst
+	// dstPath := dst
 	lastPath := src[strings.LastIndex(src, "/")+1:]
 	dst += "/" + lastPath
 	// for i := 0; Exists(dst); i++ {
@@ -314,7 +315,7 @@ func CopyDir(src string, dst string, style string) error {
 	}
 	for _, fd := range fds {
 		srcfp := path.Join(src, fd.Name())
-		dstfp := dst //path.Join(dst, fd.Name())
+		dstfp := dst // path.Join(dst, fd.Name())
 
 		if fd.IsDir() {
 			if err = CopyDir(srcfp, dstfp, style); err != nil {
@@ -336,10 +337,17 @@ func WriteToPath(data []byte, path, name string) error {
 	} else {
 		fullPath += "/" + name
 	}
-	IsNotExistCreateFile(fullPath)
+	return WriteToFullPath(data, fullPath, 0o666)
+}
+
+func WriteToFullPath(data []byte, fullPath string, perm fs.FileMode) error {
+	if err := IsNotExistCreateFile(fullPath); err != nil {
+		return err
+	}
+
 	file, err := os.OpenFile(fullPath,
 		os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
-		0666,
+		perm,
 	)
 	if err != nil {
 		return err
@@ -350,26 +358,31 @@ func WriteToPath(data []byte, path, name string) error {
 	return err
 }
 
-//最终拼接
+// 最终拼接
 func SpliceFiles(dir, path string, length int, startPoint int) error {
-
 	fullPath := path
 
-	IsNotExistCreateFile(fullPath)
+	if err := IsNotExistCreateFile(fullPath); err != nil {
+		return err
+	}
 
 	file, _ := os.OpenFile(fullPath,
 		os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
-		0666,
+		0o666,
 	)
+
 	defer file.Close()
+
 	bufferedWriter := bufio.NewWriter(file)
-	for i := 0; i < length+startPoint; i++ {
+
+	// todo: here should have a goroutine to remove each partial file after it is read, to save disk space
+
+	for i := 0; i < length+startPoint-1; i++ {
 		data, err := ioutil.ReadFile(dir + "/" + strconv.Itoa(i+startPoint))
 		if err != nil {
 			return err
 		}
-		_, err = bufferedWriter.Write(data)
-		if err != nil {
+		if _, err := bufferedWriter.Write(data); err != nil { // recommend to use https://github.com/iceber/iouring-go for faster write
 			return err
 		}
 	}
@@ -380,7 +393,6 @@ func SpliceFiles(dir, path string, length int, startPoint int) error {
 }
 
 func GetCompressionAlgorithm(t string) (string, archiver.Writer, error) {
-
 	switch t {
 	case "zip", "":
 		return ".zip", archiver.NewZip(), nil
@@ -400,8 +412,8 @@ func GetCompressionAlgorithm(t string) (string, archiver.Writer, error) {
 		return "", nil, errors.New("format not implemented")
 	}
 }
-func AddFile(ar archiver.Writer, path, commonPath string) error {
 
+func AddFile(ar archiver.Writer, path, commonPath string) error {
 	info, err := os.Stat(path)
 	if err != nil {
 		return err
@@ -447,6 +459,7 @@ func AddFile(ar archiver.Writer, path, commonPath string) error {
 
 	return nil
 }
+
 func CommonPrefix(sep byte, paths ...string) string {
 	// Handle special cases.
 	switch len(paths) {
@@ -513,7 +526,7 @@ func GetFileOrDirSize(path string) (int64, error) {
 	return fileInfo.Size(), nil
 }
 
-//getFileSize get file size by path(B)
+// getFileSize get file size by path(B)
 func DirSizeB(path string) (int64, error) {
 	var size int64
 	err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {

pkg/utils/httper/httper.go

@@ -12,9 +12,9 @@ import (
 	"github.com/tidwall/gjson"
 )
 
-//发送GET请求
-//url:请求地址
-//response:请求返回的内容
+// 发送GET请求
+// url:请求地址
+// response:请求返回的内容
 func Get(url string, head map[string]string) (response string) {
 	client := &http.Client{Timeout: 30 * time.Second}
 	req, err := http.NewRequest("GET", url, nil)
@@ -28,10 +28,10 @@ func Get(url string, head map[string]string) (response string) {
 	resp, err := client.Do(req)
 	if err != nil {
 		fmt.Println(err)
-		//需要错误日志的处理
-		//loger.Error(error)
+		// 需要错误日志的处理
+		// logger.Error(error)
 		return ""
-		//panic(error)
+		// panic(error)
 	}
 	defer resp.Body.Close()
 	var buffer [512]byte
@@ -42,7 +42,7 @@ func Get(url string, head map[string]string) (response string) {
 		if err != nil && err == io.EOF {
 			break
 		} else if err != nil {
-			//loger.Error(err)
+			// logger.Error(err)
 			return ""
 			//	panic(err)
 		}
@@ -51,22 +51,21 @@ func Get(url string, head map[string]string) (response string) {
 	return
 }
 
-//发送GET请求
-//url:请求地址
-//response:请求返回的内容
+// 发送GET请求
+// url:请求地址
+// response:请求返回的内容
 func PersonGet(url string) (response string) {
 	client := &http.Client{Timeout: 5 * time.Second}
 	req, err := http.NewRequest("GET", url, nil)
-
 	if err != nil {
 		return ""
 	}
 	resp, err := client.Do(req)
 	if err != nil {
-		//需要错误日志的处理
-		//loger.Error(error)
+		// 需要错误日志的处理
+		// logger.Error(error)
 		return ""
-		//panic(error)
+		// panic(error)
 	}
 	defer resp.Body.Close()
 	var buffer [512]byte
@@ -77,7 +76,7 @@ func PersonGet(url string) (response string) {
 		if err != nil && err == io.EOF {
 			break
 		} else if err != nil {
-			//loger.Error(err)
+			// logger.Error(err)
 			return ""
 			//	panic(err)
 		}
@@ -86,11 +85,10 @@ func PersonGet(url string) (response string) {
 	return
 }
 
-//发送POST请求
-//url:请求地址，data:POST请求提交的数据,contentType:请求体格式，如：application/json
-//content:请求放回的内容
+// 发送POST请求
+// url:请求地址，data:POST请求提交的数据,contentType:请求体格式，如：application/json
+// content:请求放回的内容
 func Post(url string, data []byte, contentType string, head map[string]string) (content string) {
-
 	req, err := http.NewRequest("POST", url, bytes.NewBuffer(data))
 	req.Header.Add("content-type", contentType)
 	for k, v := range head {
@@ -113,9 +111,9 @@ func Post(url string, data []byte, contentType string, head map[string]string) (
 	return
 }
 
-//发送POST请求
-//url:请求地址，data:POST请求提交的数据,contentType:请求体格式，如：application/json
-//content:请求放回的内容
+// 发送POST请求
+// url:请求地址，data:POST请求提交的数据,contentType:请求体格式，如：application/json
+// content:请求放回的内容
 func ZeroTierGet(url string, head map[string]string) (content string, code int) {
 	req, err := http.NewRequest(http.MethodGet, url, nil)
 	for k, v := range head {
@@ -138,11 +136,10 @@ func ZeroTierGet(url string, head map[string]string) (content string, code int)
 	return
 }
 
-//发送GET请求
-//url:请求地址
-//response:请求返回的内容
+// 发送GET请求
+// url:请求地址
+// response:请求返回的内容
 func OasisGet(url string) (response string) {
-
 	head := make(map[string]string)
 
 	t := make(chan string)
@@ -155,5 +152,4 @@ func OasisGet(url string) (response string) {
 	head["Authorization"] = <-t
 
 	return Get(url, head)
-
 }

pkg/utils/jwt/jwt.go

@@ -1,63 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2021-09-30 18:18:14
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-18 17:30:38
- * @FilePath: /CasaOS/pkg/utils/jwt/jwt.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package jwt
-
-import (
-	"time"
-
-	jwt "github.com/golang-jwt/jwt/v4"
-)
-
-type Claims struct {
-	Username string `json:"username"`
-	PassWord string `json:"password"`
-	Id       int    `json:"id"`
-	jwt.RegisteredClaims
-}
-
-var jwtSecret []byte
-
-//创建token
-func GenerateToken(username, password string, id int, issuer string, t time.Duration) (string, error) {
-	clims := Claims{
-		username,
-		password,
-		id,
-		jwt.RegisteredClaims{
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(t)),
-			IssuedAt:  jwt.NewNumericDate(time.Now()),
-			NotBefore: jwt.NewNumericDate(time.Now()),
-			Issuer:    issuer,
-		},
-	}
-
-	tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, clims)
-	token, err := tokenClaims.SignedString(jwtSecret)
-	return token, err
-
-}
-
-//解析token
-func ParseToken(token string, valid bool) (*Claims, error) {
-	tokenClaims, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (interface{}, error) {
-		return jwtSecret, nil
-	})
-	if tokenClaims != nil {
-		if clims, ok := tokenClaims.Claims.(*Claims); ok {
-			if valid && tokenClaims.Valid {
-				return clims, nil
-			} else if !valid {
-				return clims, nil
-			}
-		}
-	}
-	return nil, err
-}

pkg/utils/jwt/jwt_helper.go

@@ -1,75 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-06-17 14:01:25
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-29 16:22:25
- * @FilePath: /CasaOS/pkg/utils/jwt/jwt_helper.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package jwt
-
-import (
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
-	loger2 "github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-	"github.com/gin-gonic/gin"
-)
-
-func JWT() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		var code int
-		code = common_err.SUCCESS
-		token := c.GetHeader("Authorization")
-		if len(token) == 0 {
-			token = c.Query("token")
-		}
-		if token == "" {
-			code = common_err.INVALID_PARAMS
-		}
-
-		claims, err := ParseToken(token, false)
-
-		//_, err := ParseToken(token)
-		if err != nil {
-			code = common_err.ERROR_AUTH_TOKEN
-		} else if (c.Request.URL.Path == "/v1/file" || c.Request.URL.Path == "/v1/image" || c.Request.URL.Path == "/v1/file/upload" || c.Request.URL.Path == "/v1/batch") && claims.VerifyIssuer("casaos", true) {
-			//Special treatment
-		} else if !claims.VerifyExpiresAt(time.Now(), true) || !claims.VerifyIssuer("casaos", true) {
-			code = common_err.ERROR_AUTH_TOKEN
-		}
-		if code != common_err.SUCCESS {
-			c.JSON(code, model.Result{Success: code, Message: common_err.GetMsg(code)})
-			c.Abort()
-			return
-		}
-		c.Request.Header.Add("user_id", strconv.Itoa(claims.Id))
-		c.Next()
-	}
-}
-
-//get AccessToken
-func GetAccessToken(username, pwd string, id int) string {
-	token, err := GenerateToken(username, pwd, id, "casaos", 3*time.Hour*time.Duration(1))
-	if err == nil {
-		return token
-	} else {
-		loger2.Error(fmt.Sprintf("Get Token Fail: %V", err))
-		return ""
-	}
-}
-
-func GetRefreshToken(username, pwd string, id int) string {
-	token, err := GenerateToken(username, pwd, id, "refresh", 7*24*time.Hour*time.Duration(1))
-	if err == nil {
-		return token
-	} else {
-		loger2.Error(fmt.Sprintf("Get Token Fail: %V", err))
-		return ""
-	}
-}

pkg/utils/loger/log.go

@@ -1,92 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-06-02 15:09:38
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-06-27 15:47:49
- * @FilePath: /CasaOS/pkg/utils/loger/log.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package loger
-
-import (
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"runtime"
-
-	"github.com/IceWhaleTech/CasaOS/pkg/config"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-	"gopkg.in/natefinch/lumberjack.v2"
-)
-
-var loggers *zap.Logger
-
-func getFileLogWriter() (writeSyncer zapcore.WriteSyncer) {
-	// 使用 lumberjack 实现 log rotate
-	lumberJackLogger := &lumberjack.Logger{
-		Filename: filepath.Join(config.AppInfo.LogPath, fmt.Sprintf("%s.%s",
-			config.AppInfo.LogSaveName,
-			config.AppInfo.LogFileExt,
-		)),
-		MaxSize:    10,
-		MaxBackups: 60,
-		MaxAge:     1,
-		Compress:   true,
-	}
-
-	return zapcore.AddSync(lumberJackLogger)
-}
-
-func LogInit() {
-	encoderConfig := zap.NewProductionEncoderConfig()
-	encoderConfig.EncodeTime = zapcore.EpochTimeEncoder
-	encoder := zapcore.NewJSONEncoder(encoderConfig)
-	fileWriteSyncer := getFileLogWriter()
-	core := zapcore.NewTee(
-		zapcore.NewCore(encoder, zapcore.AddSync(os.Stdout), zapcore.InfoLevel),
-		zapcore.NewCore(encoder, fileWriteSyncer, zapcore.InfoLevel),
-	)
-	loggers = zap.New(core)
-
-}
-
-func Info(message string, fields ...zap.Field) {
-	callerFields := getCallerInfoForLog()
-	fields = append(fields, callerFields...)
-	loggers.Info(message, fields...)
-}
-
-func Debug(message string, fields ...zap.Field) {
-	callerFields := getCallerInfoForLog()
-	fields = append(fields, callerFields...)
-	loggers.Debug(message, fields...)
-}
-
-func Error(message string, fields ...zap.Field) {
-	callerFields := getCallerInfoForLog()
-	fields = append(fields, callerFields...)
-	loggers.Error(message, fields...)
-}
-
-func Warn(message string, fields ...zap.Field) {
-	callerFields := getCallerInfoForLog()
-	fields = append(fields, callerFields...)
-	loggers.Warn(message, fields...)
-}
-
-func getCallerInfoForLog() (callerFields []zap.Field) {
-
-	pc, file, line, ok := runtime.Caller(2) // 回溯两层，拿到写日志的调用方的函数信息
-	if !ok {
-		return
-	}
-	funcName := runtime.FuncForPC(pc).Name()
-	funcName = path.Base(funcName) //Base函数返回路径的最后一个元素，只保留函数名
-
-	callerFields = append(callerFields, zap.String("func", funcName), zap.String("file", file), zap.Int("line", line))
-	return
-}

pkg/utils/port/port.go

@@ -1,68 +0,0 @@
-package port
-
-import (
-	"fmt"
-	"net"
-)
-
-// 获取可用端口
-func GetAvailablePort(t string) (int, error) {
-	address := fmt.Sprintf("%s:0", "0.0.0.0")
-	if t == "udp" {
-		add, err := net.ResolveUDPAddr(t, address)
-		if err != nil {
-			return 0, err
-		}
-
-		listener, err := net.ListenUDP(t, add)
-		if err != nil {
-			return 0, err
-		}
-
-		defer listener.Close()
-		return listener.LocalAddr().(*net.UDPAddr).Port, nil
-	} else {
-		add, err := net.ResolveTCPAddr(t, address)
-		if err != nil {
-			return 0, err
-		}
-
-		listener, err := net.ListenTCP(t, add)
-		if err != nil {
-			return 0, err
-		}
-
-		defer listener.Close()
-		return listener.Addr().(*net.TCPAddr).Port, nil
-	}
-
-}
-
-// 判断端口是否可以（未被占用）
-// param t tcp/udp
-func IsPortAvailable(port int, t string) bool {
-	address := fmt.Sprintf("%s:%d", "0.0.0.0", port)
-	if t == "udp" {
-		sadd, err := net.ResolveUDPAddr("udp", address)
-		uc, err := net.ListenUDP("udp", sadd)
-
-		if err != nil {
-			fmt.Println(err.Error())
-			return false
-		} else {
-			defer uc.Close()
-			return true
-		}
-
-	} else {
-		listener, err := net.Listen(t, address)
-
-		if err != nil {
-			//log.Infof("port %s is taken: %s", address, err)
-			return false
-		}
-		defer listener.Close()
-		return true
-	}
-
-}

pkg/utils/port/port_test.go

@@ -1,18 +0,0 @@
-package port
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestPortAvailable(t *testing.T) {
-	//	fmt.Println(PortAvailable())
-	//fmt.Println(IsPortAvailable(6881,"tcp"))
-	p, _ := GetAvailablePort("udp")
-	fmt.Println("udp", p)
-	fmt.Println(IsPortAvailable(p, "udp"))
-
-	t1, _ := GetAvailablePort("tcp")
-	fmt.Println("tcp", t1)
-	fmt.Println(IsPortAvailable(t1, "tcp"))
-}

pkg/utils/random/random.go

@@ -1,24 +0,0 @@
-package random
-
-import (
-	"math/rand"
-	"time"
-)
-
-func RandomString(n int, onlyLetter bool) string {
-
-	var letters []rune
-
-	if onlyLetter {
-		letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
-	} else {
-		letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
-	}
-
-	b := make([]rune, n)
-	rand.Seed(time.Now().UnixNano())
-	for i := range b {
-		b[i] = letters[rand.Intn(len(letters))]
-	}
-	return string(b)
-}

pkg/utils/random/random_test.go

@@ -1,10 +0,0 @@
-package random
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestRandomString(t *testing.T) {
-	fmt.Println(RandomString(6, true))
-}

route/darwin.go

@@ -5,7 +5,7 @@
  * @Author: LinkLeong link@icewhale.org
  * @Date: 2022-08-12 14:22:28
  * @LastEditors: LinkLeong
- * @LastEditTime: 2022-08-12 18:41:14
+ * @LastEditTime: 2022-09-05 16:27:55
  * @FilePath: /CasaOS/route/darwin.go
  * @Description:
  * @Website: https://www.casaos.io

route/init.go

@@ -1,147 +1,63 @@
+/*
+ * @Author: LinkLeong link@icewhale.org
+ * @Date: 2022-11-15 15:51:44
+ * @LastEditors: LinkLeong
+ * @LastEditTime: 2022-11-15 15:55:16
+ * @FilePath: /CasaOS/route/init.go
+ * @Description:
+ * @Website: https://www.casaos.io
+ * Copyright (c) 2022 by icewhale, All Rights Reserved.
+ */
 package route
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
-	"strconv"
 	"strings"
 	"time"
 
+	"github.com/IceWhaleTech/CasaOS-Common/utils/logger"
+	"github.com/IceWhaleTech/CasaOS/model"
 	"github.com/IceWhaleTech/CasaOS/pkg/config"
 	"github.com/IceWhaleTech/CasaOS/pkg/samba"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/command"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/encryption"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
 	"github.com/IceWhaleTech/CasaOS/service"
-	model2 "github.com/IceWhaleTech/CasaOS/service/model"
-	uuid "github.com/satori/go.uuid"
+	"github.com/IceWhaleTech/CasaOS/types"
 	"go.uber.org/zap"
 )
 
 func InitFunction() {
-	ShellInit()
-	CheckSerialDiskMount()
-	CheckToken2_11()
-	ImportApplications()
-	// Soon to be removed
-	ChangeAPIUrl()
-	MoveUserToDB()
 	go InitNetworkMount()
-
+	go InitInfo()
 }
 
-func CheckSerialDiskMount() {
-	// check mount point
-	dbList := service.MyService.Disk().GetSerialAll()
-
-	list := service.MyService.Disk().LSBLK(true)
-	mountPoint := make(map[string]string, len(dbList))
-	//remount
-	for _, v := range dbList {
-		mountPoint[v.UUID] = v.MountPoint
-	}
-	for _, v := range list {
-		command.ExecEnabledSMART(v.Path)
-		if v.Children != nil {
-			for _, h := range v.Children {
-				//if len(h.MountPoint) == 0 && len(v.Children) == 1 && h.FsType == "ext4" {
-				if m, ok := mountPoint[h.UUID]; ok {
-					//mount point check
-					volume := m
-					if !file.CheckNotExist(m) {
-						for i := 0; file.CheckNotExist(volume); i++ {
-							volume = m + strconv.Itoa(i+1)
-						}
-					}
-					service.MyService.Disk().MountDisk(h.Path, volume)
-					if volume != m {
-						ms := model2.SerialDisk{}
-						ms.UUID = v.UUID
-						ms.MountPoint = volume
-						service.MyService.Disk().UpdateMountPoint(ms)
-					}
-
-				}
-				//}
-			}
+func InitInfo() {
+	mb := model.BaseInfo{}
+	if file.Exists(config.AppInfo.DBPath + "/baseinfo.conf") {
+		err := json.Unmarshal(file.ReadFullFile(config.AppInfo.DBPath+"/baseinfo.conf"), &mb)
+		if err != nil {
+			logger.Error("baseinfo.conf", zap.String("error", err.Error()))
 		}
 	}
-	service.MyService.Disk().RemoveLSBLKCache()
-	command.OnlyExec("source " + config.AppInfo.ShellPath + "/helper.sh ;AutoRemoveUnuseDir")
-}
-func ShellInit() {
-	command.OnlyExec("curl -fsSL https://raw.githubusercontent.com/IceWhaleTech/get/main/assist.sh | bash")
-	if !file.CheckNotExist("/casaOS") {
-		command.OnlyExec("source /casaOS/server/shell/update.sh ;")
-		command.OnlyExec("source " + config.AppInfo.ShellPath + "/delete-old-service.sh ;")
+	if file.Exists("/etc/CHANNEL") {
+		channel := file.ReadFullFile("/etc/CHANNEL")
+		mb.Channel = string(channel)
 	}
-
-}
-func CheckToken2_11() {
-	if len(config.ServerInfo.Token) == 0 {
-		token := uuid.NewV4().String
-		config.ServerInfo.Token = token()
-		config.Cfg.Section("server").Key("Token").SetValue(token())
-		config.Cfg.SaveTo(config.SystemConfigInfo.ConfigPath)
+	mac, err := service.MyService.System().GetMacAddress()
+	if err != nil {
+		logger.Error("GetMacAddress", zap.String("error", err.Error()))
 	}
-
-	if len(config.UserInfo.Description) == 0 {
-		config.Cfg.Section("user").Key("Description").SetValue("nothing")
-		config.UserInfo.Description = "nothing"
-		config.Cfg.SaveTo(config.SystemConfigInfo.ConfigPath)
-	}
-
-	if service.MyService.System().GetSysInfo().KernelArch == "aarch64" && config.ServerInfo.USBAutoMount != "True" && strings.Contains(service.MyService.System().GetDeviceTree(), "Raspberry Pi") {
-		service.MyService.System().UpdateUSBAutoMount("False")
-		service.MyService.System().ExecUSBAutoMountShell("False")
-	}
-
-	// str := []string{}
-	// str = append(str, "ddd")
-	// str = append(str, "aaa")
-	// ddd := strings.Join(str, "|")
-	// config.Cfg.Section("file").Key("ShareDir").SetValue(ddd)
-
-	// config.Cfg.SaveTo(config.SystemConfigInfo.ConfigPath)
-
-}
-
-func ImportApplications() {
-	service.MyService.App().ImportApplications(true)
-}
-
-// 0.3.1
-func ChangeAPIUrl() {
-
-	newAPIUrl := "https://api.casaos.io/casaos-api"
-	if config.ServerInfo.ServerApi == "https://api.casaos.zimaboard.com" {
-		config.ServerInfo.ServerApi = newAPIUrl
-		config.Cfg.Section("server").Key("ServerApi").SetValue(newAPIUrl)
-		config.Cfg.SaveTo(config.SystemConfigInfo.ConfigPath)
-	}
-
-}
-
-//0.3.3
-//Transferring user data to the database
-func MoveUserToDB() {
-
-	if len(config.UserInfo.UserName) > 0 && service.MyService.User().GetUserInfoByUserName(config.UserInfo.UserName).Id == 0 {
-		user := model2.UserDBModel{}
-		user.Username = config.UserInfo.UserName
-		user.Email = config.UserInfo.Email
-		user.Nickname = config.UserInfo.NickName
-		user.Password = encryption.GetMD5ByStr(config.UserInfo.PWD)
-		user.Role = "admin"
-		user = service.MyService.User().CreateUser(user)
-		if user.Id > 0 {
-			userPath := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id)
-			file.MkDir(userPath)
-			os.Rename("/casaOS/server/conf/app_order.json", userPath+"/app_order.json")
-		}
-
+	mb.Hash = encryption.GetMD5ByStr(mac)
+	mb.Version = types.CURRENTVERSION
+	os.Remove(config.AppInfo.DBPath + "/baseinfo.conf")
+	by, err := json.Marshal(mb)
+	if err != nil {
+		logger.Error("init info err", zap.Any("err", err))
+		return
 	}
+	file.WriteToFullPath(by, config.AppInfo.DBPath+"/baseinfo.conf", 0o666)
 }
 
 func InitNetworkMount() {
@@ -152,7 +68,7 @@ func InitNetworkMount() {
 		directories, err := samba.GetSambaSharesList(connection.Host, connection.Port, connection.Username, connection.Password)
 		if err != nil {
 			service.MyService.Connections().DeleteConnection(fmt.Sprint(connection.ID))
-			loger.Error("mount samba err", zap.Any("err", err), zap.Any("info", connection))
+			logger.Error("mount samba err", zap.Any("err", err), zap.Any("info", connection))
 			continue
 		}
 		baseHostPath := "/mnt/" + connection.Host

route/periodical.go

@@ -5,7 +5,7 @@
  * @Author: LinkLeong link@icewhale.com
  * @Date: 2022-07-01 15:11:36
  * @LastEditors: LinkLeong
- * @LastEditTime: 2022-08-15 11:50:04
+ * @LastEditTime: 2022-09-05 16:28:46
  * @FilePath: /CasaOS/route/periodical.go
  * @Description:
  * @Website: https://www.casaos.io
@@ -14,20 +14,12 @@
 package route
 
 import (
-	"os"
-	"os/signal"
-	"reflect"
-	"strconv"
 	"strings"
-	"syscall"
 	"time"
 	"unsafe"
 
 	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
 	"github.com/IceWhaleTech/CasaOS/service"
-	"github.com/pilebones/go-udev/netlink"
-	"go.uber.org/zap"
 )
 
 func SendNetINfoBySocket() {
@@ -61,106 +53,7 @@ func SendMemBySocket() {
 	service.MyService.Notify().SendMemInfoBySocket(service.MyService.System().GetMemInfo())
 }
 
-func SendDiskBySocket() {
-	list := service.MyService.Disk().LSBLK(true)
-
-	summary := model.Summary{}
-	healthy := true
-	findSystem := 0
-
-	for i := 0; i < len(list); i++ {
-		if len(list[i].Children) > 0 && findSystem == 0 {
-
-			for j := 0; j < len(list[i].Children); j++ {
-
-				if len(list[i].Children[j].Children) > 0 {
-					for _, v := range list[i].Children[j].Children {
-						if v.MountPoint == "/" {
-							s, _ := strconv.ParseUint(v.FSSize, 10, 64)
-							a, _ := strconv.ParseUint(v.FSAvail, 10, 64)
-							u, _ := strconv.ParseUint(v.FSUsed, 10, 64)
-							summary.Size += s
-							summary.Avail += a
-							summary.Used += u
-							findSystem = 1
-							break
-						}
-					}
-				} else {
-					if list[i].Children[j].MountPoint == "/" {
-						s, _ := strconv.ParseUint(list[i].Children[j].FSSize, 10, 64)
-						a, _ := strconv.ParseUint(list[i].Children[j].FSAvail, 10, 64)
-						u, _ := strconv.ParseUint(list[i].Children[j].FSUsed, 10, 64)
-						summary.Size += s
-						summary.Avail += a
-						summary.Used += u
-						findSystem = 1
-						break
-					}
-				}
-			}
-
-		}
-		if findSystem == 1 {
-			findSystem += 1
-			continue
-		}
-		if list[i].Tran == "sata" || list[i].Tran == "nvme" || list[i].Tran == "spi" || list[i].Tran == "sas" || strings.Contains(list[i].SubSystems, "virtio") || (list[i].Tran == "ata" && list[i].Type == "disk") {
-			temp := service.MyService.Disk().SmartCTL(list[i].Path)
-			if reflect.DeepEqual(temp, model.SmartctlA{}) {
-				healthy = true
-			} else {
-				healthy = temp.SmartStatus.Passed
-			}
-
-			//list[i].Temperature = temp.Temperature.Current
-
-			if len(list[i].Children) > 0 {
-				for _, v := range list[i].Children {
-					s, _ := strconv.ParseUint(v.FSSize, 10, 64)
-					a, _ := strconv.ParseUint(v.FSAvail, 10, 64)
-					u, _ := strconv.ParseUint(v.FSUsed, 10, 64)
-					summary.Size += s
-					summary.Avail += a
-					summary.Used += u
-				}
-			}
-
-		}
-	}
-
-	summary.Health = healthy
-	service.MyService.Notify().SendDiskInfoBySocket(summary)
-}
-
-func SendUSBBySocket() {
-	usbList := service.MyService.Disk().LSBLK(false)
-	usb := []model.DriveUSB{}
-	for _, v := range usbList {
-		if v.Tran == "usb" {
-			isMount := false
-			temp := model.DriveUSB{}
-			temp.Model = v.Model
-			temp.Name = v.Name
-			temp.Size = v.Size
-			for _, child := range v.Children {
-				if len(child.MountPoint) > 0 {
-					isMount = true
-					avail, _ := strconv.ParseUint(child.FSAvail, 10, 64)
-					temp.Avail += avail
-
-				}
-			}
-			if isMount {
-				usb = append(usb, temp)
-			}
-		}
-	}
-	service.MyService.Notify().SendUSBInfoBySocket(usb)
-}
-
 func SendAllHardwareStatusBySocket() {
-
 	netList := service.MyService.System().GetNetInfo()
 	newNet := []model.IOCountersStat{}
 	nets := service.MyService.System().GetNet(true)
@@ -176,136 +69,61 @@ func SendAllHardwareStatusBySocket() {
 		}
 	}
 	cpu := service.MyService.System().GetCpuPercent()
+
+	var cpuModel = "arm"
+	if cpu := service.MyService.System().GetCpuInfo(); len(cpu) > 0 {
+		if strings.Count(strings.ToLower(strings.TrimSpace(cpu[0].ModelName)), "intel") > 0 {
+			cpuModel = "intel"
+		} else if strings.Count(strings.ToLower(strings.TrimSpace(cpu[0].ModelName)), "amd") > 0 {
+			cpuModel = "amd"
+		}
+	}
+
 	num := service.MyService.System().GetCpuCoreNum()
 	cpuData := make(map[string]interface{})
 	cpuData["percent"] = cpu
 	cpuData["num"] = num
+	cpuData["temperature"] = service.MyService.System().GetCPUTemperature()
+	cpuData["power"] = service.MyService.System().GetCPUPower()
+	cpuData["model"] = cpuModel
 
-	list := service.MyService.Disk().LSBLK(true)
-
-	summary := model.Summary{}
-	healthy := true
-	findSystem := 0
-
-	for i := 0; i < len(list); i++ {
-		if len(list[i].Children) > 0 && findSystem == 0 {
-
-			for j := 0; j < len(list[i].Children); j++ {
-
-				if len(list[i].Children[j].Children) > 0 {
-					for _, v := range list[i].Children[j].Children {
-						if v.MountPoint == "/" {
-							s, _ := strconv.ParseUint(v.FSSize, 10, 64)
-							a, _ := strconv.ParseUint(v.FSAvail, 10, 64)
-							u, _ := strconv.ParseUint(v.FSUsed, 10, 64)
-							summary.Size += s
-							summary.Avail += a
-							summary.Used += u
-							findSystem = 1
-							break
-						}
-					}
-				} else {
-					if list[i].Children[j].MountPoint == "/" {
-						s, _ := strconv.ParseUint(list[i].Children[j].FSSize, 10, 64)
-						a, _ := strconv.ParseUint(list[i].Children[j].FSAvail, 10, 64)
-						u, _ := strconv.ParseUint(list[i].Children[j].FSUsed, 10, 64)
-						summary.Size += s
-						summary.Avail += a
-						summary.Used += u
-						findSystem = 1
-						break
-					}
-				}
-			}
-
-		}
-		if findSystem == 1 {
-			findSystem += 1
-			continue
-		}
-		if list[i].Tran == "sata" || list[i].Tran == "nvme" || list[i].Tran == "spi" || list[i].Tran == "sas" || strings.Contains(list[i].SubSystems, "virtio") || (list[i].Tran == "ata" && list[i].Type == "disk") {
-			temp := service.MyService.Disk().SmartCTL(list[i].Path)
-			if reflect.DeepEqual(temp, model.SmartctlA{}) {
-				healthy = true
-			} else {
-				healthy = temp.SmartStatus.Passed
-			}
-			if len(list[i].Children) > 0 {
-				for _, v := range list[i].Children {
-					s, _ := strconv.ParseUint(v.FSSize, 10, 64)
-					a, _ := strconv.ParseUint(v.FSAvail, 10, 64)
-					u, _ := strconv.ParseUint(v.FSUsed, 10, 64)
-					summary.Size += s
-					summary.Avail += a
-					summary.Used += u
-				}
-			}
-
-		}
-	}
-
-	summary.Health = healthy
-
-	usbList := service.MyService.Disk().LSBLK(false)
-	usb := []model.DriveUSB{}
-	for _, v := range usbList {
-		if v.Tran == "usb" {
-			isMount := false
-			temp := model.DriveUSB{}
-			temp.Model = v.Model
-			temp.Name = v.Name
-			temp.Size = v.Size
-			for _, child := range v.Children {
-				if len(child.MountPoint) > 0 {
-					isMount = true
-					avail, _ := strconv.ParseUint(child.FSAvail, 10, 64)
-					temp.Avail += avail
-				}
-			}
-			if isMount {
-				usb = append(usb, temp)
-			}
-
-		}
-	}
 	memInfo := service.MyService.System().GetMemInfo()
 
-	service.MyService.Notify().SendAllHardwareStatusBySocket(summary, usb, memInfo, cpuData, newNet)
-
+	service.MyService.Notify().SendAllHardwareStatusBySocket(memInfo, cpuData, newNet)
 }
-func MonitoryUSB() {
-	var matcher netlink.Matcher
 
-	conn := new(netlink.UEventConn)
-	if err := conn.Connect(netlink.UdevEvent); err != nil {
-		loger.Error("udev err", zap.Any("Unable to connect to Netlink Kobject UEvent socket", err))
-	}
-	defer conn.Close()
+// func MonitoryUSB() {
+// 	var matcher netlink.Matcher
 
-	queue := make(chan netlink.UEvent)
-	errors := make(chan error)
-	quit := conn.Monitor(queue, errors, matcher)
+// 	conn := new(netlink.UEventConn)
+// 	if err := conn.Connect(netlink.UdevEvent); err != nil {
+// 		logger.Error("udev err", zap.Any("Unable to connect to Netlink Kobject UEvent socket", err))
+// 	}
+// 	defer conn.Close()
 
-	signals := make(chan os.Signal, 1)
-	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
-	go func() {
-		<-signals
-		close(quit)
-		os.Exit(0)
-	}()
+// 	queue := make(chan netlink.UEvent)
+// 	errors := make(chan error)
+// 	quit := conn.Monitor(queue, errors, matcher)
 
-	for {
-		select {
-		case uevent := <-queue:
-			if uevent.Env["DEVTYPE"] == "disk" {
-				time.Sleep(time.Microsecond * 500)
-				SendUSBBySocket()
-				continue
-			}
-		case err := <-errors:
-			loger.Error("udev err", zap.Any("err", err))
-		}
-	}
+// 	signals := make(chan os.Signal, 1)
+// 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+// 	go func() {
+// 		<-signals
+// 		close(quit)
+// 		os.Exit(0)
+// 	}()
 
-}
+// 	for {
+// 		select {
+// 		case uevent := <-queue:
+// 			if uevent.Env["DEVTYPE"] == "disk" {
+// 				time.Sleep(time.Microsecond * 500)
+// 				SendUSBBySocket()
+// 				continue
+// 			}
+// 		case err := <-errors:
+// 			logger.Error("udev err", zap.Any("err", err))
+// 		}
+// 	}
+
+// }

route/route.go

@@ -1,131 +1,80 @@
 package route
 
 import (
-	"net/http"
+	"os"
 
-	"github.com/IceWhaleTech/CasaOS/middleware"
+	"github.com/IceWhaleTech/CasaOS-Common/middleware"
+	"github.com/IceWhaleTech/CasaOS-Common/utils/jwt"
 	"github.com/IceWhaleTech/CasaOS/pkg/config"
-	jwt2 "github.com/IceWhaleTech/CasaOS/pkg/utils/jwt"
 	v1 "github.com/IceWhaleTech/CasaOS/route/v1"
-	"github.com/IceWhaleTech/CasaOS/web"
 
 	"github.com/gin-contrib/gzip"
 	"github.com/gin-gonic/gin"
 )
 
-var OnlineDemo bool = false
-
 func InitRouter() *gin.Engine {
+	ginMode := gin.ReleaseMode
+	if config.ServerInfo.RunMode != "" {
+		ginMode = config.ServerInfo.RunMode
+	}
+	if os.Getenv(gin.EnvGinMode) != "" {
+		ginMode = os.Getenv(gin.EnvGinMode)
+	}
+	gin.SetMode(ginMode)
 
-	r := gin.Default()
-
+	r := gin.New()
+	r.Use(gin.Recovery())
 	r.Use(middleware.Cors())
-	r.Use(middleware.WriteLog())
 	r.Use(gzip.Gzip(gzip.DefaultCompression))
-	gin.SetMode(config.ServerInfo.RunMode)
+	if ginMode != gin.ReleaseMode {
+		r.Use(middleware.WriteLog())
+	}
 
-	r.StaticFS("/ui", http.FS(web.Static))
-	r.GET("/", WebUIHome)
+	// r.StaticFS("/ui", http.FS(web.Static))
+	// r.GET("/", WebUIHome)
 	// r.StaticFS("/assets", http.Dir("./static/assets"))
 	// r.StaticFile("/favicon.ico", "./static/favicon.ico")
 	//r.GET("/", func(c *gin.Context) {
 	//	c.Redirect(http.StatusMovedPermanently, "ui/")
 	//})
 
-	r.POST("/v1/users/register", v1.PostUserRegister)
-	r.POST("/v1/users/login", v1.PostUserLogin)
-	r.GET("/v1/users/name", v1.GetUserAllUsername) //all/name
-	r.POST("/v1/users/refresh", v1.PostUserRefreshToken)
-	// No short-term modifications
-	r.GET("/v1/users/image", v1.GetUserImage)
+	// r.POST("/v1/users/register", v1.PostUserRegister)
+	// r.POST("/v1/users/login", v1.PostUserLogin)
+	// r.GET("/v1/users/name", v1.GetUserAllUsername) //all/name
+	// r.POST("/v1/users/refresh", v1.PostUserRefreshToken)
+	// // No short-term modifications
+	// r.GET("/v1/users/image", v1.GetUserImage)
 
-	r.GET("/v1/users/status", v1.GetUserStatus) //init/check
-	//r.GET("/v1/guide/check", v1.GetGuideCheck)         // /v1/sys/guide_check
+	// r.GET("/v1/users/status", v1.GetUserStatus) //init/check
+	// r.GET("/v1/guide/check", v1.GetGuideCheck)         // /v1/sys/guide_check
 	r.GET("/v1/sys/debug", v1.GetSystemConfigDebug) // //debug
 
 	r.GET("/v1/sys/socket-port", v1.GetSystemSocketPort) //sys/socket_port
 	r.GET("/v1/sys/version/check", v1.GetSystemCheckVersion)
-
+	r.GET("/ping", func(ctx *gin.Context) {
+		ctx.String(200, "pong")
+	})
 	v1Group := r.Group("/v1")
 
-	v1Group.Use(jwt2.JWT())
+	v1Group.Use(jwt.ExceptLocalhost())
 	{
-		v1UsersGroup := v1Group.Group("/users")
-		v1UsersGroup.Use()
-		{
-			v1UsersGroup.GET("/current", v1.GetUserInfo)
-			v1UsersGroup.PUT("/current", v1.PutUserInfo)
-			v1UsersGroup.PUT("/current/password", v1.PutUserPassword)
-
-			v1UsersGroup.GET("/current/custom/:key", v1.GetUserCustomConf)
-			v1UsersGroup.POST("/current/custom/:key", v1.PostUserCustomConf)
-			v1UsersGroup.DELETE("/current/custom/:key", v1.DeleteUserCustomConf)
-
-			v1UsersGroup.POST("/current/image/:key", v1.PostUserUploadImage)
-			v1UsersGroup.PUT("/current/image/:key", v1.PutUserImage)
-			//v1UserGroup.POST("/file/image/:key", v1.PostUserFileImage)
-			v1UsersGroup.DELETE("/current/image", v1.DeleteUserImage)
-
-			//v1UserGroup.PUT("/avatar", v1.PutUserAvatar)
-			//v1UserGroup.GET("/avatar", v1.GetUserAvatar)
-			v1UsersGroup.DELETE("/:id", v1.DeleteUser)
-			v1UsersGroup.GET("/:username", v1.GetUserInfoByUsername)
-			v1UsersGroup.DELETE("", v1.DeleteUserAll)
-		}
-
-		v1AppsGroup := v1Group.Group("/apps")
-		v1AppsGroup.Use()
-		{
-			v1AppsGroup.GET("", v1.AppList) //list
-			v1AppsGroup.GET("/:id", v1.AppInfo)
-		}
-		v1ContainerGroup := v1Group.Group("/container")
-		v1ContainerGroup.Use()
-		{
-			v1ContainerGroup.GET("", v1.MyAppList) ///my/list
-			v1ContainerGroup.GET("/usage", v1.AppUsageList)
-			v1ContainerGroup.GET("/:id", v1.ContainerUpdateInfo)    ///update/:id/info
-			v1ContainerGroup.GET("/:id/logs", v1.ContainerLog)      // /app/logs/:id
-			v1ContainerGroup.GET("/networks", v1.GetDockerNetworks) //app/install/config
-
-			v1ContainerGroup.GET("/:id/state", v1.GetContainerState) //app/state/:id ?state=install_progress
-			// there are problems, temporarily do not deal with
-			v1ContainerGroup.GET("/:id/terminal", v1.DockerTerminal) //app/terminal/:id
-			v1ContainerGroup.POST("", v1.InstallApp)                 //app/install
-			//v1ContainerGroup.GET("/:id", v1.ContainerInfo) // /app/info/:id
-
-			v1ContainerGroup.PUT("/:id", v1.UpdateSetting) ///update/:id/setting
-
-			v1ContainerGroup.PUT("/:id/state", v1.ChangAppState) // /app/state/:id
-			v1ContainerGroup.DELETE("/:id", v1.UnInstallApp)     //app/uninstall/:id
-			//Not used
-			v1ContainerGroup.PUT("/:id/latest", v1.PutAppUpdate)
-			//Not used
-			v1ContainerGroup.POST("/share", v1.ShareAppFile)
-
-		}
-		v1AppCategoriesGroup := v1Group.Group("/app-categories")
-		v1AppCategoriesGroup.Use()
-		{
-			v1AppCategoriesGroup.GET("", v1.CategoryList)
-		}
 
 		v1SysGroup := v1Group.Group("/sys")
 		v1SysGroup.Use()
 		{
-			v1SysGroup.GET("/version", v1.GetSystemCheckVersion) //version/check
+			v1SysGroup.GET("/version", v1.GetSystemCheckVersion) // version/check
 
 			v1SysGroup.POST("/update", v1.SystemUpdate)
 
-			v1SysGroup.GET("/hardware", v1.GetSystemHardwareInfo) //hardware/info
+			v1SysGroup.GET("/hardware", v1.GetSystemHardwareInfo) // hardware/info
 
 			v1SysGroup.GET("/wsssh", v1.WsSsh)
 			v1SysGroup.POST("/ssh-login", v1.PostSshLogin)
-			//v1SysGroup.GET("/config", v1.GetSystemConfig) //delete
-			//v1SysGroup.POST("/config", v1.PostSetSystemConfig)
-			v1SysGroup.GET("/logs", v1.GetCasaOSErrorLogs) //error/logs
-			//v1SysGroup.GET("/widget/config", v1.GetWidgetConfig)//delete
-			//v1SysGroup.POST("/widget/config", v1.PostSetWidgetConfig)//delete
+			// v1SysGroup.GET("/config", v1.GetSystemConfig) //delete
+			// v1SysGroup.POST("/config", v1.PostSetSystemConfig)
+			v1SysGroup.GET("/logs", v1.GetCasaOSErrorLogs) // error/logs
+			// v1SysGroup.GET("/widget/config", v1.GetWidgetConfig)//delete
+			// v1SysGroup.POST("/widget/config", v1.PostSetWidgetConfig)//delete
 
 			v1SysGroup.POST("/stop", v1.PostKillCasaOS)
 
@@ -135,36 +84,34 @@ func InitRouter() *gin.Engine {
 			// v1SysGroup.GET("/disk", v1.GetSystemDiskInfo)
 			// v1SysGroup.GET("/network", v1.GetSystemNetInfo)
 
-			v1SysGroup.PUT("/usb-auto-mount", v1.PutSystemUSBAutoMount) ///sys/usb/:status
-			v1SysGroup.GET("/usb-auto-mount", v1.GetSystemUSBAutoMount) ///sys/usb/status
-
 			v1SysGroup.GET("/server-info", nil)
 			v1SysGroup.PUT("/server-info", nil)
-			v1SysGroup.GET("/apps-state", v1.GetSystemAppsStatus)
-			v1SysGroup.GET("/port", v1.GetCasaOSPort)
-			v1SysGroup.PUT("/port", v1.PutCasaOSPort)
+			// v1SysGroup.GET("/port", v1.GetCasaOSPort)
+			// v1SysGroup.PUT("/port", v1.PutCasaOSPort)
+			v1SysGroup.GET("/proxy", v1.GetSystemProxy)
+			v1SysGroup.PUT("/state/:state", v1.PutSystemState)
 		}
 		v1PortGroup := v1Group.Group("/port")
 		v1PortGroup.Use()
 		{
-			v1PortGroup.GET("/", v1.GetPort)              //app/port
-			v1PortGroup.GET("/state/:port", v1.PortCheck) //app/check/:port
+			v1PortGroup.GET("/", v1.GetPort)              // app/port
+			v1PortGroup.GET("/state/:port", v1.PortCheck) // app/check/:port
 		}
 
 		v1FileGroup := v1Group.Group("/file")
 		v1FileGroup.Use()
 		{
-			v1FileGroup.GET("", v1.GetDownloadSingleFile) //download/:path
+			v1FileGroup.GET("", v1.GetDownloadSingleFile) // download/:path
 			v1FileGroup.POST("", v1.PostCreateFile)
 			v1FileGroup.PUT("", v1.PutFileContent)
 			v1FileGroup.PUT("/name", v1.RenamePath)
-			//file/rename
-			v1FileGroup.GET("/content", v1.GetFilerContent) //file/read
+			// file/rename
+			v1FileGroup.GET("/content", v1.GetFilerContent) // file/read
 
-			//File uploads need to be handled separately, and will not be modified here
+			// File uploads need to be handled separately, and will not be modified here
 			v1FileGroup.POST("/upload", v1.PostFileUpload)
 			v1FileGroup.GET("/upload", v1.GetFileUpload)
-			//v1FileGroup.GET("/download", v1.UserFileDownloadCommonService)
+			// v1FileGroup.GET("/download", v1.UserFileDownloadCommonService)
 		}
 		v1FolderGroup := v1Group.Group("/folder")
 		v1FolderGroup.Use()
@@ -177,9 +124,9 @@ func InitRouter() *gin.Engine {
 		v1BatchGroup.Use()
 		{
 
-			v1BatchGroup.DELETE("", v1.DeleteFile) //file/delete
+			v1BatchGroup.DELETE("", v1.DeleteFile) // file/delete
 			v1BatchGroup.DELETE("/:id/task", v1.DeleteOperateFileOrDir)
-			v1BatchGroup.POST("/task", v1.PostOperateFileOrDir) //file/operate
+			v1BatchGroup.POST("/task", v1.PostOperateFileOrDir) // file/operate
 			v1BatchGroup.GET("", v1.GetDownloadFile)
 		}
 		v1ImageGroup := v1Group.Group("/image")
@@ -187,42 +134,6 @@ func InitRouter() *gin.Engine {
 		{
 			v1ImageGroup.GET("", v1.GetFileImage)
 		}
-
-		v1DisksGroup := v1Group.Group("/disks")
-		v1DisksGroup.Use()
-		{
-			//v1DiskGroup.GET("/check", v1.GetDiskCheck) //delete
-			//v1DisksGroup.GET("", v1.GetDiskInfo)
-
-			//v1DisksGroup.POST("", v1.PostMountDisk)
-			v1DisksGroup.GET("", v1.GetDiskList)
-			v1DisksGroup.GET("/usb", v1.GetDisksUSBList)
-			v1DisksGroup.DELETE("/usb", v1.DeleteDiskUSB)
-			v1DisksGroup.DELETE("", v1.DeleteDisksUmount)
-			// //format storage
-			// v1DiskGroup.POST("/format", v1.PostDiskFormat)
-
-			// //mount SATA disk
-			// v1DiskGroup.POST("/mount", v1.PostMountDisk)
-
-			// //umount sata disk
-			// v1DiskGroup.POST("/umount", v1.PostDiskUmount)
-
-			//v1DiskGroup.GET("/type", v1.FormatDiskType)//delete
-
-			v1DisksGroup.DELETE("/part", v1.RemovePartition) //disk/delpart
-		}
-
-		v1StorageGroup := v1Group.Group("/storage")
-		v1StorageGroup.Use()
-		{
-			v1StorageGroup.POST("", v1.PostDiskAddPartition)
-
-			v1StorageGroup.PUT("", v1.PostDiskFormat)
-
-			v1StorageGroup.DELETE("", v1.PostDiskUmount)
-			v1StorageGroup.GET("", v1.GetStorageList)
-		}
 		v1SambaGroup := v1Group.Group("/samba")
 		v1SambaGroup.Use()
 		{
@@ -242,6 +153,15 @@ func InitRouter() *gin.Engine {
 				v1SharesGroup.GET("/status", v1.GetSambaStatus)
 			}
 		}
+		v1NotifyGroup := v1Group.Group("/notify")
+		v1NotifyGroup.Use()
+		{
+			v1NotifyGroup.POST("/:path", v1.PostNotifyMessage)
+			// merge to system
+			v1NotifyGroup.POST("/system_status", v1.PostSystemStatusNotify)
+			v1NotifyGroup.POST("/install_app", v1.PostInstallAppNotify)
+			v1NotifyGroup.POST("/uninstall_app", v1.PostUninstallAppNotify)
+		}
 	}
 	return r
 }

route/socket.go

@@ -14,15 +14,14 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/IceWhaleTech/CasaOS-Common/utils/port"
 	"github.com/IceWhaleTech/CasaOS/model/notify"
 	"github.com/IceWhaleTech/CasaOS/pkg/config"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/port"
 	"github.com/IceWhaleTech/CasaOS/service"
 	f "github.com/ambelovsky/gosf"
 )
 
 func SocketInit(msg chan notify.Message) {
-
 	// set socket port
 	socketPort := 0
 	if len(config.ServerInfo.SocketPort) == 0 {
@@ -51,10 +50,9 @@ func SocketInit(msg chan notify.Message) {
 			f.Broadcast("", v.Path, &v.Msg)
 			time.Sleep(time.Millisecond * 100)
 		}
-
 	}(msg)
 
 	f.Startup(map[string]interface{}{
-		"port": socketPort})
-
+		"port": socketPort,
+	})
 }

route/ui.go

@@ -1,25 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-06-23 17:27:43
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-06-23 17:27:48
- * @FilePath: /CasaOS/route/ui.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package route
-
-import (
-	"html/template"
-
-	"github.com/IceWhaleTech/CasaOS/web"
-	"github.com/gin-gonic/gin"
-)
-
-func WebUIHome(c *gin.Context) {
-	c.Writer.Header().Set("Content-Type", "text/html; charset=utf-8")
-	index, _ := template.ParseFS(web.Static, "index.html")
-	index.Execute(c.Writer, nil)
-	return
-}

route/v1/app.go

@@ -1,264 +0,0 @@
-package v1
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"strconv"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-
-	port2 "github.com/IceWhaleTech/CasaOS/pkg/utils/port"
-	"github.com/IceWhaleTech/CasaOS/service"
-	"github.com/gin-gonic/gin"
-)
-
-// @Summary 获取远程列表
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Param index query int false "页码"
-// @Param size query int false "每页数量"
-// @Param  category_id query int false "分类id"
-// @Param  type query string false "rank,new"
-// @Param  key query string false "search key"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /app/list [get]
-func AppList(c *gin.Context) {
-
-	//service.MyService.Docker().DockerContainerCommit("test2")
-
-	index := c.DefaultQuery("index", "1")
-	size := c.DefaultQuery("size", "10000")
-	t := c.DefaultQuery("type", "rank")
-	categoryId := c.DefaultQuery("category_id", "0")
-	key := c.DefaultQuery("key", "")
-	if len(index) == 0 || len(size) == 0 || len(t) == 0 || len(categoryId) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, &model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	collection, err := service.MyService.Casa().GetServerList(index, size, t, categoryId, key)
-	if err != nil {
-		c.JSON(common_err.SERVICE_ERROR, &model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: err.Error()})
-		return
-	}
-	// for i := 0; i < len(recommend); i++ {
-	// 	ct, _ := service.MyService.Docker().DockerListByImage(recommend[i].Image, recommend[i].ImageVersion)
-	// 	if ct != nil {
-	// 		recommend[i].State = ct.State
-	// 	}
-	// }
-	// for i := 0; i < len(list); i++ {
-	// 	ct, _ := service.MyService.Docker().DockerListByImage(list[i].Image, list[i].ImageVersion)
-	// 	if ct != nil {
-	// 		list[i].State = ct.State
-	// 	}
-	// }
-	// for i := 0; i < len(community); i++ {
-	// 	ct, _ := service.MyService.Docker().DockerListByImage(community[i].Image, community[i].ImageVersion)
-	// 	if ct != nil {
-	// 		community[i].State = ct.State
-	// 	}
-	// }
-	data := make(map[string]interface{}, 3)
-	data["recommend"] = collection.Recommend
-	data["list"] = collection.List
-	data["community"] = collection.Community
-
-	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-}
-
-// @Summary 获取一个可用端口
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Param  type query string true "端口类型 udp/tcp"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /app/getport [get]
-func GetPort(c *gin.Context) {
-	t := c.DefaultQuery("type", "tcp")
-	var p int
-	ok := true
-	for ok {
-		p, _ = port2.GetAvailablePort(t)
-		ok = !port2.IsPortAvailable(p, t)
-	}
-	// @tiger 这里最好封装成 {'port': ...} 的形式，来体现出参的上下文
-	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: p})
-}
-
-// @Summary 检查端口是否可用
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Param  port path int true "端口号"
-// @Param  type query string true "端口类型 udp/tcp"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /app/check/{port} [get]
-func PortCheck(c *gin.Context) {
-	p, _ := strconv.Atoi(c.Param("port"))
-	t := c.DefaultQuery("type", "tcp")
-	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: port2.IsPortAvailable(p, t)})
-}
-
-// @Summary 我的应用列表
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Security ApiKeyAuth
-// @Param  index query int false "index"
-// @Param  size query int false "size"
-// @Param  position query bool false "是否是首页应用"
-// @Success 200 {string} string "ok"
-// @Router /app/my/list [get]
-func MyAppList(c *gin.Context) {
-	index, _ := strconv.Atoi(c.DefaultQuery("index", "1"))
-	size, _ := strconv.Atoi(c.DefaultQuery("size", "0"))
-	position, _ := strconv.ParseBool(c.DefaultQuery("position", "true"))
-	list, unTranslation := service.MyService.App().GetMyList(index, size, position)
-	data := make(map[string]interface{}, 2)
-	data["casaos_apps"] = list
-	data["local_apps"] = unTranslation
-
-	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-}
-
-// @Summary my app hardware usage list
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /app/usage [get]
-func AppUsageList(c *gin.Context) {
-	list := service.MyService.App().GetHardwareUsage()
-	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: list})
-	//c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: nil})
-}
-
-// @Summary 应用详情
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Param  id path int true "id"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /app/appinfo/{id} [get]
-func AppInfo(c *gin.Context) {
-
-	id := c.Param("id")
-	language := c.GetHeader("Language")
-	info, err := service.MyService.Casa().GetServerAppInfo(id, "", language)
-	if err != nil {
-		c.JSON(common_err.SERVICE_ERROR, &model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: err.Error()})
-		return
-	}
-	if info.NetworkModel != "host" {
-		for i := 0; i < len(info.Ports); i++ {
-			if p, _ := strconv.Atoi(info.Ports[i].ContainerPort); port2.IsPortAvailable(p, info.Ports[i].Protocol) {
-				info.Ports[i].CommendPort = strconv.Itoa(p)
-			} else {
-				if info.Ports[i].Protocol == "tcp" {
-					if p, err := port2.GetAvailablePort("tcp"); err == nil {
-						info.Ports[i].CommendPort = strconv.Itoa(p)
-					}
-				} else if info.Ports[i].Protocol == "upd" {
-					if p, err := port2.GetAvailablePort("udp"); err == nil {
-						info.Ports[i].CommendPort = strconv.Itoa(p)
-					}
-				}
-			}
-
-			if info.Ports[i].Type == 0 {
-				info.PortMap = info.Ports[i].CommendPort
-			}
-		}
-	} else {
-		for i := 0; i < len(info.Ports); i++ {
-			if info.Ports[i].Type == 0 {
-				info.PortMap = info.Ports[i].ContainerPort
-				break
-			}
-		}
-	}
-
-	for i := 0; i < len(info.Devices); i++ {
-		if !file.CheckNotExist(info.Devices[i].ContainerPath) {
-			info.Devices[i].Path = info.Devices[i].ContainerPath
-		}
-	}
-	// if len(info.Tip) > 0 {
-	// 	info.Tip = env_helper.ReplaceStringDefaultENV(info.Tip)
-	// }
-
-	// portOrder := func(c1, c2 *model.Ports) bool {
-	// 	return c1.Type < c2.Type
-	// }
-
-	// envOrder := func(c1, c2 *model.Envs) bool {
-	// 	return c1.Type < c2.Type
-	// }
-
-	// volOrder := func(c1, c2 *model.Volume) bool {
-	// 	return c1.Type < c2.Type
-	// }
-
-	// devOrder := func(c1, c2 *model.Devices) bool {
-	// 	return c1.Type < c2.Type
-	// }
-
-	//sort
-	// if info.NetworkModel != "host" {
-	// 	sort.PortsSort(portOrder).Sort(info.Configures.TcpPorts)
-	// 	sort.PortsSort(portOrder).Sort(info.Configures.UdpPorts)
-	// }
-
-	// sort.EnvSort(envOrder).Sort(info.Envs)
-	// sort.VolSort(volOrder).Sort(info.Volumes.([]model.PathMap))
-	// sort.DevSort(devOrder).Sort(info.Devices)
-	info.Image += ":" + info.ImageVersion
-	info.MaxMemory = (service.MyService.System().GetMemInfo()["total"]).(uint64) >> 20
-
-	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: info})
-}
-
-// @Summary 获取远程分类列表
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /app/category [get]
-func CategoryList(c *gin.Context) {
-	list, err := service.MyService.Casa().GetServerCategoryList()
-	if err != nil {
-		c.JSON(common_err.SERVICE_ERROR, &model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: err.Error()})
-		return
-	}
-	var count uint = 0
-	for _, category := range list {
-		count += category.Count
-	}
-
-	rear := append([]model.CategoryList{}, list[0:]...)
-	list = append(list[:0], model.CategoryList{Count: count, Name: "All", Font: "apps"})
-	list = append(list, rear...)
-	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: list})
-}
-
-// @Summary 分享该应用配置
-// @Produce  application/json
-// @Accept application/json
-// @Tags app
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /app/share [post]
-func ShareAppFile(c *gin.Context) {
-	str, _ := ioutil.ReadAll(c.Request.Body)
-	content := service.MyService.Casa().ShareAppFile(str)
-	c.JSON(common_err.SUCCESS, json.RawMessage(content))
-}

route/v1/disk.go

@@ -1,608 +0,0 @@
-package v1
-
-import (
-	"fmt"
-	"net/http"
-	"path/filepath"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/model/notify"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/encryption"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-	"github.com/IceWhaleTech/CasaOS/service"
-	model2 "github.com/IceWhaleTech/CasaOS/service/model"
-	"github.com/gin-gonic/gin"
-	"github.com/shirou/gopsutil/v3/disk"
-)
-
-var diskMap = make(map[string]string)
-
-// @Summary disk list
-// @Produce  application/json
-// @Accept application/json
-// @Tags disk
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /disk/list [get]
-func GetDiskList(c *gin.Context) {
-	path := c.Query("path")
-	if len(path) > 0 {
-		m := service.MyService.Disk().GetDiskInfo(path)
-		c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: m})
-		return
-	}
-	t := c.DefaultQuery("type", "")
-	list := service.MyService.Disk().LSBLK(false)
-	if t == "usb" {
-		data := []model.DriveUSB{}
-		for _, v := range list {
-			if v.Tran == "usb" {
-				temp := model.DriveUSB{}
-				temp.Model = v.Model
-				temp.Name = v.Name
-				temp.Size = v.Size
-				for _, child := range v.Children {
-					if len(child.MountPoint) > 0 {
-						avail, _ := strconv.ParseUint(child.FSAvail, 10, 64)
-						temp.Avail += avail
-					}
-				}
-				data = append(data, temp)
-			}
-		}
-		c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-		return
-	}
-
-	dbList := service.MyService.Disk().GetSerialAll()
-	part := make(map[string]int64, len(dbList))
-	for _, v := range dbList {
-		part[v.MountPoint] = v.CreatedAt
-	}
-	findSystem := 0
-
-	disks := []model.Drive{}
-	storage := []model.Storage{}
-	avail := []model.Drive{}
-	for i := 0; i < len(list); i++ {
-		disk := model.Drive{}
-		if list[i].Rota {
-			disk.DiskType = "HDD"
-		} else {
-			disk.DiskType = "SSD"
-		}
-		disk.Serial = list[i].Serial
-		disk.Name = list[i].Name
-		disk.Size = list[i].Size
-		disk.Path = list[i].Path
-		disk.Model = list[i].Model
-		disk.ChildrenNumber = len(list[i].Children)
-		if len(list[i].Children) > 0 && findSystem == 0 {
-			for j := 0; j < len(list[i].Children); j++ {
-				if len(list[i].Children[j].Children) > 0 {
-					for _, v := range list[i].Children[j].Children {
-						if v.MountPoint == "/" {
-							stor := model.Storage{}
-							stor.MountPoint = v.MountPoint
-							stor.Size = v.FSSize
-							stor.Avail = v.FSAvail
-							stor.Path = v.Path
-							stor.Type = v.FsType
-							stor.DriveName = "System"
-							disk.Model = "System"
-							if strings.Contains(v.SubSystems, "mmc") {
-								disk.DiskType = "MMC"
-							} else if strings.Contains(v.SubSystems, "usb") {
-								disk.DiskType = "USB"
-							}
-							disk.Health = "true"
-
-							disks = append(disks, disk)
-							storage = append(storage, stor)
-							findSystem = 1
-							break
-						}
-					}
-				} else {
-					if list[i].Children[j].MountPoint == "/" {
-						stor := model.Storage{}
-						stor.MountPoint = list[i].Children[j].MountPoint
-						stor.Size = list[i].Children[j].FSSize
-						stor.Avail = list[i].Children[j].FSAvail
-						stor.Path = list[i].Children[j].Path
-						stor.Type = list[i].Children[j].FsType
-						stor.DriveName = "System"
-						disk.Model = "System"
-						if strings.Contains(list[i].Children[j].SubSystems, "mmc") {
-							disk.DiskType = "MMC"
-						} else if strings.Contains(list[i].Children[j].SubSystems, "usb") {
-							disk.DiskType = "USB"
-						}
-						disk.Health = "true"
-
-						disks = append(disks, disk)
-						storage = append(storage, stor)
-						findSystem = 1
-						break
-					}
-				}
-
-			}
-		}
-		if findSystem == 1 {
-			findSystem += 1
-			continue
-		}
-
-		if list[i].Tran == "sata" || list[i].Tran == "nvme" || list[i].Tran == "spi" || list[i].Tran == "sas" || strings.Contains(list[i].SubSystems, "virtio") || (list[i].Tran == "ata" && list[i].Type == "disk") {
-			temp := service.MyService.Disk().SmartCTL(list[i].Path)
-			if reflect.DeepEqual(temp, model.SmartctlA{}) {
-				temp.SmartStatus.Passed = true
-			}
-			isAvail := true
-			for _, v := range list[i].Children {
-				if v.MountPoint != "" {
-					stor := model.Storage{}
-					stor.MountPoint = v.MountPoint
-					stor.Size = v.FSSize
-					stor.Avail = v.FSAvail
-					stor.Path = v.Path
-					stor.Type = v.FsType
-					stor.DriveName = list[i].Name
-					storage = append(storage, stor)
-					isAvail = false
-				}
-			}
-
-			if isAvail {
-				//if len(list[i].Children) == 1 && list[i].Children[0].FsType == "ext4" {
-				disk.NeedFormat = false
-				avail = append(avail, disk)
-				// } else {
-				// 	disk.NeedFormat = true
-				// 	avail = append(avail, disk)
-				// }
-			}
-
-			disk.Temperature = temp.Temperature.Current
-			disk.Health = strconv.FormatBool(temp.SmartStatus.Passed)
-
-			disks = append(disks, disk)
-		}
-	}
-	data := make(map[string]interface{}, 3)
-	data["drive"] = disks
-	data["storage"] = storage
-	data["avail"] = avail
-
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-}
-
-// @Summary disk list
-// @Produce  application/json
-// @Accept application/json
-// @Tags disk
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /disk/list [get]
-func GetDisksUSBList(c *gin.Context) {
-	list := service.MyService.Disk().LSBLK(false)
-	data := []model.DriveUSB{}
-	for _, v := range list {
-		if v.Tran == "usb" {
-			temp := model.DriveUSB{}
-			temp.Model = v.Model
-			temp.Name = v.Label
-			if temp.Name == "" {
-				temp.Name = v.Name
-			}
-			temp.Size = v.Size
-			children := []model.USBChildren{}
-			for _, child := range v.Children {
-
-				if len(child.MountPoint) > 0 {
-					tempChildren := model.USBChildren{}
-					tempChildren.MountPoint = child.MountPoint
-					tempChildren.Size, _ = strconv.ParseUint(child.FSSize, 10, 64)
-					tempChildren.Avail, _ = strconv.ParseUint(child.FSAvail, 10, 64)
-					tempChildren.Name = child.Label
-					if len(tempChildren.Name) == 0 {
-						tempChildren.Name = filepath.Base(child.MountPoint)
-					}
-					avail, _ := strconv.ParseUint(child.FSAvail, 10, 64)
-					children = append(children, tempChildren)
-					temp.Avail += avail
-				}
-			}
-
-			temp.Children = children
-			data = append(data, temp)
-		}
-	}
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-
-}
-
-func DeleteDisksUmount(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	js := make(map[string]string)
-	c.ShouldBind(&js)
-
-	path := js["path"]
-	pwd := js["password"]
-
-	if len(path) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	user := service.MyService.User().GetUserAllInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if encryption.GetMD5ByStr(pwd) != user.Password {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.PWD_INVALID, Message: common_err.GetMsg(common_err.PWD_INVALID)})
-		return
-	}
-
-	if _, ok := diskMap[path]; ok {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.DISK_BUSYING, Message: common_err.GetMsg(common_err.DISK_BUSYING)})
-		return
-	}
-
-	diskInfo := service.MyService.Disk().GetDiskInfo(path)
-	for _, v := range diskInfo.Children {
-		service.MyService.Disk().UmountPointAndRemoveDir(v.Path)
-		//delete data
-		service.MyService.Disk().DeleteMountPoint(v.Path, v.MountPoint)
-
-		service.MyService.Shares().DeleteShareByPath(v.MountPoint)
-	}
-
-	service.MyService.Disk().RemoveLSBLKCache()
-
-	//send notify to client
-	msg := notify.StorageMessage{}
-	msg.Action = "REMOVED"
-	msg.Path = path
-	msg.Volume = ""
-	msg.Size = 0
-	msg.Type = ""
-	service.MyService.Notify().SendStorageBySocket(msg)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: path})
-}
-
-func DeleteDiskUSB(c *gin.Context) {
-	js := make(map[string]string)
-	c.ShouldBind(&js)
-	mountPoint := js["mount_point"]
-	if file.CheckNotExist(mountPoint) {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.DIR_NOT_EXISTS, Message: common_err.GetMsg(common_err.DIR_NOT_EXISTS)})
-		return
-	}
-	service.MyService.Disk().UmountUSB(mountPoint)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: mountPoint})
-}
-
-// @Summary get disk list
-// @Produce  application/json
-// @Accept application/json
-// @Tags disk
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /disk/lists [get]
-func GetPlugInDisks(c *gin.Context) {
-
-	list := service.MyService.Disk().LSBLK(true)
-	var result []*disk.UsageStat
-	for _, item := range list {
-		result = append(result, service.MyService.Disk().GetDiskInfoByPath(item.Path))
-	}
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: result})
-}
-
-// @Summary disk detail
-// @Produce  application/json
-// @Accept application/json
-// @Tags disk
-// @Security ApiKeyAuth
-// @Param  path query string true "for example /dev/sda"
-// @Success 200 {string} string "ok"
-// @Router /disk/info [get]
-func GetDiskInfo(c *gin.Context) {
-	path := c.Query("path")
-	if len(path) == 0 {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-	}
-	m := service.MyService.Disk().GetDiskInfo(path)
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: m})
-}
-
-// @Summary 获取支持的格式
-// @Produce  application/json
-// @Accept application/json
-// @Tags disk
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /disk/type [get]
-func FormatDiskType(c *gin.Context) {
-	var strArr = [4]string{"fat32", "ntfs", "ext4", "exfat"}
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: strArr})
-
-}
-
-// @Summary 删除分区
-// @Produce  application/json
-// @Accept multipart/form-data
-// @Tags disk
-// @Security ApiKeyAuth
-// @Param  path formData string true "磁盘路径 例如/dev/sda1"
-// @Success 200 {string} string "ok"
-// @Router /disk/delpart [delete]
-func RemovePartition(c *gin.Context) {
-	js := make(map[string]string)
-	c.ShouldBind(&js)
-	path := js["path"]
-
-	if len(path) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-	}
-	var p = path[:len(path)-1]
-	var n = path[len(path)-1:]
-	service.MyService.Disk().DelPartition(p, n)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-// @Summary  add storage
-// @Produce  application/json
-// @Accept multipart/form-data
-// @Tags disk
-// @Security ApiKeyAuth
-// @Param  path formData string true "disk path  e.g. /dev/sda"
-// @Param  serial formData string true "serial"
-// @Param  name formData string true "name"
-// @Param  format formData bool true "need format(true)"
-// @Success 200 {string} string "ok"
-// @Router /disk/storage [post]
-func PostDiskAddPartition(c *gin.Context) {
-
-	js := make(map[string]interface{})
-	c.ShouldBind(&js)
-	path := js["path"].(string)
-	name := js["name"].(string)
-	format := js["format"].(bool)
-
-	if len(path) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	if _, ok := diskMap[path]; ok {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.DISK_BUSYING, Message: common_err.GetMsg(common_err.DISK_BUSYING)})
-		return
-	}
-
-	//diskInfo := service.MyService.Disk().GetDiskInfo(path)
-
-	// if !file.CheckNotExist("/DATA/" + name) {
-	// 	// /mnt/name exist
-	// 	c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.NAME_NOT_AVAILABLE, Message: common_err.GetMsg(common_err.NAME_NOT_AVAILABLE)})
-	// 	return
-	// }
-	diskMap[path] = "busying"
-	currentDisk := service.MyService.Disk().GetDiskInfo(path)
-	if format {
-		// format := service.MyService.Disk().FormatDisk(path+"1", "ext4")
-		// if len(format) == 0 {
-		// 	delete(diskMap, path)
-		// 	c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.FORMAT_ERROR, Message: common_err.GetMsg(common_err.FORMAT_ERROR)})
-		// 	return
-		// }
-		service.MyService.Disk().AddPartition(path)
-	}
-
-	// formatBool := true
-	// for formatBool {
-	// 	currentDisk = service.MyService.Disk().GetDiskInfo(path)
-	// 	if len(currentDisk.Children) > 0 {
-	// 		formatBool = false
-	// 		break
-	// 	}
-	// 	time.Sleep(time.Second)
-	// }
-	currentDisk = service.MyService.Disk().GetDiskInfo(path)
-	// if len(currentDisk.Children) != 1 {
-	// 	c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.DISK_NEEDS_FORMAT, Message: common_err.GetMsg(common_err.DISK_NEEDS_FORMAT)})
-	// 	return
-	// }
-	fmt.Println(name)
-	if len(name) == 0 {
-		name = "Storage"
-	}
-	fmt.Println(name)
-	for i := 0; i < len(currentDisk.Children); i++ {
-		childrenName := currentDisk.Children[i].Label
-		if len(childrenName) == 0 {
-			//childrenName = name + "_" + currentDisk.Children[i].Name
-			childrenName = name + "_" + strconv.Itoa(i+1)
-		}
-		mountPath := "/DATA/" + childrenName
-		if !file.CheckNotExist(mountPath) {
-			ls := service.MyService.System().GetDirPath(mountPath)
-			if len(ls) > 0 {
-				// exist
-				c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.NAME_NOT_AVAILABLE, Message: common_err.GetMsg(common_err.NAME_NOT_AVAILABLE)})
-				return
-			}
-		}
-		m := model2.SerialDisk{}
-		m.MountPoint = mountPath
-		m.Path = currentDisk.Children[i].Path
-		m.UUID = currentDisk.Children[i].UUID
-		m.State = 0
-		m.CreatedAt = time.Now().Unix()
-		service.MyService.Disk().SaveMountPoint(m)
-		//mount dir
-		service.MyService.Disk().MountDisk(currentDisk.Children[i].Path, mountPath)
-	}
-
-	service.MyService.Disk().RemoveLSBLKCache()
-
-	delete(diskMap, path)
-
-	//send notify to client
-	msg := notify.StorageMessage{}
-	msg.Action = "ADDED"
-	msg.Path = currentDisk.Children[0].Path
-	msg.Volume = "/DATA/"
-	msg.Size = currentDisk.Children[0].Size
-	msg.Type = currentDisk.Children[0].Tran
-	service.MyService.Notify().SendStorageBySocket(msg)
-
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-// @Param  pwd formData string true "user password"
-// @Param  volume formData string true "mount point"
-// @Success 200 {string} string "ok"
-// @Router /disk/format [post]
-func PostDiskFormat(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	js := make(map[string]string)
-	c.ShouldBind(&js)
-	path := js["path"]
-	t := "ext4"
-	pwd := js["password"]
-	volume := js["volume"]
-	user := service.MyService.User().GetUserAllInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if encryption.GetMD5ByStr(pwd) != user.Password {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.PWD_INVALID, Message: common_err.GetMsg(common_err.PWD_INVALID)})
-		return
-	}
-
-	if len(path) == 0 || len(t) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	if _, ok := diskMap[path]; ok {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.DISK_BUSYING, Message: common_err.GetMsg(common_err.DISK_BUSYING)})
-		return
-	}
-	diskMap[path] = "busying"
-	service.MyService.Disk().UmountPointAndRemoveDir(path)
-	format := service.MyService.Disk().FormatDisk(path, t)
-	if len(format) == 0 {
-		delete(diskMap, path)
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.FORMAT_ERROR, Message: common_err.GetMsg(common_err.FORMAT_ERROR)})
-		return
-	}
-	service.MyService.Disk().MountDisk(path, volume)
-	service.MyService.Disk().RemoveLSBLKCache()
-	delete(diskMap, path)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-// @Summary remove mount point
-// @Produce  application/json
-// @Accept multipart/form-data
-// @Tags disk
-// @Security ApiKeyAuth
-// @Param  path formData string true "e.g. /dev/sda1"
-// @Param  mount_point formData string true "e.g. /mnt/volume1"
-// @Param  pwd formData string true "user password"
-// @Success 200 {string} string "ok"
-// @Router /disk/umount [post]
-func PostDiskUmount(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	js := make(map[string]string)
-	c.ShouldBind(&js)
-
-	path := js["path"]
-	mountPoint := js["volume"]
-	pwd := js["password"]
-
-	if len(path) == 0 || len(mountPoint) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	user := service.MyService.User().GetUserAllInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if encryption.GetMD5ByStr(pwd) != user.Password {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.PWD_INVALID, Message: common_err.GetMsg(common_err.PWD_INVALID)})
-		return
-	}
-
-	if _, ok := diskMap[path]; ok {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.DISK_BUSYING, Message: common_err.GetMsg(common_err.DISK_BUSYING)})
-		return
-	}
-
-	service.MyService.Disk().UmountPointAndRemoveDir(path)
-	//delete data
-	service.MyService.Disk().DeleteMountPoint(path, mountPoint)
-	service.MyService.Disk().RemoveLSBLKCache()
-
-	//send notify to client
-	msg := notify.StorageMessage{}
-	msg.Action = "REMOVED"
-	msg.Path = path
-	msg.Volume = mountPoint
-	msg.Size = 0
-	msg.Type = ""
-	service.MyService.Notify().SendStorageBySocket(msg)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-// @Summary confirm delete disk
-// @Produce  application/json
-// @Accept application/json
-// @Tags disk
-// @Security ApiKeyAuth
-// @Param  id path string true "id"
-// @Success 200 {string} string "ok"
-// @Router /disk/remove/{id} [delete]
-func DeleteDisk(c *gin.Context) {
-	id := c.Param("id")
-	service.MyService.Disk().DeleteMount(id)
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-// @Summary check mount point
-// @Produce  application/json
-// @Accept application/json
-// @Tags disk
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /disk/init [get]
-func GetDiskCheck(c *gin.Context) {
-
-	dbList := service.MyService.Disk().GetSerialAll()
-	list := service.MyService.Disk().LSBLK(true)
-
-	mapList := make(map[string]string)
-
-	for _, v := range list {
-		mapList[v.Serial] = "1"
-	}
-
-	for _, v := range dbList {
-		if _, ok := mapList[v.UUID]; !ok {
-			//disk undefind
-			c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: "disk undefind"})
-			return
-		}
-	}
-
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}

route/v1/file.go

@@ -15,13 +15,14 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/IceWhaleTech/CasaOS-Common/utils/logger"
 	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/config"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
 	"github.com/IceWhaleTech/CasaOS/service"
 	"github.com/gin-gonic/gin"
 	uuid "github.com/satori/go.uuid"
+	"go.uber.org/zap"
 )
 
 // @Summary 读取文件
@@ -48,7 +49,7 @@ func GetFilerContent(c *gin.Context) {
 		})
 		return
 	}
-	//文件读取任务是将文件内容读取到内存中。
+	// 文件读取任务是将文件内容读取到内存中。
 	info, err := ioutil.ReadFile(filePath)
 	if err != nil {
 		c.JSON(common_err.SERVICE_ERROR, model.Result{
@@ -84,7 +85,6 @@ func GetLocalFile(c *gin.Context) {
 		return
 	}
 	c.File(path)
-	return
 }
 
 // @Summary download
@@ -97,7 +97,6 @@ func GetLocalFile(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /file/download [get]
 func GetDownloadFile(c *gin.Context) {
-
 	t := c.Query("format")
 
 	files := c.Query("files")
@@ -136,11 +135,11 @@ func GetDownloadFile(c *gin.Context) {
 		}
 		if !info.IsDir() {
 
-			//打开文件
+			// 打开文件
 			fileTmp, _ := os.Open(filePath)
 			defer fileTmp.Close()
 
-			//获取文件的名称
+			// 获取文件的名称
 			fileName := path.Base(filePath)
 			c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url2.PathEscape(fileName))
 			c.File(filePath)
@@ -180,7 +179,6 @@ func GetDownloadFile(c *gin.Context) {
 			log.Printf("Failed to archive %s: %v", fname, err)
 		}
 	}
-
 }
 
 func GetDownloadSingleFile(c *gin.Context) {
@@ -203,7 +201,7 @@ func GetDownloadSingleFile(c *gin.Context) {
 	defer fileTmp.Close()
 
 	fileName := path.Base(filePath)
-	//c.Header("Content-Disposition", "inline")
+	// c.Header("Content-Disposition", "inline")
 	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url2.PathEscape(fileName))
 	c.File(filePath)
 }
@@ -224,45 +222,7 @@ func DirPath(c *gin.Context) {
 	for _, v := range shares {
 		sharesMap[v.Path] = fmt.Sprint(v.ID)
 	}
-	if path == "/DATA/AppData" {
-		list := service.MyService.Docker().DockerContainerList()
-		apps := make(map[string]string, len(list))
-		for _, v := range list {
-			apps[strings.ReplaceAll(v.Names[0], "/", "")] = strings.ReplaceAll(v.Names[0], "/", "")
-		}
-		for i := 0; i < len(info); i++ {
-			if v, ok := apps[info[i].Name]; ok {
-				info[i].Label = v
-				info[i].Type = "application"
-			}
-		}
-	} else if path == "/DATA" {
-		disk := make(map[string]string)
-		lsblk := service.MyService.Disk().LSBLK(true)
-		for _, v := range lsblk {
-			if len(v.Children) > 0 {
-				t := v.Tran
-				for _, c := range v.Children {
-					if len(c.Children) > 0 {
-						for _, gc := range c.Children {
-							if len(gc.MountPoint) > 0 {
-								disk[gc.MountPoint] = t
-							}
-						}
-					}
-					if len(c.MountPoint) > 0 {
-						disk[c.MountPoint] = t
-					}
-				}
 
-			}
-		}
-		for i := 0; i < len(info); i++ {
-			if v, ok := disk[info[i].Path]; ok {
-				info[i].Type = v
-			}
-		}
-	}
 	for i := 0; i < len(info); i++ {
 		if v, ok := sharesMap[info[i].Path]; ok {
 			ex := make(map[string]interface{})
@@ -274,7 +234,7 @@ func DirPath(c *gin.Context) {
 			info[i].Extensions = ex
 		}
 	}
-	//Hide the files or folders in operation
+	// Hide the files or folders in operation
 	fileQueue := make(map[string]string)
 	if len(service.OpStrArr) > 0 {
 		for _, v := range service.OpStrArr {
@@ -292,6 +252,9 @@ func DirPath(c *gin.Context) {
 
 	pathList := []model.Path{}
 	for i := 0; i < len(info); i++ {
+		if info[i].Name == ".temp" && info[i].IsDir {
+			continue
+		}
 		if _, ok := fileQueue[info[i].Path]; !ok {
 			pathList = append(pathList, info[i])
 		}
@@ -384,7 +347,6 @@ func PostCreateFile(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /file/upload [get]
 func GetFileUpload(c *gin.Context) {
-
 	relative := c.Query("relativePath")
 	fileName := c.Query("filename")
 	chunkNumber := c.Query("chunkNumber")
@@ -392,7 +354,7 @@ func GetFileUpload(c *gin.Context) {
 	path := c.Query("path")
 	dirPath := ""
 	hash := file.GetHashByContent([]byte(fileName))
-	tempDir := config.AppInfo.TempPath + "/" + hash + strconv.Itoa(totalChunks) + "/"
+	tempDir := filepath.Join(path, ".temp", hash+strconv.Itoa(totalChunks)) + "/"
 	if fileName != relative {
 		dirPath = strings.TrimSuffix(relative, fileName)
 		tempDir += dirPath
@@ -428,55 +390,91 @@ func PostFileUpload(c *gin.Context) {
 	hash := file.GetHashByContent([]byte(fileName))
 
 	if len(path) == 0 {
-		c.JSON(common_err.INVALID_PARAMS, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		logger.Error("path should not be empty")
+		c.JSON(http.StatusBadRequest, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
 		return
 	}
-	tempDir := config.AppInfo.TempPath + "/" + hash + strconv.Itoa(totalChunks) + "/"
+	tempDir := filepath.Join(path, ".temp", hash+strconv.Itoa(totalChunks)) + "/"
 
 	if fileName != relative {
 		dirPath = strings.TrimSuffix(relative, fileName)
 		tempDir += dirPath
-		file.MkDir(path + "/" + dirPath)
+		if err := file.MkDir(path + "/" + dirPath); err != nil {
+			logger.Error("error when trying to create `"+path+"/"+dirPath+"`", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
+			return
+		}
 	}
 
 	path += "/" + relative
 
 	if !file.CheckNotExist(tempDir + chunkNumber) {
-		file.RMDir(tempDir + chunkNumber)
+		if err := file.RMDir(tempDir + chunkNumber); err != nil {
+			logger.Error("error when trying to remove existing `"+tempDir+chunkNumber+"`", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
+			return
+		}
 	}
 
 	if totalChunks > 1 {
-		file.IsNotExistMkDir(tempDir)
-
-		out, _ := os.OpenFile(tempDir+chunkNumber, os.O_WRONLY|os.O_CREATE, 0644)
-		defer out.Close()
-		_, err := io.Copy(out, f)
-		if err != nil {
-			c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: err.Error()})
+		if err := file.IsNotExistMkDir(tempDir); err != nil {
+			logger.Error("error when trying to create `"+tempDir+"`", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
 			return
 		}
+
+		out, err := os.OpenFile(tempDir+chunkNumber, os.O_WRONLY|os.O_CREATE, 0o644)
+		if err != nil {
+			logger.Error("error when trying to open `"+tempDir+chunkNumber+"` for creation", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
+			return
+		}
+
+		defer out.Close()
+
+		if _, err := io.Copy(out, f); err != nil { // recommend to use https://github.com/iceber/iouring-go for faster copy
+			logger.Error("error when trying to write to `"+tempDir+chunkNumber+"`", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
+			return
+		}
+
+		fileNum, err := ioutil.ReadDir(tempDir)
+		if err != nil {
+			logger.Error("error when trying to read number of files under `"+tempDir+"`", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
+			return
+		}
+
+		if totalChunks == len(fileNum) {
+			if err := file.SpliceFiles(tempDir, path, totalChunks, 1); err != nil {
+				logger.Error("error when trying to splice files under `"+tempDir+"`", zap.Error(err))
+				c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
+				return
+			}
+
+			if err := file.RMDir(tempDir); err != nil {
+				logger.Error("error when trying to remove `"+tempDir+"`", zap.Error(err))
+				c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
+				return
+			}
+		}
 	} else {
-		out, _ := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0644)
-		defer out.Close()
-		_, err := io.Copy(out, f)
+		out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0o644)
 		if err != nil {
-			c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: err.Error()})
+			logger.Error("error when trying to open `"+path+"` for creation", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: err.Error()})
 			return
 		}
-		c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-		return
-	}
-	fileNum, err := ioutil.ReadDir(tempDir)
-	if err != nil {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: err.Error()})
-		return
-	}
-	if totalChunks == len(fileNum) {
-		file.SpliceFiles(tempDir, path, totalChunks, 1)
-		file.RMDir(tempDir)
-	}
 
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+		defer out.Close()
+
+		if _, err := io.Copy(out, f); err != nil { // recommend to use https://github.com/iceber/iouring-go for faster copy
+			logger.Error("error when trying to write to `"+path+"`", zap.Error(err))
+			c.JSON(http.StatusInternalServerError, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: err.Error()})
+			return
+		}
+	}
+	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
 }
 
 // @Summary copy or move file
@@ -488,7 +486,6 @@ func PostFileUpload(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /file/operate [post]
 func PostOperateFileOrDir(c *gin.Context) {
-
 	list := model.FileOperate{}
 	c.ShouldBind(&list)
 
@@ -538,7 +535,6 @@ func PostOperateFileOrDir(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /file/delete [delete]
 func DeleteFile(c *gin.Context) {
-
 	paths := []string{}
 	c.ShouldBind(&paths)
 	if len(paths) == 0 {
@@ -570,7 +566,6 @@ func DeleteFile(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /file/update [put]
 func PutFileContent(c *gin.Context) {
-
 	fi := model.FileUpdate{}
 	c.ShouldBind(&fi)
 
@@ -580,7 +575,7 @@ func PutFileContent(c *gin.Context) {
 		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.FILE_ALREADY_EXISTS, Message: common_err.GetMsg(common_err.FILE_ALREADY_EXISTS)})
 		return
 	}
-	//err := os.Remove(path)
+	// err := os.Remove(path)
 	err := os.RemoveAll(fi.FilePath)
 	if err != nil {
 		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.FILE_DELETE_ERROR, Message: common_err.GetMsg(common_err.FILE_DELETE_ERROR), Data: err})

route/v1/notify.go

@@ -0,0 +1,56 @@
+package v1
+
+import (
+	"net/http"
+
+	"github.com/IceWhaleTech/CasaOS-Common/model/notify"
+	"github.com/IceWhaleTech/CasaOS/model"
+	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
+	"github.com/IceWhaleTech/CasaOS/service"
+	"github.com/gin-gonic/gin"
+)
+
+func PostNotifyMessage(c *gin.Context) {
+	path := c.Param("path")
+	message := make(map[string]interface{})
+	if err := c.ShouldBind(&message); err != nil {
+		c.JSON(http.StatusBadRequest, model.Result{Success: common_err.INVALID_PARAMS, Message: err.Error()})
+		return
+	}
+
+	service.MyService.Notify().SendNotify(path, message)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+func PostSystemStatusNotify(c *gin.Context) {
+	message := make(map[string]interface{})
+	if err := c.ShouldBind(&message); err != nil {
+		c.JSON(http.StatusBadRequest, model.Result{Success: common_err.INVALID_PARAMS, Message: err.Error()})
+		return
+	}
+
+	service.MyService.Notify().SettingSystemTempData(message)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+func PostInstallAppNotify(c *gin.Context) {
+	app := notify.Application{}
+	if err := c.ShouldBind(&app); err != nil {
+		c.JSON(http.StatusBadRequest, model.Result{Success: common_err.INVALID_PARAMS, Message: err.Error()})
+		return
+	}
+
+	service.MyService.Notify().SendInstallAppBySocket(app)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+func PostUninstallAppNotify(c *gin.Context) {
+	app := notify.Application{}
+	if err := c.ShouldBind(&app); err != nil {
+		c.JSON(http.StatusBadRequest, model.Result{Success: common_err.INVALID_PARAMS, Message: err.Error()})
+		return
+	}
+
+	service.MyService.Notify().SendUninstallAppBySocket(app)
+	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}

route/v1/samba.go

@@ -14,12 +14,14 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/IceWhaleTech/CasaOS/model"
 	"github.com/IceWhaleTech/CasaOS/pkg/samba"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
+	"github.com/IceWhaleTech/CasaOS/pkg/utils/ip_helper"
 	"github.com/IceWhaleTech/CasaOS/service"
 	model2 "github.com/IceWhaleTech/CasaOS/service/model"
 	"github.com/gin-gonic/gin"
@@ -125,9 +127,27 @@ func PostSambaConnectionsCreate(c *gin.Context) {
 		connection.Port = "445"
 	}
 	if connection.Username == "" || connection.Host == "" {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.CHARACTER_LIMIT, Message: common_err.GetMsg(common_err.CHARACTER_LIMIT)})
+		return
+	}
+
+	if ok, _ := regexp.MatchString("^[a-zA-Z0-9]{4,30}$", connection.Password); !ok {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.CHARACTER_LIMIT, Message: common_err.GetMsg(common_err.CHARACTER_LIMIT)})
+		return
+	}
+	if ok, _ := regexp.MatchString("^[a-zA-Z0-9]{4,30}$", connection.Username); !ok {
 		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
 		return
 	}
+	if !ip_helper.IsIPv4(connection.Host) && !ip_helper.IsIPv6(connection.Host) {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+	if ok, _ := regexp.MatchString("^[0-9]{1,6}$", connection.Port); !ok {
+		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
+		return
+	}
+
 	connection.Host = strings.Split(connection.Host, "/")[0]
 	// check is exists
 	connections := service.MyService.Connections().GetConnectionByHost(connection.Host)

route/v1/ssh.go

@@ -0,0 +1,96 @@
+package v1
+
+import (
+	"bytes"
+	"net/http"
+	"os/exec"
+	"strconv"
+	"time"
+
+	"github.com/IceWhaleTech/CasaOS-Common/utils/common_err"
+	"github.com/IceWhaleTech/CasaOS-Common/utils/logger"
+	sshHelper "github.com/IceWhaleTech/CasaOS-Common/utils/ssh"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"go.uber.org/zap"
+	"golang.org/x/crypto/ssh"
+
+	modelCommon "github.com/IceWhaleTech/CasaOS-Common/model"
+)
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:   1024,
+	WriteBufferSize:  1024,
+	CheckOrigin:      func(r *http.Request) bool { return true },
+	HandshakeTimeout: time.Duration(time.Second * 5),
+}
+
+func PostSshLogin(c *gin.Context) {
+	j := make(map[string]string)
+	c.ShouldBind(&j)
+	userName := j["username"]
+	password := j["password"]
+	port := j["port"]
+	if userName == "" || password == "" || port == "" {
+		c.JSON(common_err.CLIENT_ERROR, modelCommon.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS), Data: "Username or password or port is empty"})
+		return
+	}
+	_, err := sshHelper.NewSshClient(userName, password, port)
+	if err != nil {
+		c.JSON(common_err.CLIENT_ERROR, modelCommon.Result{Success: common_err.CLIENT_ERROR, Message: common_err.GetMsg(common_err.CLIENT_ERROR), Data: "Please check if the username and port are correct, and make sure that ssh server is installed."})
+		logger.Error("connect ssh error", zap.Any("error", err))
+		return
+	}
+	c.JSON(common_err.SUCCESS, modelCommon.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
+}
+
+func WsSsh(c *gin.Context) {
+	_, e := exec.LookPath("ssh")
+	if e != nil {
+		c.JSON(common_err.SERVICE_ERROR, modelCommon.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR), Data: "ssh server not found"})
+		return
+	}
+
+	userName := c.Query("username")
+	password := c.Query("password")
+	port := c.Query("port")
+	wsConn, _ := upgrader.Upgrade(c.Writer, c.Request, nil)
+	logBuff := new(bytes.Buffer)
+
+	quitChan := make(chan bool, 3)
+	// user := ""
+	// password := ""
+	var login int = 1
+	cols, _ := strconv.Atoi(c.DefaultQuery("cols", "200"))
+	rows, _ := strconv.Atoi(c.DefaultQuery("rows", "32"))
+	var client *ssh.Client
+	for login != 0 {
+
+		var err error
+		if userName == "" || password == "" || port == "" {
+			wsConn.WriteMessage(websocket.TextMessage, []byte("username or password or port is empty"))
+		}
+		client, err = sshHelper.NewSshClient(userName, password, port)
+
+		if err != nil && client == nil {
+			wsConn.WriteMessage(websocket.TextMessage, []byte(err.Error()))
+			wsConn.WriteMessage(websocket.TextMessage, []byte("\r\n\x1b[0m"))
+		} else {
+			login = 0
+		}
+
+	}
+	if client != nil {
+		defer client.Close()
+	}
+
+	ssConn, _ := sshHelper.NewSshConn(cols, rows, client)
+	defer ssConn.Close()
+
+	go ssConn.ReceiveWsMsg(wsConn, logBuff, quitChan)
+	go ssConn.SendComboOutput(wsConn, quitChan)
+	go ssConn.SessionWait(quitChan)
+
+	<-quitChan
+}

route/v1/storage.go

@@ -1,109 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-07-11 16:02:29
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-08-17 19:14:50
- * @FilePath: /CasaOS/route/v1/storage.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package v1
-
-import (
-	"path/filepath"
-	"reflect"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
-	"github.com/IceWhaleTech/CasaOS/service"
-	"github.com/gin-gonic/gin"
-)
-
-func GetStorageList(c *gin.Context) {
-	system := c.Query("system")
-	storages := []model.Storages{}
-	disks := service.MyService.Disk().LSBLK(false)
-	diskNumber := 1
-	children := 1
-	findSystem := 0
-	for _, d := range disks {
-		if d.Tran != "usb" {
-			tempSystemDisk := false
-			children = 1
-			tempDisk := model.Storages{
-				DiskName: d.Model,
-				Path:     d.Path,
-				Size:     d.Size,
-			}
-
-			storageArr := []model.Storage{}
-			temp := service.MyService.Disk().SmartCTL(d.Path)
-			if reflect.DeepEqual(temp, model.SmartctlA{}) {
-				temp.SmartStatus.Passed = true
-			}
-			for _, v := range d.Children {
-				if v.MountPoint != "" {
-					if findSystem == 0 {
-						if v.MountPoint == "/" {
-							tempDisk.DiskName = "System"
-							findSystem = 1
-							tempSystemDisk = true
-						}
-						if len(v.Children) > 0 {
-							for _, c := range v.Children {
-								if c.MountPoint == "/" {
-									tempDisk.DiskName = "System"
-									findSystem = 1
-									tempSystemDisk = true
-									break
-								}
-							}
-						}
-					}
-
-					stor := model.Storage{}
-					stor.MountPoint = v.MountPoint
-					stor.Size = v.FSSize
-					stor.Avail = v.FSAvail
-					stor.Path = v.Path
-					stor.Type = v.FsType
-					stor.DriveName = v.Name
-					if len(v.Label) == 0 {
-						if stor.MountPoint == "/" {
-							stor.Label = "System"
-						} else {
-							stor.Label = filepath.Base(stor.MountPoint)
-						}
-
-						children += 1
-					} else {
-						stor.Label = v.Label
-					}
-					storageArr = append(storageArr, stor)
-				}
-			}
-
-			if len(storageArr) > 0 {
-				if tempSystemDisk && len(system) > 0 {
-					tempStorageArr := []model.Storage{}
-					for i := 0; i < len(storageArr); i++ {
-						if storageArr[i].MountPoint != "/boot/efi" && storageArr[i].Type != "swap" {
-							tempStorageArr = append(tempStorageArr, storageArr[i])
-						}
-					}
-					tempDisk.Children = tempStorageArr
-					storages = append(storages, tempDisk)
-					diskNumber += 1
-				} else if !tempSystemDisk {
-					tempDisk.Children = storageArr
-					storages = append(storages, tempDisk)
-					diskNumber += 1
-				}
-
-			}
-		}
-	}
-
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: storages})
-}

route/v1/system.go

@@ -1,26 +1,27 @@
 package v1
 
 import (
+	"bytes"
 	"fmt"
+	"io"
+	"io/ioutil"
 	"net/http"
 	"os"
-	"reflect"
 	"strconv"
 	"strings"
 	"time"
 	"unsafe"
 
+	http2 "github.com/IceWhaleTech/CasaOS-Common/utils/http"
+	"github.com/IceWhaleTech/CasaOS-Common/utils/port"
 	"github.com/IceWhaleTech/CasaOS/model"
 	"github.com/IceWhaleTech/CasaOS/pkg/config"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-	port2 "github.com/IceWhaleTech/CasaOS/pkg/utils/port"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/version"
 	"github.com/IceWhaleTech/CasaOS/service"
 	model2 "github.com/IceWhaleTech/CasaOS/service/model"
 	"github.com/IceWhaleTech/CasaOS/types"
 	"github.com/gin-gonic/gin"
-	"go.uber.org/zap"
 )
 
 // @Summary check version
@@ -76,7 +77,7 @@ func GetCasaOSErrorLogs(c *gin.Context) {
 	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: service.MyService.System().GetCasaOSLogs(line)})
 }
 
-//系统配置
+// 系统配置
 func GetSystemConfigDebug(c *gin.Context) {
 	array := service.MyService.System().GetSystemConfigDebug()
 	disk := service.MyService.System().GetDiskInfo()
@@ -126,7 +127,7 @@ func PutCasaOSPort(c *gin.Context) {
 	json := make(map[string]string)
 	c.ShouldBind(&json)
 	portStr := json["port"]
-	port, err := strconv.Atoi(portStr)
+	portNumber, err := strconv.Atoi(portStr)
 	if err != nil {
 		c.JSON(common_err.SERVICE_ERROR,
 			model.Result{
@@ -136,7 +137,7 @@ func PutCasaOSPort(c *gin.Context) {
 		return
 	}
 
-	isAvailable := port2.IsPortAvailable(port, "tcp")
+	isAvailable := port.IsPortAvailable(portNumber, "tcp")
 	if !isAvailable {
 		c.JSON(common_err.SERVICE_ERROR,
 			model.Result{
@@ -145,7 +146,7 @@ func PutCasaOSPort(c *gin.Context) {
 			})
 		return
 	}
-	service.MyService.System().UpSystemPort(strconv.Itoa(port))
+	service.MyService.System().UpSystemPort(strconv.Itoa(portNumber))
 	c.JSON(common_err.SUCCESS,
 		model.Result{
 			Success: common_err.SUCCESS,
@@ -164,135 +165,6 @@ func PostKillCasaOS(c *gin.Context) {
 	os.Exit(0)
 }
 
-// @Summary Turn off usb auto-mount
-// @Produce  application/json
-// @Accept application/json
-// @Tags sys
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /sys/usb/off [put]
-func PutSystemUSBAutoMount(c *gin.Context) {
-	js := make(map[string]string)
-	c.ShouldBind(&js)
-	status := js["state"]
-	if status == "on" {
-		service.MyService.System().UpdateUSBAutoMount("True")
-		service.MyService.System().ExecUSBAutoMountShell("True")
-	} else {
-		service.MyService.System().UpdateUSBAutoMount("False")
-		service.MyService.System().ExecUSBAutoMountShell("False")
-	}
-	go func() {
-		usbList := service.MyService.Disk().LSBLK(false)
-		usb := []model.DriveUSB{}
-		for _, v := range usbList {
-			if v.Tran == "usb" {
-				isMount := false
-				temp := model.DriveUSB{}
-				temp.Model = v.Model
-				temp.Name = v.Name
-				temp.Size = v.Size
-				for _, child := range v.Children {
-					if len(child.MountPoint) > 0 {
-						isMount = true
-						avail, _ := strconv.ParseUint(child.FSAvail, 10, 64)
-						temp.Avail += avail
-
-					}
-				}
-				if isMount {
-					usb = append(usb, temp)
-				}
-			}
-		}
-		service.MyService.Notify().SendUSBInfoBySocket(usb)
-	}()
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-		})
-}
-
-// @Summary Turn off usb auto-mount
-// @Produce  application/json
-// @Accept application/json
-// @Tags sys
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /sys/usb [get]
-func GetSystemUSBAutoMount(c *gin.Context) {
-	state := "True"
-	if config.ServerInfo.USBAutoMount == "False" {
-		state = "False"
-	}
-	go func() {
-		usbList := service.MyService.Disk().LSBLK(false)
-		usb := []model.DriveUSB{}
-		for _, v := range usbList {
-			if v.Tran == "usb" {
-				isMount := false
-				temp := model.DriveUSB{}
-				temp.Model = v.Model
-				temp.Name = v.Name
-				temp.Size = v.Size
-				for _, child := range v.Children {
-					if len(child.MountPoint) > 0 {
-						isMount = true
-						avail, _ := strconv.ParseUint(child.FSAvail, 10, 64)
-						temp.Avail += avail
-
-					}
-				}
-				if isMount {
-					usb = append(usb, temp)
-				}
-			}
-		}
-		service.MyService.Notify().SendUSBInfoBySocket(usb)
-	}()
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    state,
-		})
-}
-
-func GetSystemAppsStatus(c *gin.Context) {
-	systemAppList := service.MyService.App().GetSystemAppList()
-	appList := []model2.MyAppList{}
-	for _, v := range systemAppList {
-		name := strings.ReplaceAll(v.Names[0], "/", "")
-		if len(v.Labels["name"]) > 0 {
-			name = v.Labels["name"]
-		}
-		appList = append(appList, model2.MyAppList{
-			Name:     name,
-			Icon:     v.Labels["icon"],
-			State:    v.State,
-			CustomId: v.Labels["custom_id"],
-			Id:       v.ID,
-			Port:     v.Labels["web"],
-			Index:    v.Labels["index"],
-			//Order:      m.Labels["order"],
-			Image:  v.Image,
-			Latest: false,
-			//Type:   m.Labels["origin"],
-			//Slogan: m.Slogan,
-			//Rely:     m.Rely,
-			Host:     v.Labels["host"],
-			Protocol: v.Labels["protocol"],
-		})
-	}
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    appList,
-		})
-}
-
 // @Summary get system hardware info
 // @Produce  application/json
 // @Accept application/json
@@ -301,7 +173,6 @@ func GetSystemAppsStatus(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /sys/hardware/info [get]
 func GetSystemHardwareInfo(c *gin.Context) {
-
 	data := make(map[string]string, 1)
 	data["drive_model"] = service.MyService.System().GetDeviceTree()
 	c.JSON(common_err.SUCCESS,
@@ -320,108 +191,28 @@ func GetSystemHardwareInfo(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /sys/utilization [get]
 func GetSystemUtilization(c *gin.Context) {
-	var data = make(map[string]interface{}, 6)
-
-	list := service.MyService.Disk().LSBLK(true)
-
-	summary := model.Summary{}
-	healthy := true
-	findSystem := 0
-
-	for i := 0; i < len(list); i++ {
-		if len(list[i].Children) > 0 && findSystem == 0 {
-
-			for j := 0; j < len(list[i].Children); j++ {
-
-				if len(list[i].Children[j].Children) > 0 {
-					for _, v := range list[i].Children[j].Children {
-						if v.MountPoint == "/" {
-							s, _ := strconv.ParseUint(v.FSSize, 10, 64)
-							a, _ := strconv.ParseUint(v.FSAvail, 10, 64)
-							u, _ := strconv.ParseUint(v.FSUsed, 10, 64)
-							loger.Info("disk info", zap.Any("/ total:", s))
-							loger.Info("disk path", zap.Any("path", v.Path))
-							summary.Size += s
-							summary.Avail += a
-							summary.Used += u
-							findSystem = 1
-							break
-						}
-					}
-				} else {
-					if list[i].Children[j].MountPoint == "/" {
-						s, _ := strconv.ParseUint(list[i].Children[j].FSSize, 10, 64)
-						a, _ := strconv.ParseUint(list[i].Children[j].FSAvail, 10, 64)
-						u, _ := strconv.ParseUint(list[i].Children[j].FSUsed, 10, 64)
-						loger.Info("disk info", zap.Any("/ total:", s))
-						loger.Info("disk path", zap.Any("path", list[i].Path))
-						summary.Size += s
-						summary.Avail += a
-						summary.Used += u
-						findSystem = 1
-						break
-					}
-				}
-			}
-
-		}
-		if findSystem == 1 {
-			findSystem += 1
-			continue
-		}
-		if list[i].Tran == "sata" || list[i].Tran == "nvme" || list[i].Tran == "spi" || list[i].Tran == "sas" || strings.Contains(list[i].SubSystems, "virtio") || (list[i].Tran == "ata" && list[i].Type == "disk") {
-			temp := service.MyService.Disk().SmartCTL(list[i].Path)
-			if reflect.DeepEqual(temp, model.SmartctlA{}) {
-				healthy = true
-			} else {
-				healthy = temp.SmartStatus.Passed
-			}
-			if len(list[i].Children) > 0 {
-				for _, v := range list[i].Children {
-					s, _ := strconv.ParseUint(v.FSSize, 10, 64)
-					a, _ := strconv.ParseUint(v.FSAvail, 10, 64)
-					u, _ := strconv.ParseUint(v.FSUsed, 10, 64)
-					loger.Info("disk info", zap.Any("/ total:", s))
-					loger.Info("disk path", zap.Any("path", list[i].Path))
-					summary.Size += s
-					summary.Avail += a
-					summary.Used += u
-				}
-			}
-
-		}
-	}
-
-	summary.Health = healthy
-	data["disk"] = summary
-	usbList := service.MyService.Disk().LSBLK(false)
-	usb := []model.DriveUSB{}
-	for _, v := range usbList {
-		if v.Tran == "usb" {
-			temp := model.DriveUSB{}
-			temp.Model = v.Model
-			temp.Name = v.Name
-			temp.Size = v.Size
-
-			for _, child := range v.Children {
-				if len(child.MountPoint) > 0 {
-					avail, _ := strconv.ParseUint(child.FSAvail, 10, 64)
-					temp.Avail += avail
-				}
-			}
-			usb = append(usb, temp)
-		}
-	}
-	data["usb"] = usb
+	data := make(map[string]interface{})
 	cpu := service.MyService.System().GetCpuPercent()
 	num := service.MyService.System().GetCpuCoreNum()
+	cpuModel := "arm"
+	if cpu := service.MyService.System().GetCpuInfo(); len(cpu) > 0 {
+		if strings.Count(strings.ToLower(strings.TrimSpace(cpu[0].ModelName)), "intel") > 0 {
+			cpuModel = "intel"
+		} else if strings.Count(strings.ToLower(strings.TrimSpace(cpu[0].ModelName)), "amd") > 0 {
+			cpuModel = "amd"
+		}
+	}
 	cpuData := make(map[string]interface{})
 	cpuData["percent"] = cpu
 	cpuData["num"] = num
+	cpuData["temperature"] = service.MyService.System().GetCPUTemperature()
+	cpuData["power"] = service.MyService.System().GetCPUPower()
+	cpuData["model"] = cpuModel
+
 	data["cpu"] = cpuData
 	data["mem"] = service.MyService.System().GetMemInfo()
 
-	//拼装网络信息
+	// 拼装网络信息
 	netList := service.MyService.System().GetNetInfo()
 	newNet := []model.IOCountersStat{}
 	nets := service.MyService.System().GetNet(true)
@@ -438,7 +229,9 @@ func GetSystemUtilization(c *gin.Context) {
 	}
 
 	data["net"] = newNet
-
+	for k, v := range service.MyService.Notify().GetSystemTempMap() {
+		data[k] = v
+	}
 	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
 }
 
@@ -450,7 +243,6 @@ func GetSystemUtilization(c *gin.Context) {
 // @Success 200 {string} string "ok"
 // @Router /sys/socket/port [get]
 func GetSystemSocketPort(c *gin.Context) {
-
 	c.JSON(common_err.SUCCESS,
 		model.Result{
 			Success: common_err.SUCCESS,
@@ -473,7 +265,6 @@ func GetSystemCupInfo(c *gin.Context) {
 	data["percent"] = cpu
 	data["num"] = num
 	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-
 }
 
 // @Summary get mem info
@@ -486,7 +277,6 @@ func GetSystemCupInfo(c *gin.Context) {
 func GetSystemMemInfo(c *gin.Context) {
 	mem := service.MyService.System().GetMemInfo()
 	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: mem})
-
 }
 
 // @Summary get disk info
@@ -525,3 +315,67 @@ func GetSystemNetInfo(c *gin.Context) {
 
 	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: newNet})
 }
+
+func GetSystemProxy(c *gin.Context) {
+	url := c.Query("url")
+	resp, err := http2.Get(url, 30*time.Second)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	for k, v := range c.Request.Header {
+		c.Header(k, v[0])
+	}
+	rda, _ := ioutil.ReadAll(resp.Body)
+	//	json.NewEncoder(c.Writer).Encode(json.RawMessage(string(rda)))
+	// 响应状态码
+	c.Writer.WriteHeader(resp.StatusCode)
+	// 复制转发的响应Body到响应Body
+	io.Copy(c.Writer, ioutil.NopCloser(bytes.NewBuffer(rda)))
+}
+
+func PutSystemState(c *gin.Context) {
+	state := c.Param("state")
+	if state == "off" {
+		service.MyService.System().SystemShutdown()
+	} else if state == "restart" {
+		service.MyService.System().SystemReboot()
+
+	}
+	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: "The operation will be completed shortly."})
+}
+
+// @Summary 获取一个可用端口
+// @Produce  application/json
+// @Accept application/json
+// @Tags app
+// @Param  type query string true "端口类型 udp/tcp"
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /app/getport [get]
+func GetPort(c *gin.Context) {
+	t := c.DefaultQuery("type", "tcp")
+	var p int
+	ok := true
+	for ok {
+		p, _ = port.GetAvailablePort(t)
+		ok = !port.IsPortAvailable(p, t)
+	}
+	// @tiger 这里最好封装成 {'port': ...} 的形式，来体现出参的上下文
+	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: p})
+}
+
+// @Summary 检查端口是否可用
+// @Produce  application/json
+// @Accept application/json
+// @Tags app
+// @Param  port path int true "端口号"
+// @Param  type query string true "端口类型 udp/tcp"
+// @Security ApiKeyAuth
+// @Success 200 {string} string "ok"
+// @Router /app/check/{port} [get]
+func PortCheck(c *gin.Context) {
+	p, _ := strconv.Atoi(c.Param("port"))
+	t := c.DefaultQuery("type", "tcp")
+	c.JSON(common_err.SUCCESS, &model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: port.IsPortAvailable(p, t)})
+}

route/v1/user.go

@@ -1,683 +0,0 @@
-package v1
-
-import (
-	json2 "encoding/json"
-	"io/ioutil"
-	"net/http"
-	url2 "net/url"
-	"os"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/model/system_model"
-	"github.com/IceWhaleTech/CasaOS/pkg/config"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/common_err"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/encryption"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/jwt"
-	model2 "github.com/IceWhaleTech/CasaOS/service/model"
-	uuid "github.com/satori/go.uuid"
-	"github.com/tidwall/gjson"
-
-	"github.com/IceWhaleTech/CasaOS/service"
-	"github.com/gin-gonic/gin"
-)
-
-// @Summary register user
-// @Router /user/register/ [post]
-func PostUserRegister(c *gin.Context) {
-	json := make(map[string]string)
-	c.ShouldBind(&json)
-
-	username := json["username"]
-	pwd := json["password"]
-	key := json["key"]
-	if _, ok := service.UserRegisterHash[key]; !ok {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{Success: common_err.KEY_NOT_EXIST, Message: common_err.GetMsg(common_err.KEY_NOT_EXIST)})
-		return
-	}
-
-	if len(username) == 0 || len(pwd) == 0 {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	if len(pwd) < 6 {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{Success: common_err.PWD_IS_TOO_SIMPLE, Message: common_err.GetMsg(common_err.PWD_IS_TOO_SIMPLE)})
-		return
-	}
-	oldUser := service.MyService.User().GetUserInfoByUserName(username)
-	if oldUser.Id > 0 {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{Success: common_err.USER_EXIST, Message: common_err.GetMsg(common_err.USER_EXIST)})
-		return
-	}
-
-	user := model2.UserDBModel{}
-	user.Username = username
-	user.Password = encryption.GetMD5ByStr(pwd)
-	user.Role = "admin"
-
-	user = service.MyService.User().CreateUser(user)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR)})
-		return
-	}
-	file.MkDir(config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id))
-	delete(service.UserRegisterHash, key)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-
-}
-
-// @Summary login
-// @Produce  application/json
-// @Accept application/json
-// @Tags user
-// @Param user_name query string true "User name"
-// @Param pwd  query string true "password"
-// @Success 200 {string} string "ok"
-// @Router /user/login [post]
-func PostUserLogin(c *gin.Context) {
-	json := make(map[string]string)
-	c.ShouldBind(&json)
-
-	username := json["username"]
-
-	password := json["password"]
-	//check params is empty
-	if len(username) == 0 || len(password) == 0 {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{
-				Success: common_err.CLIENT_ERROR,
-				Message: common_err.GetMsg(common_err.INVALID_PARAMS),
-			})
-		return
-	}
-	user := service.MyService.User().GetUserAllInfoByName(username)
-	if user.Id == 0 {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if user.Password != encryption.GetMD5ByStr(password) {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{Success: common_err.PWD_INVALID, Message: common_err.GetMsg(common_err.PWD_INVALID)})
-		return
-	}
-	token := system_model.VerifyInformation{}
-	token.AccessToken = jwt.GetAccessToken(user.Username, user.Password, user.Id)
-	token.RefreshToken = jwt.GetRefreshToken(user.Username, user.Password, user.Id)
-	token.ExpiresAt = time.Now().Add(3 * time.Hour * time.Duration(1)).Unix()
-	data := make(map[string]interface{}, 2)
-	user.Password = ""
-	data["token"] = token
-
-	// TODO:1 Database fields cannot be external
-	data["user"] = user
-
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    data,
-		})
-}
-
-// @Summary edit user head
-// @Produce  application/json
-// @Accept multipart/form-data
-// @Tags user
-// @Param file formData file true "用户头像"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /user/avatar [put]
-func PutUserAvatar(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	f, err := c.FormFile("file")
-	if err != nil {
-		c.JSON(common_err.CLIENT_ERROR,
-			model.Result{Success: common_err.CLIENT_ERROR, Message: common_err.GetMsg(common_err.CLIENT_ERROR), Data: err.Error()})
-		return
-	}
-	if len(user.Avatar) > 0 {
-		os.RemoveAll(config.AppInfo.UserDataPath + "/" + id + "/" + user.Avatar)
-	}
-	ext := filepath.Ext(f.Filename)
-	avatarPath := config.AppInfo.UserDataPath + "/" + id + "/avatar" + ext
-	c.SaveUploadedFile(f, avatarPath)
-	user.Avatar = avatarPath
-	service.MyService.User().UpdateUser(user)
-	c.JSON(http.StatusOK,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    user,
-		})
-}
-
-// @Summary edit user name
-// @Produce  application/json
-// @Accept application/json
-// @Tags user
-// @Param old_name  query string true "Old user name"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /user/name/:id [put]
-func PutUserInfo(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	json := model2.UserDBModel{}
-	c.ShouldBind(&json)
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if len(json.Username) > 0 {
-		u := service.MyService.User().GetUserInfoByUserName(json.Username)
-		if u.Id > 0 {
-			c.JSON(common_err.CLIENT_ERROR,
-				model.Result{Success: common_err.USER_EXIST, Message: common_err.GetMsg(common_err.USER_EXIST)})
-			return
-		}
-	}
-
-	if len(json.Email) == 0 {
-		json.Email = user.Email
-	}
-	if len(json.Avatar) == 0 {
-		json.Avatar = user.Avatar
-	}
-	if len(json.Role) == 0 {
-		json.Role = user.Role
-	}
-	if len(json.Description) == 0 {
-		json.Description = user.Description
-	}
-	if len(json.Nickname) == 0 {
-		json.Nickname = user.Nickname
-	}
-	service.MyService.User().UpdateUser(json)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: json})
-}
-
-// @Summary edit user password
-// @Produce  application/json
-// @Accept application/json
-// @Tags user
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /user/password/:id [put]
-func PutUserPassword(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	json := make(map[string]string)
-	c.ShouldBind(&json)
-	oldPwd := json["old_password"]
-	pwd := json["password"]
-	if len(oldPwd) == 0 || len(pwd) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	user := service.MyService.User().GetUserAllInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if user.Password != encryption.GetMD5ByStr(oldPwd) {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.PWD_INVALID_OLD, Message: common_err.GetMsg(common_err.PWD_INVALID_OLD)})
-		return
-	}
-	user.Password = encryption.GetMD5ByStr(pwd)
-	service.MyService.User().UpdateUserPassword(user)
-	user.Password = ""
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: user})
-}
-
-// @Summary edit user nick
-// @Produce  application/json
-// @Accept application/json
-// @Tags user
-// @Param nick_name query string false "nick name"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /user/nick [put]
-func PutUserNick(c *gin.Context) {
-
-	id := c.GetHeader("user_id")
-	json := make(map[string]string)
-	c.ShouldBind(&json)
-	Nickname := json["nick_name"]
-	if len(Nickname) == 0 {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(http.StatusOK,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	user.Nickname = Nickname
-	service.MyService.User().UpdateUser(user)
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: user})
-}
-
-// @Summary edit user description
-// @Produce  application/json
-// @Accept multipart/form-data
-// @Tags user
-// @Param description formData string false "Description"
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /user/desc [put]
-func PutUserDesc(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	json := make(map[string]string)
-	c.ShouldBind(&json)
-	desc := json["description"]
-	if len(desc) == 0 {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(http.StatusOK,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	user.Description = desc
-
-	service.MyService.User().UpdateUser(user)
-
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: user})
-}
-
-// @Summary get user info
-// @Produce  application/json
-// @Accept  application/json
-// @Tags user
-// @Success 200 {string} string "ok"
-// @Router /user/info/:id [get]
-func GetUserInfo(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	user := service.MyService.User().GetUserInfoById(id)
-
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    user,
-		})
-}
-
-/**
- * @description:
- * @param {*gin.Context} c
- * @param {string} Username
- * @return {*}
- * @method:
- * @router:
- */
-func GetUserInfoByUsername(c *gin.Context) {
-	username := c.Param("username")
-	if len(username) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	user := service.MyService.User().GetUserInfoByUserName(username)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    user,
-		})
-}
-
-/**
- * @description: get all Usernames
- * @method:GET
- * @router:/user/all/name
- */
-func GetUserAllUsername(c *gin.Context) {
-	users := service.MyService.User().GetAllUserName()
-	names := []string{}
-	for _, v := range users {
-		names = append(names, v.Username)
-	}
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    names,
-		})
-}
-
-/**
- * @description:get custom file by user
- * @param {path} name string "file name"
- * @method: GET
- * @router: /user/custom/:key
- */
-func GetUserCustomConf(c *gin.Context) {
-	name := c.Param("key")
-	if len(name) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	id := c.GetHeader("user_id")
-
-	user := service.MyService.User().GetUserInfoById(id)
-	//	user := service.MyService.User().GetUserInfoByUsername(Username)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	filePath := config.AppInfo.UserDataPath + "/" + id + "/" + name + ".json"
-
-	data := file.ReadFullFile(filePath)
-	if !gjson.ValidBytes(data) {
-		c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: string(data)})
-		return
-	}
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: json2.RawMessage(string(data))})
-}
-
-/**
- * @description:create or update custom conf by user
- * @param {path} name string "file name"
- * @method:POST
- * @router:/user/custom/:key
- */
-func PostUserCustomConf(c *gin.Context) {
-
-	name := c.Param("key")
-	if len(name) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	id := c.GetHeader("user_id")
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	data, _ := ioutil.ReadAll(c.Request.Body)
-	filePath := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id)
-
-	file.WriteToPath(data, filePath, name+".json")
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: json2.RawMessage(string(data))})
-}
-
-/**
- * @description: delete user custom config
- * @param {path} key string
- * @method:delete
- * @router:/user/custom/:key
- */
-func DeleteUserCustomConf(c *gin.Context) {
-	name := c.Param("key")
-	if len(name) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	id := c.GetHeader("user_id")
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR,
-			model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	filePath := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id) + "/" + name + ".json"
-	err := os.Remove(filePath)
-	if err != nil {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.SERVICE_ERROR, Message: common_err.GetMsg(common_err.SERVICE_ERROR)})
-		return
-	}
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-/**
- * @description:
- * @param {path} id string "user id"
- * @method:DELETE
- * @router:/user/delete/:id
- */
-func DeleteUser(c *gin.Context) {
-	id := c.Param("id")
-	service.MyService.User().DeleteUserById(id)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: id})
-}
-
-/**
- * @description:update user image
- * @method:POST
- * @router:/user/current/image/:key
- */
-func PutUserImage(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	json := make(map[string]string)
-	c.ShouldBind(&json)
-
-	path := json["path"]
-	key := c.Param("key")
-	if len(path) == 0 || len(key) == 0 {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	if !file.Exists(path) {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.FILE_DOES_NOT_EXIST, Message: common_err.GetMsg(common_err.FILE_DOES_NOT_EXIST)})
-		return
-	}
-
-	_, err := file.GetImageExt(path)
-
-	if err != nil {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.NOT_IMAGE, Message: common_err.GetMsg(common_err.NOT_IMAGE)})
-		return
-	}
-
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	fstat, _ := os.Stat(path)
-	if fstat.Size() > 10<<20 {
-		c.JSON(http.StatusOK, model.Result{Success: common_err.IMAGE_TOO_LARGE, Message: common_err.GetMsg(common_err.IMAGE_TOO_LARGE)})
-		return
-	}
-	ext := file.GetExt(path)
-	filePath := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id) + "/" + key + ext
-	file.CopySingleFile(path, filePath, "overwrite")
-
-	data := make(map[string]string, 3)
-	data["path"] = filePath
-	data["file_name"] = key + ext
-	data["online_path"] = "/v1/users/image?path=" + filePath
-	c.JSON(http.StatusOK, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-}
-
-/**
-* @description:
-* @param {*gin.Context} c
-* @param {file} file
-* @param {string} key
-* @param {string} type:avatar,background
-* @return {*}
-* @method:
-* @router:
- */
-func PostUserUploadImage(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	f, err := c.FormFile("file")
-	key := c.Param("key")
-	t := c.PostForm("type")
-	if len(key) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	if err != nil {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.CLIENT_ERROR, Message: common_err.GetMsg(common_err.CLIENT_ERROR), Data: err.Error()})
-		return
-	}
-
-	_, err = file.GetImageExtByName(f.Filename)
-	if err != nil {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.NOT_IMAGE, Message: common_err.GetMsg(common_err.NOT_IMAGE)})
-		return
-	}
-	ext := filepath.Ext(f.Filename)
-	user := service.MyService.User().GetUserInfoById(id)
-
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if t == "avatar" {
-		key = "avatar"
-	}
-	path := config.AppInfo.UserDataPath + "/" + strconv.Itoa(user.Id) + "/" + key + ext
-
-	c.SaveUploadedFile(f, path)
-	data := make(map[string]string, 3)
-	data["path"] = path
-	data["file_name"] = key + ext
-	data["online_path"] = "/v1/users/image?path=" + path
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: data})
-}
-
-/**
- * @description: get current user's image
- * @method:GET
- * @router:/user/image/:id
- */
-func GetUserImage(c *gin.Context) {
-	filePath := c.Query("path")
-	if len(filePath) == 0 {
-		c.JSON(http.StatusNotFound, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	if !file.Exists(filePath) {
-		c.JSON(http.StatusNotFound, model.Result{Success: common_err.FILE_DOES_NOT_EXIST, Message: common_err.GetMsg(common_err.FILE_DOES_NOT_EXIST)})
-		return
-	}
-	if !strings.Contains(filePath, config.AppInfo.UserDataPath) {
-		c.JSON(http.StatusNotFound, model.Result{Success: common_err.INSUFFICIENT_PERMISSIONS, Message: common_err.GetMsg(common_err.INSUFFICIENT_PERMISSIONS)})
-		return
-	}
-
-	fileTmp, _ := os.Open(filePath)
-	defer fileTmp.Close()
-
-	fileName := path.Base(filePath)
-
-	// @tiger - RESTful 规范下不应该返回文件本身内容，而是返回文件的静态URL，由前端去解析
-	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url2.PathEscape(fileName))
-	c.File(filePath)
-}
-func DeleteUserImage(c *gin.Context) {
-	id := c.GetHeader("user_id")
-	path := c.Query("path")
-	if len(path) == 0 {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.INVALID_PARAMS, Message: common_err.GetMsg(common_err.INVALID_PARAMS)})
-		return
-	}
-	user := service.MyService.User().GetUserInfoById(id)
-	if user.Id == 0 {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.USER_NOT_EXIST, Message: common_err.GetMsg(common_err.USER_NOT_EXIST)})
-		return
-	}
-	if !file.Exists(path) {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.FILE_DOES_NOT_EXIST, Message: common_err.GetMsg(common_err.FILE_DOES_NOT_EXIST)})
-		return
-	}
-	if !strings.Contains(path, config.AppInfo.UserDataPath+"/"+strconv.Itoa(user.Id)) {
-		c.JSON(common_err.SERVICE_ERROR, model.Result{Success: common_err.INSUFFICIENT_PERMISSIONS, Message: common_err.GetMsg(common_err.INSUFFICIENT_PERMISSIONS)})
-		return
-	}
-	os.Remove(path)
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-/**
- * @description:
- * @param {*gin.Context} c
- * @param {string} refresh_token
- * @return {*}
- * @method:
- * @router:
- */
-func PostUserRefreshToken(c *gin.Context) {
-	js := make(map[string]string)
-	c.ShouldBind(&js)
-	refresh := js["refresh_token"]
-	claims, err := jwt.ParseToken(refresh, true)
-	if err != nil {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.VERIFICATION_FAILURE, Message: common_err.GetMsg(common_err.VERIFICATION_FAILURE), Data: err.Error()})
-		return
-	}
-	if !claims.VerifyExpiresAt(time.Now(), true) || !claims.VerifyIssuer("refresh", true) {
-		c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.VERIFICATION_FAILURE, Message: common_err.GetMsg(common_err.VERIFICATION_FAILURE)})
-		return
-	}
-	newToken := jwt.GetAccessToken(claims.Username, claims.PassWord, claims.Id)
-	verifyInfo := system_model.VerifyInformation{}
-	verifyInfo.AccessToken = newToken
-	verifyInfo.RefreshToken = jwt.GetRefreshToken(claims.Username, claims.PassWord, claims.Id)
-	verifyInfo.ExpiresAt = time.Now().Add(3 * time.Hour * time.Duration(1)).Unix()
-
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS), Data: verifyInfo})
-
-}
-
-func DeleteUserAll(c *gin.Context) {
-	service.MyService.User().DeleteAllUser()
-	c.JSON(common_err.SUCCESS, model.Result{Success: common_err.SUCCESS, Message: common_err.GetMsg(common_err.SUCCESS)})
-}
-
-// @Summary 检查是否进入引导状态
-// @Produce  application/json
-// @Accept application/json
-// @Tags sys
-// @Security ApiKeyAuth
-// @Success 200 {string} string "ok"
-// @Router /sys/init/check [get]
-func GetUserStatus(c *gin.Context) {
-	data := make(map[string]interface{}, 2)
-
-	if service.MyService.User().GetUserCount() > 0 {
-		data["initialized"] = true
-		data["key"] = ""
-	} else {
-		key := uuid.NewV4().String()
-		service.UserRegisterHash[key] = key
-		data["key"] = key
-		data["initialized"] = false
-	}
-	c.JSON(common_err.SUCCESS,
-		model.Result{
-			Success: common_err.SUCCESS,
-			Message: common_err.GetMsg(common_err.SUCCESS),
-			Data:    data,
-		})
-}

service/app.go

@@ -1,480 +0,0 @@
-package service
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"runtime"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/config"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/command"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-	model2 "github.com/IceWhaleTech/CasaOS/service/model"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	client2 "github.com/docker/docker/client"
-	"github.com/pkg/errors"
-	uuid "github.com/satori/go.uuid"
-	"go.uber.org/zap"
-	"gorm.io/gorm"
-)
-
-type AppService interface {
-	GetMyList(index, size int, position bool) (*[]model2.MyAppList, *[]model2.MyAppList)
-	SaveContainer(m model2.AppListDBModel)
-	GetUninstallInfo(id string) model2.AppListDBModel
-	DeleteApp(id string)
-	GetContainerInfo(id string) (types.Container, error)
-	GetAppDBInfo(id string) model2.AppListDBModel
-	UpdateApp(m model2.AppListDBModel)
-	GetSimpleContainerInfo(id string) (types.Container, error)
-	DelAppConfigDir(path string)
-	GetSystemAppList() []types.Container
-	GetHardwareUsageStream()
-	GetHardwareUsage() []model.DockerStatsModel
-	GetAppStats(id string) string
-	GetAllDBApps() []model2.AppListDBModel
-	ImportApplications(casaApp bool)
-	CheckNewImage()
-}
-
-type appStruct struct {
-	db *gorm.DB
-}
-
-func (a *appStruct) CheckNewImage() {
-	list := MyService.Docker().DockerContainerList()
-	for _, v := range list {
-		inspect, err := MyService.Docker().DockerImageInfo(strings.Split(v.Image, ":")[0])
-		if err != nil {
-			NewVersionApp[v.ID] = inspect.ID
-			continue
-		}
-		if inspect.ID == v.ImageID {
-			delete(NewVersionApp, v.ID)
-			continue
-		}
-		NewVersionApp[v.ID] = inspect.ID
-	}
-
-}
-func (a *appStruct) ImportApplications(casaApp bool) {
-	if casaApp {
-		list := MyService.App().GetAllDBApps()
-		for _, app := range list {
-			info, err := MyService.Docker().DockerContainerInfo(app.CustomId)
-			if err != nil {
-				MyService.App().DeleteApp(app.CustomId)
-				continue
-			}
-			//info.NetworkSettings
-			info.Config.Labels["casaos"] = "casaos"
-			info.Config.Labels["web"] = app.PortMap
-			info.Config.Labels["icon"] = app.Icon
-			info.Config.Labels["desc"] = app.Description
-			info.Config.Labels["index"] = app.Index
-			info.Config.Labels["custom_id"] = app.CustomId
-			info.Name = app.Title
-			container_id, err := MyService.Docker().DockerContainerCopyCreate(info)
-			if err != nil {
-				fmt.Println(err)
-				continue
-			}
-			MyService.App().DeleteApp(app.CustomId)
-			MyService.Docker().DockerContainerStop(app.CustomId)
-			MyService.Docker().DockerContainerRemove(app.CustomId, false)
-			MyService.Docker().DockerContainerStart(container_id)
-
-		}
-	} else {
-		list := MyService.Docker().DockerContainerList()
-		for _, app := range list {
-			info, err := MyService.Docker().DockerContainerInfo(app.ID)
-			if err != nil || info.Config.Labels["casaos"] == "casaos" {
-				continue
-			}
-			info.Config.Labels["casaos"] = "casaos"
-			info.Config.Labels["web"] = ""
-			info.Config.Labels["icon"] = ""
-			info.Config.Labels["desc"] = ""
-			info.Config.Labels["index"] = ""
-			info.Config.Labels["custom_id"] = uuid.NewV4().String()
-
-			_, err = MyService.Docker().DockerContainerCopyCreate(info)
-			if err != nil {
-				continue
-			}
-
-		}
-	}
-
-	// allcontainer := MyService.Docker().DockerContainerList()
-	// for _, app := range allcontainer {
-	// 	info, err := MyService.Docker().DockerContainerInfo(app.ID)
-	// 	if err != nil {
-	// 		continue
-	// 	}
-	// 	MyService.Docker().DockerContainerStop(app.ID)
-	// 	MyService.Docker().DockerContainerRemove(app.ID, false)
-	// 	//info.NetworkSettings
-	// 	info.Config.Labels["custom_id"] = uuid.NewV4().String()
-	// 	container_id, err := MyService.Docker().DockerContainerCopyCreate(info)
-	// 	if err != nil {
-	// 		fmt.Println(err)
-	// 		continue
-	// 	}
-	// 	MyService.Docker().DockerContainerStart(container_id)
-	//}
-}
-
-//获取我的应用列表
-func (a *appStruct) GetMyList(index, size int, position bool) (*[]model2.MyAppList, *[]model2.MyAppList) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv, client2.WithTimeout(time.Second*5))
-	if err != nil {
-		loger.Error("Failed to init client", zap.Any("err", err))
-	}
-	defer cli.Close()
-	// fts := filters.NewArgs()
-	// fts.Add("label", "casaos=casaos")
-	//fts.Add("label", "casaos")
-	//fts.Add("casaos", "casaos")
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true})
-	if err != nil {
-		loger.Error("Failed to get container_list", zap.Any("err", err))
-	}
-	//获取本地数据库应用
-
-	unTranslation := []model2.MyAppList{}
-
-	list := []model2.MyAppList{}
-
-	for _, m := range containers {
-		if m.Labels["casaos"] == "casaos" {
-
-			_, newVersion := NewVersionApp[m.ID]
-			name := strings.ReplaceAll(m.Names[0], "/", "")
-			icon := m.Labels["icon"]
-			if len(m.Labels["name"]) > 0 {
-				name = m.Labels["name"]
-			}
-			if m.Labels["origin"] == "system" {
-				name = strings.Split(m.Image, ":")[0]
-				if len(strings.Split(name, "/")) > 1 {
-					icon = "https://icon.casaos.io/main/all/" + strings.Split(name, "/")[1] + ".png"
-				}
-			}
-
-			list = append(list, model2.MyAppList{
-				Name:     name,
-				Icon:     icon,
-				State:    m.State,
-				CustomId: m.Labels["custom_id"],
-				Id:       m.ID,
-				Port:     m.Labels["web"],
-				Index:    m.Labels["index"],
-				//Order:      m.Labels["order"],
-				Image:  m.Image,
-				Latest: newVersion,
-				//Type:   m.Labels["origin"],
-				//Slogan: m.Slogan,
-				//Rely:     m.Rely,
-				Host:     m.Labels["host"],
-				Protocol: m.Labels["protocol"],
-			})
-		} else {
-			unTranslation = append(unTranslation, model2.MyAppList{
-				Name:     strings.ReplaceAll(m.Names[0], "/", ""),
-				Icon:     "",
-				State:    m.State,
-				CustomId: m.ID,
-				Id:       m.ID,
-				Port:     "",
-				Latest:   false,
-				Host:     "",
-				Protocol: "",
-				Image:    m.Image,
-			})
-		}
-	}
-
-	//lMap := make(map[string]interface{})
-	// for _, dbModel := range lm {
-	// 	if position {
-	// 		if dbModel.Position {
-	// 			lMap[dbModel.ContainerId] = dbModel
-	// 		}
-	// 	} else {
-	// 		lMap[dbModel.ContainerId] = dbModel
-	// 	}
-	// }
-	// for _, container := range containers {
-
-	// 	if lMap[container.ID] != nil && container.Labels["origin"] != "system" {
-	// 		m := lMap[container.ID].(model2.AppListDBModel)
-	// 		if len(m.Label) == 0 {
-	// 			m.Label = m.Title
-	// 		}
-
-	// 		// info, err := cli.ContainerInspect(context.Background(), container.ID)
-	// 		// var tm string
-	// 		// if err != nil {
-	// 		// 	tm = time.Now().String()
-	// 		// } else {
-	// 		// 	tm = info.State.StartedAt
-	// 		//}
-	// 		list = append(list, model2.MyAppList{
-	// 			Name:     m.Label,
-	// 			Icon:     m.Icon,
-	// 			State:    container.State,
-	// 			CustomId: strings.ReplaceAll(container.Names[0], "/", ""),
-	// 			Port:     m.PortMap,
-	// 			Index:    m.Index,
-	// 			//UpTime:   tm,
-	// 			Image:  m.Image,
-	// 			Slogan: m.Slogan,
-	// 			//Rely:     m.Rely,
-	// 		})
-	// 	}
-
-	// }
-
-	return &list, &unTranslation
-
-}
-
-//system application list
-func (a *appStruct) GetSystemAppList() []types.Container {
-	//获取docker应用
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		loger.Error("Failed to init client", zap.Any("err", err))
-	}
-	defer cli.Close()
-	fts := filters.NewArgs()
-	fts.Add("label", "origin=system")
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true, Filters: fts})
-	if err != nil {
-		loger.Error("Failed to get container_list", zap.Any("err", err))
-	}
-
-	//获取本地数据库应用
-
-	// var lm []model2.AppListDBModel
-	// a.db.Table(model2.CONTAINERTABLENAME).Select("title,icon,port_map,`index`,container_id,position,label,slogan,image,volumes").Find(&lm)
-
-	//list := []model2.MyAppList{}
-	//lMap := make(map[string]interface{})
-	// for _, dbModel := range lm {
-	// 	lMap[dbModel.ContainerId] = dbModel
-	// }
-
-	return containers
-
-}
-func (a *appStruct) GetAllDBApps() []model2.AppListDBModel {
-	var lm []model2.AppListDBModel
-	a.db.Table(model2.CONTAINERTABLENAME).Select("custom_id,title,icon,container_id,label,slogan,image,port_map").Find(&lm)
-	return lm
-}
-
-//获取我的应用列表
-func (a *appStruct) GetContainerInfo(id string) (types.Container, error) {
-	//获取docker应用
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		loger.Error("Failed to init client", zap.Any("err", err))
-	}
-	filters := filters.NewArgs()
-	filters.Add("id", id)
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true, Filters: filters})
-	if err != nil {
-		loger.Error("Failed to get container_list", zap.Any("err", err))
-	}
-
-	if len(containers) > 0 {
-		return containers[0], nil
-	}
-	return types.Container{}, nil
-
-}
-
-func (a *appStruct) GetSimpleContainerInfo(id string) (types.Container, error) {
-	//获取docker应用
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return types.Container{}, err
-	}
-	defer cli.Close()
-	filters := filters.NewArgs()
-	filters.Add("id", id)
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true, Filters: filters})
-	if err != nil {
-		return types.Container{}, err
-	}
-
-	if len(containers) > 0 {
-		return containers[0], nil
-	}
-	return types.Container{}, errors.New("container not existent")
-}
-
-//获取我的应用列表
-func (a *appStruct) GetAppDBInfo(id string) model2.AppListDBModel {
-	var m model2.AppListDBModel
-	a.db.Table(model2.CONTAINERTABLENAME).Where("custom_id = ?", id).First(&m)
-	return m
-}
-
-//根据容器id获取镜像名称
-func (a *appStruct) GetUninstallInfo(id string) model2.AppListDBModel {
-	var m model2.AppListDBModel
-	a.db.Table(model2.CONTAINERTABLENAME).Select("image,version,enable_upnp,ports,envs,volumes,origin").Where("custom_id = ?", id).First(&m)
-	return m
-}
-
-//创建容器成功后保存容器
-func (a *appStruct) SaveContainer(m model2.AppListDBModel) {
-	a.db.Table(model2.CONTAINERTABLENAME).Create(&m)
-}
-
-func (a *appStruct) UpdateApp(m model2.AppListDBModel) {
-	a.db.Table(model2.CONTAINERTABLENAME).Save(&m)
-}
-
-func (a *appStruct) DelAppConfigDir(path string) {
-	command.OnlyExec("source " + config.AppInfo.ShellPath + "/helper.sh ;DelAppConfigDir " + path)
-}
-
-func (a *appStruct) DeleteApp(id string) {
-	a.db.Table(model2.CONTAINERTABLENAME).Where("custom_id = ?", id).Delete(&model2.AppListDBModel{})
-}
-
-var dataStats sync.Map
-
-var isFinish bool = false
-
-func (a *appStruct) GetAppStats(id string) string {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return ""
-	}
-	defer cli.Close()
-	con, err := cli.ContainerStats(context.Background(), id, false)
-	if err != nil {
-		return err.Error()
-	}
-	defer con.Body.Close()
-	c, _ := ioutil.ReadAll(con.Body)
-	return string(c)
-}
-
-func (a *appStruct) GetHardwareUsage() []model.DockerStatsModel {
-
-	stream := true
-	for !isFinish {
-		if stream {
-			stream = false
-			go func() {
-				a.GetHardwareUsageStream()
-			}()
-		}
-		runtime.Gosched()
-	}
-	list := []model.DockerStatsModel{}
-
-	dataStats.Range(func(key, value interface{}) bool {
-		list = append(list, value.(model.DockerStatsModel))
-		return true
-	})
-	return list
-
-}
-
-func (a *appStruct) GetHardwareUsageStream() {
-
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return
-	}
-	defer cli.Close()
-
-	ctx := context.Background()
-	ctx, cancel := context.WithCancel(ctx)
-
-	fts := filters.NewArgs()
-	fts.Add("label", "casaos=casaos")
-	//fts.Add("status", "running")
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true, Filters: fts})
-	if err != nil {
-		loger.Error("Failed to get container_list", zap.Any("err", err))
-	}
-	for i := 0; i < 100; i++ {
-		if i%10 == 0 {
-			containers, err = cli.ContainerList(context.Background(), types.ContainerListOptions{All: true, Filters: fts})
-			if err != nil {
-				loger.Error("Failed to get container_list", zap.Any("err", err))
-				continue
-			}
-		}
-		if config.CasaOSGlobalVariables.AppChange {
-			config.CasaOSGlobalVariables.AppChange = false
-			dataStats.Range(func(key, value interface{}) bool {
-				dataStats.Delete(key)
-				return true
-			})
-		}
-
-		var temp sync.Map
-		var wg sync.WaitGroup
-		for _, v := range containers {
-			if v.State != "running" {
-				continue
-			}
-			wg.Add(1)
-			go func(v types.Container, i int) {
-				defer wg.Done()
-				stats, err := cli.ContainerStats(ctx, v.ID, true)
-				if err != nil {
-					return
-				}
-				decode := json.NewDecoder(stats.Body)
-				var data interface{}
-				if err := decode.Decode(&data); err == io.EOF {
-					return
-				}
-				m, _ := dataStats.Load(v.ID)
-				dockerStats := model.DockerStatsModel{}
-				if m != nil {
-					dockerStats.Previous = m.(model.DockerStatsModel).Data
-				}
-				dockerStats.Data = data
-				dockerStats.Icon = v.Labels["icon"]
-				dockerStats.Title = strings.ReplaceAll(v.Names[0], "/", "")
-
-				// @tiger - 不建议直接把依赖的数据结构封装返回。
-				//          如果依赖的数据结构有变化，应该在这里适配或者保存，这样更加对客户端负责
-				temp.Store(v.ID, dockerStats)
-				if i == 99 {
-					stats.Body.Close()
-				}
-			}(v, i)
-		}
-		wg.Wait()
-		dataStats = temp
-		isFinish = true
-
-		time.Sleep(time.Second * 1)
-	}
-	isFinish = false
-	cancel()
-}
-
-func NewAppService(db *gorm.DB) AppService {
-	return &appStruct{db: db}
-}

service/casa.go

@@ -1,274 +1,20 @@
 package service
 
 import (
-	"encoding/json"
 	json2 "encoding/json"
-	"fmt"
-	"sort"
-	"strconv"
 	"time"
 
 	"github.com/IceWhaleTech/CasaOS/model"
 	"github.com/IceWhaleTech/CasaOS/pkg/config"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/httper"
-	httper2 "github.com/IceWhaleTech/CasaOS/pkg/utils/httper"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-	"github.com/pkg/errors"
 	"github.com/tidwall/gjson"
-	"go.uber.org/zap"
 )
 
 type CasaService interface {
-	GetServerList(index, size, tp, categoryId, key string) (model.ServerAppListCollection, error)
-	GetServerCategoryList() (list []model.CategoryList, err error)
-	GetServerAppInfo(id, t string, language string) (model.ServerAppList, error)
-	ShareAppFile(body []byte) string
 	GetCasaosVersion() model.Version
-	AsyncGetServerList() (collection model.ServerAppListCollection, err error)
-	AsyncGetServerCategoryList() ([]model.CategoryList, error)
 }
 
-type casaService struct {
-}
-
-func (o *casaService) ShareAppFile(body []byte) string {
-	head := make(map[string]string)
-
-	head["Authorization"] = GetToken()
-
-	content := httper2.Post(config.ServerInfo.ServerApi+"/v1/community/add", body, "application/json", head)
-	return content
-}
-
-func (o *casaService) GetServerList(index, size, tp, categoryId, key string) (model.ServerAppListCollection, error) {
-
-	keyName := fmt.Sprintf("list_%s_%s_%s_%s_%s", index, size, tp, categoryId, "en")
-	collection := model.ServerAppListCollection{}
-	if result, ok := Cache.Get(keyName); ok {
-		res, ok := result.(string)
-		if ok {
-			json2.Unmarshal([]byte(res), &collection)
-			return collection, nil
-		}
-	}
-
-	collectionStr := file.ReadFullFile(config.AppInfo.DBPath + "/app_list.json")
-
-	err := json2.Unmarshal(collectionStr, &collection)
-	if err != nil {
-		loger.Error("marshal error", zap.Any("err", err), zap.Any("content", string(collectionStr)))
-		collection, err = o.AsyncGetServerList()
-		if err != nil {
-			return collection, err
-		}
-	}
-
-	go o.AsyncGetServerList()
-
-	if categoryId != "0" {
-		categoryInt, _ := strconv.Atoi(categoryId)
-		nList := []model.ServerAppList{}
-		for _, v := range collection.List {
-			if v.CategoryId == categoryInt {
-				nList = append(nList, v)
-			}
-		}
-		collection.List = nList
-		nCommunity := []model.ServerAppList{}
-		for _, v := range collection.Community {
-			if v.CategoryId == categoryInt {
-				nCommunity = append(nCommunity, v)
-			}
-		}
-		collection.Community = nCommunity
-	}
-	if tp != "name" {
-		if tp == "new" {
-			sort.Slice(collection.List, func(i, j int) bool {
-				return collection.List[i].CreatedAt.After(collection.List[j].CreatedAt)
-			})
-			sort.Slice(collection.Community, func(i, j int) bool {
-				return collection.Community[i].CreatedAt.After(collection.Community[j].CreatedAt)
-			})
-		} else if tp == "rank" {
-			sort.Slice(collection.List, func(i, j int) bool {
-				return collection.List[i].QueryCount > collection.List[j].QueryCount
-			})
-			sort.Slice(collection.Community, func(i, j int) bool {
-				return collection.Community[i].QueryCount > collection.Community[j].QueryCount
-			})
-		}
-	}
-	sizeInt, _ := strconv.Atoi(size)
-
-	if index != "1" {
-		indexInt, _ := strconv.Atoi(index)
-		collection.List = collection.List[(indexInt-1)*sizeInt : indexInt*sizeInt]
-		collection.Community = collection.Community[(indexInt-1)*sizeInt : indexInt*sizeInt]
-	} else {
-		if len(collection.List) > sizeInt {
-			collection.List = collection.List[:sizeInt]
-		}
-		if len(collection.Community) > sizeInt {
-			collection.Community = collection.Community[:sizeInt]
-		}
-	}
-
-	if len(collection.List) > 0 {
-		by, _ := json.Marshal(collection)
-		Cache.Set(keyName, string(by), time.Minute*10)
-	}
-
-	return collection, nil
-
-}
-
-func (o *casaService) AsyncGetServerList() (collection model.ServerAppListCollection, err error) {
-
-	results := file.ReadFullFile(config.AppInfo.DBPath + "/app_list.json")
-	errr := json2.Unmarshal(results, &collection)
-	if errr != nil {
-		loger.Error("marshal error", zap.Any("err", err), zap.Any("content", string(results)))
-	} else {
-		if collection.Version == o.GetCasaosVersion().Version {
-			return collection, err
-		}
-	}
-
-	head := make(map[string]string)
-
-	head["Authorization"] = GetToken()
-
-	listS := httper2.Get(config.ServerInfo.ServerApi+"/v2/app/newlist?index=1&size=1000&rank=name&category_id=0&key=&language=en", head)
-	listModel := []model.ServerAppList{}
-	communityModel := []model.ServerAppList{}
-	recommendModel := []model.ServerAppList{}
-	json2.Unmarshal([]byte(gjson.Get(listS, "data.list").String()), &listModel)
-	json2.Unmarshal([]byte(gjson.Get(listS, "data.recommend").String()), &recommendModel)
-	json2.Unmarshal([]byte(gjson.Get(listS, "data.community").String()), &communityModel)
-
-	if len(listModel) > 0 {
-		collection.Community = communityModel
-		collection.List = listModel
-		collection.Recommend = recommendModel
-		collection.Version = o.GetCasaosVersion().Version
-		var by []byte
-		by, err = json.Marshal(collection)
-		if err != nil {
-			loger.Error("marshal error", zap.Any("err", err))
-		}
-		file.WriteToPath(by, config.AppInfo.DBPath, "app_list.json")
-	}
-	return
-}
-
-// func (o *casaService) GetServerCategoryList() (list []model.ServerCategoryList) {
-
-// 	keyName := fmt.Sprintf("category_list")
-// 	if result, ok := Cache.Get(keyName); ok {
-// 		res, ok := result.(string)
-// 		if ok {
-// 			json2.Unmarshal([]byte(gjson.Get(res, "data").String()), &list)
-// 			return list
-// 		}
-// 	}
-
-// 	head := make(map[string]string)
-// 	head["Authorization"] = GetToken()
-
-// 	listS := httper2.Get(config.ServerInfo.ServerApi+"/v2/app/category", head)
-
-// 	json2.Unmarshal([]byte(gjson.Get(listS, "data").String()), &list)
-// 	if len(list) > 0 {
-// 		Cache.Set(keyName, listS, time.Hour*24)
-// 	}
-// 	return list
-// }
-
-func (o *casaService) GetServerCategoryList() (list []model.CategoryList, err error) {
-	category := model.ServerCategoryList{}
-	results := file.ReadFullFile(config.AppInfo.DBPath + "/app_category.json")
-	err = json2.Unmarshal(results, &category)
-	if err != nil {
-		loger.Error("marshal error", zap.Any("err", err), zap.Any("content", string(results)))
-		return o.AsyncGetServerCategoryList()
-	}
-	go o.AsyncGetServerCategoryList()
-	return category.Item, err
-}
-
-func (o *casaService) AsyncGetServerCategoryList() ([]model.CategoryList, error) {
-	list := model.ServerCategoryList{}
-	results := file.ReadFullFile(config.AppInfo.DBPath + "/app_category.json")
-	err := json2.Unmarshal(results, &list)
-	if err != nil {
-		loger.Error("marshal error", zap.Any("err", err), zap.Any("content", string(results)))
-	} else {
-		if list.Version == o.GetCasaosVersion().Version {
-			return list.Item, nil
-		}
-	}
-	item := []model.CategoryList{}
-	head := make(map[string]string)
-	head["Authorization"] = GetToken()
-	listS := httper2.Get(config.ServerInfo.ServerApi+"/v2/app/category", head)
-	if len(listS) == 0 {
-		return item, errors.New("server error")
-	}
-	json2.Unmarshal([]byte(gjson.Get(listS, "data").String()), &item)
-	if len(item) > 0 {
-		list.Version = o.GetCasaosVersion().Version
-		list.Item = item
-		by, err := json.Marshal(list)
-		if err != nil {
-			loger.Error("marshal error", zap.Any("err", err))
-		}
-		file.WriteToPath(by, config.AppInfo.DBPath, "app_category.json")
-	}
-	return item, nil
-}
-
-func (o *casaService) GetServerAppInfo(id, t string, language string) (model.ServerAppList, error) {
-
-	head := make(map[string]string)
-
-	head["Authorization"] = GetToken()
-	infoS := httper2.Get(config.ServerInfo.ServerApi+"/v2/app/info/"+id+"?t="+t+"&language="+language, head)
-
-	info := model.ServerAppList{}
-	if infoS == "" {
-		return info, errors.New("server error")
-	}
-	err := json2.Unmarshal([]byte(gjson.Get(infoS, "data").String()), &info)
-	if err != nil {
-		fmt.Println(infoS)
-		return info, err
-	}
-
-	return info, nil
-}
-func GetToken() string {
-	t := make(chan string)
-	keyName := "casa_token"
-
-	var auth string
-	if result, ok := Cache.Get(keyName); ok {
-		auth, ok = result.(string)
-		if ok {
-
-			return auth
-		}
-	}
-	go func() {
-		str := httper2.Get(config.ServerInfo.ServerApi+"/token", nil)
-		t <- gjson.Get(str, "data").String()
-	}()
-	auth = <-t
-
-	Cache.SetDefault(keyName, auth)
-	return auth
-}
+type casaService struct{}
 
 /**
  * @description: get remote version

service/disk.go

@@ -1,285 +0,0 @@
-package service
-
-import (
-	json2 "encoding/json"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/config"
-	command2 "github.com/IceWhaleTech/CasaOS/pkg/utils/command"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-	model2 "github.com/IceWhaleTech/CasaOS/service/model"
-	"github.com/shirou/gopsutil/v3/disk"
-	"github.com/tidwall/gjson"
-	"go.uber.org/zap"
-	"gorm.io/gorm"
-)
-
-type DiskService interface {
-	GetPlugInDisk() []string
-	LSBLK(isUseCache bool) []model.LSBLKModel
-	SmartCTL(path string) model.SmartctlA
-	FormatDisk(path, format string) []string
-	UmountPointAndRemoveDir(path string) []string
-	GetDiskInfo(path string) model.LSBLKModel
-	DelPartition(path, num string) string
-	AddPartition(path string) string
-	GetDiskInfoByPath(path string) *disk.UsageStat
-	MountDisk(path, volume string)
-	GetSerialAll() []model2.SerialDisk
-	SaveMountPoint(m model2.SerialDisk)
-	DeleteMountPoint(path, mountPoint string)
-	DeleteMount(id string)
-	UpdateMountPoint(m model2.SerialDisk)
-	RemoveLSBLKCache()
-	UmountUSB(path string)
-}
-type diskService struct {
-	db *gorm.DB
-}
-
-func (d *diskService) RemoveLSBLKCache() {
-	key := "system_lsblk"
-	Cache.Delete(key)
-}
-func (d *diskService) UmountUSB(path string) {
-	r := command2.ExecResultStr("source " + config.AppInfo.ShellPath + "/helper.sh ;UDEVILUmount " + path)
-	fmt.Println(r)
-}
-func (d *diskService) SmartCTL(path string) model.SmartctlA {
-
-	key := "system_smart_" + path
-	if result, ok := Cache.Get(key); ok {
-
-		res, ok := result.(model.SmartctlA)
-		if ok {
-			return res
-		}
-	}
-	var m model.SmartctlA
-	str := command2.ExecSmartCTLByPath(path)
-	if str == nil {
-		loger.Error("failed to  exec shell ", zap.Any("err", "smartctl exec error"))
-		Cache.Add(key, m, time.Minute*10)
-		return m
-	}
-
-	err := json2.Unmarshal([]byte(str), &m)
-	if err != nil {
-		loger.Error("Failed to unmarshal json", zap.Any("err", err))
-	}
-	if !reflect.DeepEqual(m, model.SmartctlA{}) {
-		Cache.Add(key, m, time.Hour*24)
-	}
-	return m
-}
-
-//通过脚本获取外挂磁盘
-func (d *diskService) GetPlugInDisk() []string {
-	return command2.ExecResultStrArray("source " + config.AppInfo.ShellPath + "/helper.sh ;GetPlugInDisk")
-}
-
-//格式化硬盘
-func (d *diskService) FormatDisk(path, format string) []string {
-	r := command2.ExecResultStrArray("source " + config.AppInfo.ShellPath + "/helper.sh ;FormatDisk " + path + " " + format)
-	return r
-}
-
-//移除挂载点,删除目录
-func (d *diskService) UmountPointAndRemoveDir(path string) []string {
-	r := command2.ExecResultStrArray("source " + config.AppInfo.ShellPath + "/helper.sh ;UMountPorintAndRemoveDir " + path)
-	return r
-}
-
-//删除分区
-func (d *diskService) DelPartition(path, num string) string {
-	r := command2.ExecResultStrArray("source " + config.AppInfo.ShellPath + "/helper.sh ;DelPartition " + path + " " + num)
-	fmt.Println(r)
-	return ""
-}
-
-//part
-func (d *diskService) AddPartition(path string) string {
-	command2.ExecResultStrArray("source " + config.AppInfo.ShellPath + "/helper.sh ;AddPartition " + path)
-	return ""
-}
-
-func (d *diskService) AddAllPartition(path string) {
-
-}
-
-//获取硬盘详情
-func (d *diskService) GetDiskInfoByPath(path string) *disk.UsageStat {
-	diskInfo, err := disk.Usage(path + "1")
-
-	if err != nil {
-		fmt.Println(err)
-	}
-	diskInfo.UsedPercent, _ = strconv.ParseFloat(fmt.Sprintf("%.1f", diskInfo.UsedPercent), 64)
-	diskInfo.InodesUsedPercent, _ = strconv.ParseFloat(fmt.Sprintf("%.1f", diskInfo.InodesUsedPercent), 64)
-	return diskInfo
-}
-
-//get disk details
-func (d *diskService) LSBLK(isUseCache bool) []model.LSBLKModel {
-	key := "system_lsblk"
-	var n []model.LSBLKModel
-
-	if result, ok := Cache.Get(key); ok && isUseCache {
-
-		res, ok := result.([]model.LSBLKModel)
-		if ok {
-			return res
-		}
-	}
-
-	str := command2.ExecLSBLK()
-	if str == nil {
-		loger.Error("Failed to exec shell", zap.Any("err", "lsblk exec error"))
-		return nil
-	}
-	var m []model.LSBLKModel
-	err := json2.Unmarshal([]byte(gjson.Get(string(str), "blockdevices").String()), &m)
-	if err != nil {
-		loger.Error("Failed to unmarshal json", zap.Any("err", err))
-	}
-
-	var c []model.LSBLKModel
-
-	var fsused uint64
-
-	var health = true
-	for _, i := range m {
-		if i.Type != "loop" && !i.RO {
-			fsused = 0
-			for _, child := range i.Children {
-				if child.RM {
-					child.Health = strings.TrimSpace(command2.ExecResultStr("source " + config.AppInfo.ShellPath + "/helper.sh ;GetDiskHealthState " + child.Path))
-					if strings.ToLower(strings.TrimSpace(child.State)) != "ok" {
-						health = false
-					}
-					f, _ := strconv.ParseUint(child.FSUsed, 10, 64)
-					fsused += f
-				} else {
-					health = false
-				}
-				c = append(c, child)
-			}
-			//i.Format = strings.TrimSpace(command2.ExecResultStr("source " + config.AppInfo.ShellPath + "/helper.sh ;GetDiskType " + i.Path))
-			if health {
-				i.Health = "OK"
-			}
-			i.FSUsed = strconv.FormatUint(fsused, 10)
-			i.Children = c
-			if fsused > 0 {
-				i.UsedPercent, err = strconv.ParseFloat(fmt.Sprintf("%.4f", float64(fsused)/float64(i.Size)), 64)
-				if err != nil {
-					loger.Error("Failed to parse float", zap.Any("err", err))
-				}
-			}
-			n = append(n, i)
-			health = true
-			c = []model.LSBLKModel{}
-			fsused = 0
-		}
-	}
-	if len(n) > 0 {
-		Cache.Add(key, n, time.Second*100)
-	}
-	return n
-}
-
-func (d *diskService) GetDiskInfo(path string) model.LSBLKModel {
-	str := command2.ExecLSBLKByPath(path)
-	if str == nil {
-		loger.Error("Failed to exec shell", zap.Any("err", "lsblk exec error"))
-		return model.LSBLKModel{}
-	}
-
-	var ml []model.LSBLKModel
-	err := json2.Unmarshal([]byte(gjson.Get(string(str), "blockdevices").String()), &ml)
-	if err != nil {
-		loger.Error("Failed to unmarshal json", zap.Any("err", err))
-		return model.LSBLKModel{}
-	}
-
-	m := model.LSBLKModel{}
-	if len(ml) > 0 {
-		m = ml[0]
-	}
-	return m
-	// 下面为计算是否可以继续分区的部分,暂时不需要
-	chiArr := make(map[string]string)
-	chiList := command2.ExecResultStrArray("source " + config.AppInfo.ShellPath + "/helper.sh ;GetPartitionSectors " + m.Path)
-	if len(chiList) == 0 {
-		loger.Error("chiList length error", zap.Any("err", "chiList length error"))
-	}
-	for i := 0; i < len(chiList); i++ {
-		tempArr := strings.Split(chiList[i], ",")
-		chiArr[tempArr[0]] = chiList[i]
-	}
-	var maxSector uint64 = 0
-	for i := 0; i < len(m.Children); i++ {
-		tempArr := strings.Split(chiArr[m.Children[i].Path], ",")
-		m.Children[i].StartSector, _ = strconv.ParseUint(tempArr[1], 10, 64)
-		m.Children[i].EndSector, _ = strconv.ParseUint(tempArr[2], 10, 64)
-		if m.Children[i].EndSector > maxSector {
-			maxSector = m.Children[i].EndSector
-		}
-
-	}
-	diskEndSector := command2.ExecResultStrArray("source " + config.AppInfo.ShellPath + "/helper.sh ;GetDiskSizeAndSectors " + m.Path)
-
-	if len(diskEndSector) < 2 {
-		loger.Error("diskEndSector length error", zap.Any("err", "diskEndSector length error"))
-	}
-	diskEndSectorInt, _ := strconv.ParseUint(diskEndSector[len(diskEndSector)-1], 10, 64)
-	if (diskEndSectorInt-maxSector)*m.MinIO/1024/1024 > 100 {
-		//添加可以分区情况
-		p := model.LSBLKModel{}
-		p.Path = "可以添加"
-		m.Children = append(m.Children, p)
-	}
-	return m
-}
-
-func (d *diskService) MountDisk(path, volume string) {
-	//fmt.Println("source " + config.AppInfo.ShellPath + "/helper.sh ;do_mount " + path + " " + volume)
-	r := command2.ExecResultStr("source " + config.AppInfo.ShellPath + "/helper.sh ;do_mount " + path + " " + volume)
-	fmt.Println(r)
-}
-
-func (d *diskService) SaveMountPoint(m model2.SerialDisk) {
-	d.db.Where("uuid = ?", m.UUID).Delete(&model2.SerialDisk{})
-	d.db.Create(&m)
-}
-
-func (d *diskService) UpdateMountPoint(m model2.SerialDisk) {
-	d.db.Model(&model2.SerialDisk{}).Where("uui = ?", m.UUID).Update("mount_point", m.MountPoint)
-}
-
-func (d *diskService) DeleteMount(id string) {
-
-	d.db.Delete(&model2.SerialDisk{}).Where("id = ?", id)
-}
-
-func (d *diskService) DeleteMountPoint(path, mountPoint string) {
-
-	d.db.Where("path = ? AND mount_point = ?", path, mountPoint).Delete(&model2.SerialDisk{})
-
-	command2.OnlyExec("source " + config.AppInfo.ShellPath + "/helper.sh ;do_umount " + path)
-}
-
-func (d *diskService) GetSerialAll() []model2.SerialDisk {
-	var m []model2.SerialDisk
-	d.db.Find(&m)
-	return m
-}
-
-func NewDiskService(db *gorm.DB) DiskService {
-	return &diskService{db: db}
-}

service/docker.go

@@ -1,944 +0,0 @@
-package service
-
-import (
-	"bytes"
-	"context"
-	"encoding/base64"
-	"encoding/binary"
-	json2 "encoding/json"
-	"fmt"
-	"syscall"
-
-	"github.com/IceWhaleTech/CasaOS/model/notify"
-	"github.com/containerd/containerd"
-	"github.com/containerd/containerd/cio"
-	"github.com/containerd/containerd/namespaces"
-	"github.com/containerd/containerd/oci"
-	"github.com/pkg/errors"
-	"go.uber.org/zap"
-
-	"github.com/IceWhaleTech/CasaOS/model"
-	"github.com/IceWhaleTech/CasaOS/pkg/docker"
-	command2 "github.com/IceWhaleTech/CasaOS/pkg/utils/command"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/env_helper"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
-
-	//"github.com/containerd/containerd/oci"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/mount"
-	"github.com/docker/docker/api/types/network"
-	client2 "github.com/docker/docker/client"
-	"github.com/docker/go-connections/nat"
-)
-
-type DockerService interface {
-	DockerPullImage(imageName string, icon, name string) error
-	IsExistImage(imageName string) bool
-	DockerContainerCreate(m model.CustomizationPostData, id string) (containerId string, err error)
-	DockerContainerCopyCreate(info *types.ContainerJSON) (containerId string, err error)
-	DockerContainerStart(name string) error
-	DockerContainerStats(name string) (string, error)
-	DockerListByName(name string) (*types.Container, error)
-	DockerListByImage(image, version string) (*types.Container, error)
-	DockerContainerInfo(name string) (*types.ContainerJSON, error)
-	DockerImageRemove(name string) error
-	DockerContainerRemove(name string, update bool) error
-	DockerContainerStop(id string) error
-	DockerContainerUpdateName(name, id string) (err error)
-	DockerContainerUpdate(m model.CustomizationPostData, id string) (err error)
-	DockerContainerLog(name string) (string, error)
-	DockerContainerCommit(name string)
-	DockerContainerList() []types.Container
-	DockerNetworkModelList() []types.NetworkResource
-	DockerImageInfo(image string) (types.ImageInspect, error)
-	GetNetWorkNameByNetWorkID(id string) (string, error)
-	ContainerExecShell(container_id string) string
-}
-
-type dockerService struct {
-	rootDir string
-}
-
-func (ds *dockerService) DockerContainerList() []types.Container {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv, client2.WithTimeout(time.Second*5))
-	if err != nil {
-		return nil
-	}
-	defer cli.Close()
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true})
-	if err != nil {
-		return containers
-	}
-	return containers
-}
-
-func (ds *dockerService) ContainerExecShell(container_id string) string {
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	exec, err := cli.ContainerExecCreate(context.Background(), container_id, types.ExecConfig{
-		User: "1000:1000",
-		Cmd:  []string{"echo -e \"hellow\nworld\" >> /a.txt"},
-	})
-	if err != nil {
-		os.Exit(5)
-	}
-	err = cli.ContainerExecStart(context.Background(), exec.ID, types.ExecStartCheck{})
-	if err != nil {
-		fmt.Println("exec script error ", err)
-	}
-	return exec.ID
-}
-
-//创建默认网络
-func DockerNetwork() {
-
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	defer cli.Close()
-	d, _ := cli.NetworkList(context.Background(), types.NetworkListOptions{})
-
-	for _, resource := range d {
-		if resource.Name == docker.NETWORKNAME {
-			return
-		}
-	}
-	cli.NetworkCreate(context.Background(), docker.NETWORKNAME, types.NetworkCreate{})
-}
-
-//根据网络id获取网络名
-func (ds *dockerService) GetNetWorkNameByNetWorkID(id string) (string, error) {
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	defer cli.Close()
-	filter := filters.NewArgs()
-	filter.Add("id", id)
-	d, err := cli.NetworkList(context.Background(), types.NetworkListOptions{Filters: filter})
-	if err == nil && len(d) > 0 {
-		return d[0].Name, nil
-	}
-	return "", err
-}
-
-//拉取镜像
-func DockerPull() {
-
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	defer cli.Close()
-
-	authConfig := types.AuthConfig{}
-	encodedJSON, err := json2.Marshal(authConfig)
-	fmt.Println(err)
-
-	authStr := base64.URLEncoding.EncodeToString(encodedJSON)
-	reader, err := cli.ImagePull(context.Background(), "swr.cn-north-4.myhuaweicloud.com/root/swr-demo-2048:latest", types.ImagePullOptions{RegistryAuth: authStr})
-
-	buf := new(bytes.Buffer)
-	buf.ReadFrom(reader)
-	fmt.Println(buf.String())
-
-}
-
-//拉取镜像
-func DockerEx() {
-
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	defer cli.Close()
-
-	importResponse, err := cli.ImageImport(context.Background(), types.ImageImportSource{
-		Source:     strings.NewReader("source"),
-		SourceName: "image_source",
-	}, "repository_name:imported", types.ImageImportOptions{
-		Tag:     "imported",
-		Message: "A message",
-		Changes: []string{"change1", "change2"},
-	})
-
-	response, err := ioutil.ReadAll(importResponse)
-	if err != nil {
-		fmt.Println(err)
-	}
-	importResponse.Close()
-	println(string(response))
-	if string(response) != "response" {
-		fmt.Printf("expected response to contain 'response', got %s", string(response))
-	}
-}
-
-//func DockerContainerSize() {
-//	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-//	//but := bytes.Buffer{}
-//	d, err := cli.ContainerExecCreate(context.Background(), "c3adcef92bae648890941ac00e6c4024d7f2959c2e629f0b581d6a19d77b5eda")
-//	fmt.Println(d)
-//	st, _ := ioutil.ReadAll(d.Body)
-//	fmt.Println(string(st))
-//	if err != nil {
-//		fmt.Print(err)
-//	}
-//
-//}
-
-func (ds *dockerService) DockerImageInfo(image string) (types.ImageInspect, error) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return types.ImageInspect{}, err
-	}
-	inspect, _, err := cli.ImageInspectWithRaw(context.Background(), image)
-	if err != nil {
-		return inspect, err
-	}
-	return inspect, nil
-}
-
-func MsqlExec(container string) error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	ctx := context.Background()
-	// 执行/bin/bash命令
-	ir, err := cli.ContainerExecCreate(ctx, container, types.ExecConfig{
-		AttachStdin:  false,
-		AttachStdout: true,
-		AttachStderr: true,
-		Cmd:          []string{"date"},
-		Tty:          true,
-		Env:          []string{"aaa=ddd"},
-	})
-	err = cli.ContainerExecStart(ctx, ir.ID, types.ExecStartCheck{})
-
-	fmt.Println(err)
-
-	return err
-}
-
-func Exec(container, row, col string) (hr types.HijackedResponse, err error) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	ctx := context.Background()
-	// 执行/bin/bash命令
-	ir, err := cli.ContainerExecCreate(ctx, container, types.ExecConfig{
-		AttachStdin:  true,
-		AttachStdout: true,
-		AttachStderr: true,
-		Env:          []string{"COLUMNS=" + col, "LINES=" + row},
-		Cmd:          []string{"/bin/bash"},
-		Tty:          true,
-	})
-	if err != nil {
-		return
-	}
-	// 附加到上面创建的/bin/bash进程中
-	hr, err = cli.ContainerExecAttach(ctx, ir.ID, types.ExecStartCheck{Detach: false, Tty: true})
-	if err != nil {
-		return
-	}
-	return
-}
-
-func DockerLog() {
-	//cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	//ctx := context.Background()
-	//ir, err := cli.ContainerLogs(ctx, "79c6fa382c330b9149e2d28d24f4d2c231cdb8cfc0710c2d268ccee13c5b24f8", types.ContainerLogsOptions{})
-	//str, err := ioutil.ReadAll(ir)
-	//fmt.Println(string(str))
-	//fmt.Println(err)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	client, _ := client2.NewClientWithOpts(client2.FromEnv)
-	reader, err := client.ContainerLogs(ctx, "79c6fa382c330b9149e2d28d24f4d2c231cdb8cfc0710c2d268ccee13c5b24f8", types.ContainerLogsOptions{})
-	if err != nil {
-		log.Fatal(err)
-	}
-	_, err = io.Copy(os.Stdout, reader)
-	if err != nil && err != io.EOF {
-		log.Fatal(err)
-	}
-}
-
-func DockerLogs() {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	i, err := cli.ContainerLogs(context.Background(), "79c6fa382c330b9149e2d28d24f4d2c231cdb8cfc0710c2d268ccee13c5b24f8", types.ContainerLogsOptions{
-		ShowStderr: true,
-		ShowStdout: true,
-		Timestamps: false,
-		Follow:     true,
-		Tail:       "40",
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer i.Close()
-
-	hdr := make([]byte, 8)
-	for {
-		_, err := i.Read(hdr)
-		if err != nil {
-			log.Fatal(err)
-		}
-		var w io.Writer
-		switch hdr[0] {
-		case 1:
-			w = os.Stdout
-		default:
-			w = os.Stderr
-		}
-		count := binary.BigEndian.Uint32(hdr[4:])
-		dat := make([]byte, count)
-		_, err = i.Read(dat)
-		fmt.Fprint(w, string(dat))
-	}
-}
-
-//正式内容
-
-//检查镜像是否存在
-func (ds *dockerService) IsExistImage(imageName string) bool {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return false
-	}
-	defer cli.Close()
-	filter := filters.NewArgs()
-	filter.Add("reference", imageName)
-
-	list, err := cli.ImageList(context.Background(), types.ImageListOptions{Filters: filter})
-
-	if err == nil && len(list) > 0 {
-		return true
-	}
-
-	return false
-}
-
-//安装镜像
-func (ds *dockerService) DockerPullImage(imageName string, icon, name string) error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	out, err := cli.ImagePull(context.Background(), imageName, types.ImagePullOptions{})
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-	if err != nil {
-
-		return err
-	}
-	//io.Copy()
-	buf := make([]byte, 2048*4)
-	for {
-		n, err := out.Read(buf)
-		if err != nil {
-			if err != io.EOF {
-				fmt.Println("read error:", err)
-			}
-			break
-		}
-		if len(icon) > 0 && len(name) > 0 {
-			notify := notify.Application{}
-			notify.Icon = icon
-			notify.Name = name
-			notify.State = "PULLING"
-			notify.Type = "INSTALL"
-			notify.Finished = false
-			notify.Success = true
-			notify.Message = string(buf[:n])
-			MyService.Notify().SendInstallAppBySocket(notify)
-		}
-
-	}
-	return err
-}
-func (ds *dockerService) DockerContainerCopyCreate(info *types.ContainerJSON) (containerId string, err error) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return "", err
-	}
-	defer cli.Close()
-	container, err := cli.ContainerCreate(context.Background(), info.Config, info.HostConfig, &network.NetworkingConfig{info.NetworkSettings.Networks}, nil, info.Name)
-	if err != nil {
-		return "", err
-	}
-	return container.ID, err
-}
-
-//param imageName 镜像名称
-//param containerDbId 数据库的id
-//param port 容器内部主端口
-//param mapPort 容器主端口映射到外部的端口
-//param tcp 容器其他tcp端口
-//param udp 容器其他udp端口
-func (ds *dockerService) DockerContainerCreate(m model.CustomizationPostData, id string) (containerId string, err error) {
-	if len(m.NetworkModel) == 0 {
-		m.NetworkModel = "bridge"
-	}
-
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return "", err
-	}
-
-	defer cli.Close()
-	ports := make(nat.PortSet)
-	portMaps := make(nat.PortMap)
-	//	ports[nat.Port(fmt.Sprint(m.PortMap)+"/tcp")] = struct{}{}
-	//	if net != "host" {
-	//		portMaps[nat.Port(fmt.Sprint(m.Port)+"/tcp")] = []nat.PortBinding{{HostIP: "", HostPort: m.PortMap}}
-	//	}
-	//port := ""
-	for _, portMap := range m.Ports {
-		// if portMap.CommendPort == m.PortMap && portMap.Protocol == "tcp" || portMap.Protocol == "both" {
-		// 	port = portMap.ContainerPort
-		// }
-		if portMap.Protocol == "tcp" {
-
-			tContainer, _ := strconv.Atoi(portMap.ContainerPort)
-			if tContainer > 0 {
-				ports[nat.Port(portMap.ContainerPort+"/tcp")] = struct{}{}
-				if m.NetworkModel != "host" {
-					portMaps[nat.Port(portMap.ContainerPort+"/tcp")] = []nat.PortBinding{{HostPort: portMap.CommendPort}}
-				}
-			}
-		} else if portMap.Protocol == "both" {
-
-			tContainer, _ := strconv.Atoi(portMap.ContainerPort)
-			if tContainer > 0 {
-				ports[nat.Port(portMap.ContainerPort+"/tcp")] = struct{}{}
-				if m.NetworkModel != "host" {
-					portMaps[nat.Port(portMap.ContainerPort+"/tcp")] = []nat.PortBinding{{HostPort: portMap.CommendPort}}
-				}
-			}
-
-			uContainer, _ := strconv.Atoi(portMap.ContainerPort)
-			if uContainer > 0 {
-				ports[nat.Port(portMap.ContainerPort+"/udp")] = struct{}{}
-				if m.NetworkModel != "host" {
-					portMaps[nat.Port(portMap.ContainerPort+"/udp")] = []nat.PortBinding{{HostPort: portMap.CommendPort}}
-				}
-			}
-
-		} else {
-			uContainer, _ := strconv.Atoi(portMap.ContainerPort)
-			if uContainer > 0 {
-				ports[nat.Port(portMap.ContainerPort+"/udp")] = struct{}{}
-				if m.NetworkModel != "host" {
-					portMaps[nat.Port(portMap.ContainerPort+"/udp")] = []nat.PortBinding{{HostPort: portMap.CommendPort}}
-				}
-			}
-		}
-
-	}
-
-	var envArr []string
-	var showENV []string
-	showENV = append(showENV, "casaos")
-	for _, e := range m.Envs {
-		showENV = append(showENV, e.Name)
-		if strings.HasPrefix(e.Value, "$") {
-			envArr = append(envArr, e.Name+"="+env_helper.ReplaceDefaultENV(e.Value, MyService.System().GetTimeZone()))
-			continue
-		}
-		if len(e.Value) > 0 {
-			if e.Value == "port_map" {
-				envArr = append(envArr, e.Name+"="+m.PortMap)
-				continue
-			}
-			envArr = append(envArr, e.Name+"="+e.Value)
-		}
-	}
-
-	res := container.Resources{}
-	if m.CpuShares > 0 {
-		res.CPUShares = m.CpuShares
-	}
-	if m.Memory > 0 {
-		res.Memory = m.Memory << 20
-	}
-	for _, p := range m.Devices {
-		if len(p.Path) > 0 {
-			res.Devices = append(res.Devices, container.DeviceMapping{PathOnHost: p.Path, PathInContainer: p.ContainerPath, CgroupPermissions: "rwm"})
-		}
-	}
-	hostConfingBind := []string{}
-	// volumes bind
-	volumes := []mount.Mount{}
-	for _, v := range m.Volumes {
-		path := v.Path
-		if len(path) == 0 {
-			path = docker.GetDir(m.Label, v.Path)
-			if len(path) == 0 {
-				continue
-			}
-		}
-		path = strings.ReplaceAll(path, "$AppID", m.Label)
-		//reg1 := regexp.MustCompile(`([^<>/\\\|:""\*\?]+\.\w+$)`)
-		//result1 := reg1.FindAllStringSubmatch(path, -1)
-		//if len(result1) == 0 {
-		err = file.IsNotExistMkDir(path)
-		if err != nil {
-			loger.Error("Failed to create a folder", zap.Any("err", err))
-			continue
-		}
-		//}
-		//  else {
-		// 	err = file.IsNotExistCreateFile(path)
-		// 	if err != nil {
-		// 		ds.log.Error("mkdir error", err)
-		// 		continue
-		// 	}
-		// }
-
-		volumes = append(volumes, mount.Mount{
-			Type:   mount.TypeBind,
-			Source: path,
-			Target: v.ContainerPath,
-		})
-
-		hostConfingBind = append(hostConfingBind, v.Path+":"+v.ContainerPath)
-	}
-
-	rp := container.RestartPolicy{}
-
-	if len(m.Restart) > 0 {
-		rp.Name = m.Restart
-	}
-	// healthTest := []string{}
-	// if len(port) > 0 {
-	// 	healthTest = []string{"CMD-SHELL", "curl -f http://localhost:" + port + m.Index + " || exit 1"}
-	// }
-
-	// health := &container.HealthConfig{
-	// 	Test:        healthTest,
-	// 	StartPeriod: 0,
-	// 	Retries:     1000,
-	// }
-	// fmt.Print(health)
-	if len(m.HostName) == 0 {
-		m.HostName = m.Label
-	}
-
-	info, err := cli.ContainerInspect(context.Background(), id)
-	hostConfig := &container.HostConfig{}
-	config := &container.Config{}
-	config.Labels = map[string]string{}
-	if err == nil {
-		// info.HostConfig = &container.HostConfig{}
-		// info.Config = &container.Config{}
-		// info.NetworkSettings = &types.NetworkSettings{}
-		hostConfig = info.HostConfig
-		config = info.Config
-	} else {
-		config.Cmd = m.Cmd
-		config.Image = m.Image
-		config.Env = envArr
-		config.Hostname = m.HostName
-		config.ExposedPorts = ports
-	}
-
-	config.Labels["origin"] = m.Origin
-	config.Labels["casaos"] = "casaos"
-	config.Labels["web"] = m.PortMap
-	config.Labels["icon"] = m.Icon
-	config.Labels["desc"] = m.Description
-	config.Labels["index"] = m.Index
-	config.Labels["custom_id"] = m.CustomId
-	config.Labels["show_env"] = strings.Join(showENV, ",")
-	config.Labels["protocol"] = m.Protocol
-	config.Labels["host"] = m.Host
-	config.Labels["name"] = m.Label
-	//container, err := cli.ContainerCreate(context.Background(), info.Config, info.HostConfig, &network.NetworkingConfig{info.NetworkSettings.Networks}, nil, info.Name)
-
-	hostConfig.Mounts = volumes
-	hostConfig.Privileged = m.Privileged
-	hostConfig.CapAdd = m.CapAdd
-	hostConfig.NetworkMode = container.NetworkMode(m.NetworkModel)
-	hostConfig.RestartPolicy = rp
-	hostConfig.Resources = res
-	//hostConfig := &container.HostConfig{Resources: res, Mounts: volumes, RestartPolicy: rp, NetworkMode: , Privileged: m.Privileged, CapAdd: m.CapAdd}
-	//if net != "host" {
-
-	hostConfig.PortBindings = portMaps
-	//}
-	containerDb, err := cli.ContainerCreate(context.Background(),
-		config,
-		hostConfig,
-		&network.NetworkingConfig{EndpointsConfig: map[string]*network.EndpointSettings{m.NetworkModel: {NetworkID: "", Aliases: []string{}}}},
-		nil,
-		m.ContainerName)
-	if err != nil {
-		return "", err
-	}
-	return containerDb.ID, err
-}
-
-//删除容器
-func (ds *dockerService) DockerContainerRemove(name string, update bool) error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	err = cli.ContainerRemove(context.Background(), name, types.ContainerRemoveOptions{})
-
-	//路径处理
-	if !update {
-		path := docker.GetDir(name, "/config")
-		if !file.CheckNotExist(path) {
-			file.RMDir(path)
-		}
-	}
-
-	if err != nil {
-		return err
-	}
-
-	return err
-}
-
-//删除镜像
-func (ds *dockerService) DockerImageRemove(name string) error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	imageList, err := cli.ImageList(context.Background(), types.ImageListOptions{})
-
-	imageId := ""
-
-Loop:
-	for _, ig := range imageList {
-		for _, i := range ig.RepoTags {
-			if i == name {
-				imageId = ig.ID
-				break Loop
-			}
-		}
-	}
-	_, err = cli.ImageRemove(context.Background(), imageId, types.ImageRemoveOptions{})
-	return err
-}
-
-func DockerImageRemove(name string) error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	imageList, err := cli.ImageList(context.Background(), types.ImageListOptions{})
-	imageId := ""
-
-Loop:
-	for _, ig := range imageList {
-		fmt.Println(ig.RepoDigests)
-		fmt.Println(ig.Containers)
-		for _, i := range ig.RepoTags {
-			if i == name {
-				imageId = ig.ID
-				break Loop
-			}
-		}
-	}
-	_, err = cli.ImageRemove(context.Background(), imageId, types.ImageRemoveOptions{})
-	return err
-}
-
-//停止镜像
-func (ds *dockerService) DockerContainerStop(id string) error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	err = cli.ContainerStop(context.Background(), id, nil)
-	return err
-}
-
-//启动容器
-func (ds *dockerService) DockerContainerStart(name string) error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	err = cli.ContainerStart(context.Background(), name, types.ContainerStartOptions{})
-	return err
-}
-
-//查看日志
-func (ds *dockerService) DockerContainerLog(name string) (string, error) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return "", err
-	}
-	defer cli.Close()
-	body, err := cli.ContainerLogs(context.Background(), name, types.ContainerLogsOptions{ShowStderr: true, ShowStdout: true})
-	if err != nil {
-		return "", err
-	}
-
-	defer body.Close()
-	content, err := ioutil.ReadAll(body)
-	if err != nil {
-		return "", err
-	}
-	return string(content), nil
-}
-
-func DockerContainerStats1() error {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	dss, err := cli.ContainerStats(context.Background(), "dockermysql", false)
-	if err != nil {
-		return err
-	}
-	defer dss.Body.Close()
-	sts, err := ioutil.ReadAll(dss.Body)
-	if err != nil {
-		return err
-	}
-	fmt.Println(string(sts))
-	return nil
-}
-
-//获取容器状态
-func (ds *dockerService) DockerContainerStats(name string) (string, error) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return "", err
-	}
-	defer cli.Close()
-	dss, err := cli.ContainerStats(context.Background(), name, false)
-	if err != nil {
-		return "", err
-	}
-	defer dss.Body.Close()
-	sts, err := ioutil.ReadAll(dss.Body)
-	if err != nil {
-		return "", err
-	}
-	return string(sts), nil
-}
-
-//备份容器
-func (ds *dockerService) DockerContainerCommit(name string) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		fmt.Println(err)
-	}
-	defer cli.Close()
-	d, err := cli.ContainerInspect(context.Background(), name)
-	dss, err := cli.ContainerCommit(context.Background(), name, types.ContainerCommitOptions{Reference: "test", Config: d.Config})
-	if err != nil {
-		fmt.Println(err)
-	}
-	fmt.Println(dss)
-}
-
-func (ds *dockerService) DockerListByName(name string) (*types.Container, error) {
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	defer cli.Close()
-	filter := filters.NewArgs()
-	filter.Add("name", name)
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{Filters: filter})
-	if err != nil {
-		return &types.Container{}, err
-	}
-	if len(containers) == 0 {
-		return &types.Container{}, errors.New("not found")
-	}
-	return &containers[0], nil
-}
-
-func (ds *dockerService) DockerListByImage(image, version string) (*types.Container, error) {
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	defer cli.Close()
-	filter := filters.NewArgs()
-	filter.Add("ancestor", image+":"+version)
-	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{Filters: filter})
-	if err != nil {
-		return nil, err
-	}
-	if len(containers) == 0 {
-		return nil, nil
-	}
-	return &containers[0], nil
-}
-
-//获取容器详情
-func (ds *dockerService) DockerContainerInfo(name string) (*types.ContainerJSON, error) {
-
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return &types.ContainerJSON{}, err
-	}
-	defer cli.Close()
-	d, err := cli.ContainerInspect(context.Background(), name)
-	if err != nil {
-		return &types.ContainerJSON{}, err
-	}
-	return &d, nil
-}
-
-//更新容器
-//param shares cpu优先级
-//param containerDbId 数据库的id
-//param port 容器内部主端口
-//param mapPort 容器主端口映射到外部的端口
-//param tcp 容器其他tcp端口
-//param udp 容器其他udp端口
-func (ds *dockerService) DockerContainerUpdate(m model.CustomizationPostData, id string) (err error) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	//重启策略
-	rp := container.RestartPolicy{
-		Name:              "",
-		MaximumRetryCount: 0,
-	}
-	if len(m.Restart) > 0 {
-		rp.Name = m.Restart
-	}
-	res := container.Resources{}
-
-	if m.Memory > 0 {
-		res.Memory = m.Memory * 1024 * 1024
-		res.MemorySwap = -1
-	}
-	if m.CpuShares > 0 {
-		res.CPUShares = m.CpuShares
-	}
-	for _, p := range m.Devices {
-		res.Devices = append(res.Devices, container.DeviceMapping{PathOnHost: p.Path, PathInContainer: p.ContainerPath, CgroupPermissions: "rwm"})
-	}
-	_, err = cli.ContainerUpdate(context.Background(), id, container.UpdateConfig{RestartPolicy: rp, Resources: res})
-	if err != nil {
-		return err
-	}
-
-	return
-}
-
-//更新容器名称
-//param name 容器名称
-//param id 老的容器名称
-func (ds *dockerService) DockerContainerUpdateName(name, id string) (err error) {
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-
-	err = cli.ContainerRename(context.Background(), id, name)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-//获取网络列表
-func (ds *dockerService) DockerNetworkModelList() []types.NetworkResource {
-
-	cli, _ := client2.NewClientWithOpts(client2.FromEnv)
-	defer cli.Close()
-	networks, _ := cli.NetworkList(context.Background(), types.NetworkListOptions{})
-	return networks
-}
-func NewDockerService() DockerService {
-	return &dockerService{rootDir: command2.ExecResultStr(`source ./shell/helper.sh ;GetDockerRootDir`)}
-}
-
-//   ---------------------------------------test------------------------------------
-//func ServiceCreate() {
-//	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-//	r, err := cli.ServiceCreate(context.Background(), swarm.ServiceSpec{}, types.ServiceCreateOptions{})
-//	if err != nil {
-//		fmt.Println("error", err)
-//	}
-//
-//
-//}
-
-func Containerd() {
-	// create a new client connected to the default socket path for containerd
-	cli, err := containerd.New("/run/containerd/containerd.sock")
-	if err != nil {
-		fmt.Println("111")
-		fmt.Println(err)
-	}
-	defer cli.Close()
-
-	// create a new context with an "example" namespace
-	ctx := namespaces.WithNamespace(context.Background(), "default")
-
-	// pull the redis image from DockerHub
-	image, err := cli.Pull(ctx, "docker.io/library/busybox:latest", containerd.WithPullUnpack)
-	if err != nil {
-		fmt.Println("222")
-		fmt.Println(err)
-	}
-
-	// create a container
-	container, err := cli.NewContainer(
-		ctx,
-		"test1",
-		containerd.WithImage(image),
-		containerd.WithNewSnapshot("redis-server-snapshot1", image),
-		containerd.WithNewSpec(oci.WithImageConfig(image)),
-	)
-
-	if err != nil {
-		fmt.Println(err)
-	}
-	defer container.Delete(ctx, containerd.WithSnapshotCleanup)
-
-	// create a task from the container
-	task, err := container.NewTask(ctx, cio.NewCreator(cio.WithStdio))
-	if err != nil {
-		fmt.Println(err)
-	}
-	defer task.Delete(ctx)
-
-	// make sure we wait before calling start
-	exitStatusC, err := task.Wait(ctx)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	// call start on the task to execute the redis server
-	if err = task.Start(ctx); err != nil {
-		fmt.Println(err)
-	}
-
-	fmt.Println("执行完成等待")
-	// sleep for a lil bit to see the logs
-	time.Sleep(3 * time.Second)
-
-	// kill the process and get the exit status
-	if err = task.Kill(ctx, syscall.SIGTERM); err != nil {
-		fmt.Println(err)
-	}
-
-	// wait for the process to fully exit and print out the exit status
-
-	status := <-exitStatusC
-	code, _, err := status.Result()
-	if err != nil {
-		fmt.Println(err)
-	}
-	fmt.Printf("redis-server exited with status: %d\n", code)
-
-}

service/docker_base/common.go

@@ -1,24 +0,0 @@
-package docker_base
-
-import "github.com/IceWhaleTech/CasaOS/model"
-
-//过滤mysql关键字
-func MysqlFilter(c MysqlConfig, envs model.EnvArray) model.EnvArray {
-	for i := 0; i < len(envs); i++ {
-		switch envs[i].Value {
-		case "$MYSQL_HOST":
-			envs[i].Value = c.DataBaseHost
-		case "$MYSQL_PORT":
-			envs[i].Value = c.DataBasePort
-		case "$MYSQL_USERNAME":
-			envs[i].Value = c.DataBaseUser
-		case "$MYSQL_PASSWORD":
-			envs[i].Value = c.DataBasePassword
-		case "$MYSQL_DBNAME":
-			envs[i].Value = c.DataBaseDB
-		case "$MYSQL_HOST_AND_PORT":
-			envs[i].Value = c.DataBaseHost + ":" + c.DataBasePort
-		}
-	}
-	return envs
-}

service/docker_base/model.go

@@ -1,9 +0,0 @@
-package docker_base
-
-type MysqlConfig struct {
-	DataBaseHost     string `json:"database_host"`
-	DataBasePort     string `json:"database_port"`
-	DataBaseUser     string `json:"database_user"`
-	DataBasePassword string `json:"data_base_password"`
-	DataBaseDB       string `json:"data_base_db"`
-}

service/docker_base/mysql.go

@@ -1,93 +0,0 @@
-package docker_base
-
-import (
-	"context"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/network"
-	client2 "github.com/docker/docker/client"
-	"time"
-)
-
-//创建一个mysql数据库
-func MysqlCreate(mysqlConfig MysqlConfig, dbId string, cpuShares int64, memory int64) (string, error) {
-	const imageName = "mysql"
-	const imageVersion = "8"
-	const imageNet = "oasis"
-
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return "", err
-	}
-	defer cli.Close()
-	_, err = cli.ImagePull(context.Background(), imageName+":"+imageVersion, types.ImagePullOptions{})
-
-	isExist := true
-	//检查到镜像才继续
-	for isExist {
-		filter := filters.NewArgs()
-		filter.Add("before", imageName+":"+imageVersion)
-		list, e := cli.ImageList(context.Background(), types.ImageListOptions{Filters: filter})
-		if e == nil && len(list) > 0 {
-			isExist = false
-		}
-		time.Sleep(time.Second)
-	}
-
-	var envArr = []string{"MYSQL_ROOT_PASSWORD=" + mysqlConfig.DataBasePassword, "MYSQL_DATABASE=" + mysqlConfig.DataBaseDB}
-
-	res := container.Resources{}
-	if cpuShares > 0 {
-		res.CPUShares = cpuShares
-	}
-	if memory > 0 {
-		res.Memory = memory << 20
-	}
-
-	rp := container.RestartPolicy{}
-
-	rp.Name = "always"
-
-	config := &container.Config{
-		Image:  imageName,
-		Labels: map[string]string{"version": imageVersion, "author": "official"},
-		Env:    envArr,
-	}
-	hostConfig := &container.HostConfig{Resources: res, RestartPolicy: rp, NetworkMode: container.NetworkMode(imageNet)}
-
-	containerCreate, err := cli.ContainerCreate(context.Background(),
-		config,
-		hostConfig,
-		&network.NetworkingConfig{EndpointsConfig: map[string]*network.EndpointSettings{imageNet: {NetworkID: ""}}},
-		nil,
-		dbId)
-
-	containerId := containerCreate.ID
-
-	//启动容器
-	err = cli.ContainerStart(context.Background(), dbId, types.ContainerStartOptions{})
-	if err != nil {
-		return containerId, err
-	}
-
-	return containerId, nil
-
-}
-
-func MysqlDelete(dbId string) error {
-
-	cli, err := client2.NewClientWithOpts(client2.FromEnv)
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	err = cli.ContainerStop(context.Background(), dbId, nil)
-	if err != nil {
-		return err
-	}
-
-	err = cli.ContainerRemove(context.Background(), dbId, types.ContainerRemoveOptions{})
-	return err
-
-}

service/docker_test.go

@@ -1,50 +0,0 @@
-package service
-
-import (
-	"fmt"
-	"testing"
-)
-
-//func TestDockerImageInfo(t *testing.T) {
-//	//DockerImageInfo()
-//
-//	address, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:0", "0.0.0.0"))
-//	if err != nil {
-//		fmt.Println(0, err)
-//	}
-//
-//	listener, err := net.ListenTCP("tcp", address)
-//	if err != nil {
-//		fmt.Println(0, err)
-//	}
-//
-//	defer listener.Close()
-//	fmt.Println(listener.Addr().(*net.TCPAddr).Port, nil)
-//
-//}
-
-//func TestDockerNetwork(t *testing.T) {
-//	DockerNetwork()
-//}
-//
-//func TestDockerPull(t *testing.T) {
-//	DockerPull()
-//}
-//
-//func TestDockerLog(t *testing.T) {
-//	DockerLog()
-//}
-//func TestDockerLogs(t *testing.T) {
-//	DockerLogs()
-//}
-
-func TestDockerContainerStats(t *testing.T) {
-	fmt.Println(DockerContainerStats1())
-}
-
-//func TestDockerImageRemove(t *testing.T) {
-//	host, domain, tld := gotld.GetSubdomain("aaa.liru-05.top", 1)
-//	fmt.Println(host)
-//	fmt.Println(domain)
-//	fmt.Println(tld)
-//}

service/file.go

@@ -19,9 +19,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/IceWhaleTech/CasaOS-Common/utils/logger"
 	"github.com/IceWhaleTech/CasaOS/model"
 	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
-	"github.com/IceWhaleTech/CasaOS/pkg/utils/loger"
 	"go.uber.org/zap"
 )
 
@@ -78,8 +78,8 @@ func (w *writer) Write(p []byte) (n int, err error) {
 		return w.w.Write(p)
 	}
 }
-func FileOperate(k string) {
 
+func FileOperate(k string) {
 	list, ok := FileQueue.Load(k)
 	if !ok {
 		return
@@ -103,10 +103,10 @@ func FileOperate(k string) {
 			}
 			err := os.Rename(v.From, temp.To+"/"+lastPath)
 			if err != nil {
-				loger.Error("file move error", zap.Any("err", err))
+				logger.Error("file move error", zap.Any("err", err))
 				err = file.MoveFile(v.From, temp.To+"/"+lastPath)
 				if err != nil {
-					loger.Error("MoveFile error", zap.Any("err", err))
+					logger.Error("MoveFile error", zap.Any("err", err))
 					continue
 				}
 
@@ -152,7 +152,6 @@ func CheckFileStatus() {
 			}
 			temp := item.(model.FileOperate)
 			for i := 0; i < len(temp.Item); i++ {
-
 				if !temp.Item[i].Finished {
 					size, err := file.GetFileOrDirSize(temp.To + "/" + filepath.Base(temp.Item[i].From))
 					if err != nil {
@@ -166,7 +165,6 @@ func CheckFileStatus() {
 				} else {
 					total += temp.Item[i].ProcessedSize
 				}
-
 			}
 			temp.ProcessedSize = total
 			FileQueue.Store(v, temp)

service/model/o_container.go

@@ -1,78 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-05-13 18:15:46
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-13 10:56:34
- * @FilePath: /CasaOS/service/model/o_container.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package model
-
-const CONTAINERTABLENAME = "o_container"
-
-//Soon to be removed
-type AppListDBModel struct {
-	CustomId string `gorm:"column:custom_id;primary_key" json:"custom_id"`
-	Title    string `json:"title"`
-	//	ScreenshotLink model.Strings `gorm:"type:json" json:"screenshot_link,omitempty"`
-	ScreenshotLink string `json:"screenshot_link"`
-	Slogan         string `json:"slogan"`
-	Description    string `json:"description"`
-	//Tags           model.Strings `gorm:"type:json" json:"tags"`
-	Tags        string `json:"tags"`
-	Icon        string `json:"icon"`
-	Version     string `json:"version"`
-	ContainerId string `json:"container_id,omitempty"`
-	Image       string `json:"image,omitempty"`
-	Index       string `json:"index"`
-	CreatedAt   string `gorm:"<-:create;autoCreateTime" json:"created_at"`
-	UpdatedAt   string `gorm:"<-:create;<-:update;autoUpdateTime" json:"updated_at"`
-	//Port           string           `json:"port,omitempty"`
-	PortMap    string `json:"port_map"`
-	Label      string `json:"label"`
-	EnableUPNP bool   `json:"enable_upnp"`
-	Envs       string `json:"envs"`
-	Ports      string `json:"ports"`
-	Volumes    string `json:"volumes"`
-	Devices    string `json:"devices"`
-	//Envs      []model.Env      `json:"envs"`
-	//Ports     []model.PortMap  `gorm:"type:json" json:"ports"`
-	//Volumes   []model.PathMap  `gorm:"type:json" json:"volumes"`
-	//Devices   []model.PathMap  `gorm:"type:json" json:"device"`
-	Position  bool   `json:"position"`
-	NetModel  string `json:"net_model"`
-	CpuShares int64  `json:"cpu_shares"`
-	Memory    int64  `json:"memory"`
-	Restart   string `json:"restart"`
-	//Rely      model.MapStrings `gorm:"type:json" json:"rely"` //[{"mysql":"id"},{"mysql":"id"}]
-	Origin     string `json:"origin"`
-	HostName   string `json:"host_name"`
-	Privileged bool   `json:"privileged"`
-	CapAdd     string `json:"cap_add"`
-	Cmd        string `gorm:"type:json" json:"cmd"`
-}
-
-func (p *AppListDBModel) TableName() string {
-	return "o_container"
-}
-
-type MyAppList struct {
-	Id       string `json:"id"`
-	Name     string `json:"name"`
-	Icon     string `json:"icon"`
-	State    string `json:"state"`
-	CustomId string `gorm:"column:custom_id;primary_key" json:"custom_id"`
-	Index    string `json:"index"`
-	//Order    string `json:"order"`
-	Port   string `json:"port"`
-	Slogan string `json:"slogan"`
-	Type   string `json:"type"`
-	//Rely       model.MapStrings `json:"rely"` //[{"mysql":"id"},{"mysql":"id"}]
-	Image    string `json:"image"`
-	Volumes  string `json:"volumes"`
-	Latest   bool   `json:"latest"`
-	Host     string `json:"host"`
-	Protocol string `json:"protocol"`
-}

service/model/o_disk.go

@@ -1,25 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.org
- * @Date: 2021-12-07 17:14:41
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-08-17 18:46:43
- * @FilePath: /CasaOS/service/model/o_disk.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package model
-
-//SerialAdvanced Technology Attachment (STAT)
-type SerialDisk struct {
-	Id         uint   `gorm:"column:id;primary_key" json:"id"`
-	UUID       string `json:"uuid"`
-	Path       string `json:"path"`
-	State      int    `json:"state"`
-	MountPoint string `json:"mount_point"`
-	CreatedAt  int64  `json:"created_at"`
-}
-
-func (p *SerialDisk) TableName() string {
-	return "o_disk"
-}

service/model/o_rely.go

@@ -1,33 +1,17 @@
 package model
 
 import (
-	"database/sql/driver"
-	"encoding/json"
-	"github.com/IceWhaleTech/CasaOS/service/docker_base"
 	"time"
 )
 
 type RelyDBModel struct {
-	Id                uint         `gorm:"column:id;primary_key" json:"id"`
-	CustomId          string       ` json:"custom_id"`
-	ContainerCustomId string       `json:"container_custom_id"`
-	Config            MysqlConfigs `json:"config"`
-	ContainerId       string       `json:"container_id,omitempty"`
-	Type              int          `json:"type"` //目前暂未使用
-	CreatedAt         time.Time    `gorm:"<-:create" json:"created_at"`
-	UpdatedAt         time.Time    `gorm:"<-:create;<-:update" json:"updated_at"`
-}
-
-/****************使gorm支持[]string结构*******************/
-type MysqlConfigs docker_base.MysqlConfig
-
-func (c MysqlConfigs) Value() (driver.Value, error) {
-	b, err := json.Marshal(c)
-	return string(b), err
-}
-
-func (c *MysqlConfigs) Scan(input interface{}) error {
-	return json.Unmarshal(input.([]byte), c)
+	Id                uint      `gorm:"column:id;primary_key" json:"id"`
+	CustomId          string    ` json:"custom_id"`
+	ContainerCustomId string    `json:"container_custom_id"`
+	ContainerId       string    `json:"container_id,omitempty"`
+	Type              int       `json:"type"` // 目前暂未使用
+	CreatedAt         time.Time `gorm:"<-:create" json:"created_at"`
+	UpdatedAt         time.Time `gorm:"<-:create;<-:update" json:"updated_at"`
 }
 
 /****************使gorm支持[]string结构*******************/

service/model/o_user.go

@@ -1,31 +0,0 @@
-/*
- * @Author: LinkLeong link@icewhale.com
- * @Date: 2022-05-13 18:15:46
- * @LastEditors: LinkLeong
- * @LastEditTime: 2022-07-11 17:57:00
- * @FilePath: /CasaOS/service/model/o_user.go
- * @Description:
- * @Website: https://www.casaos.io
- * Copyright (c) 2022 by icewhale, All Rights Reserved.
- */
-package model
-
-import "time"
-
-//Soon to be removed
-type UserDBModel struct {
-	Id          int       `gorm:"column:id;primary_key" json:"id"`
-	Username    string    `json:"username"`
-	Password    string    `json:"password,omitempty"`
-	Role        string    `json:"role"`
-	Email       string    `json:"email"`
-	Nickname    string    `json:"nickname"`
-	Avatar      string    `json:"avatar"`
-	Description string    `json:"description"`
-	CreatedAt   time.Time `gorm:"<-:create;autoCreateTime" json:"created_at,omitempty"`
-	UpdatedAt   time.Time `gorm:"<-:create;<-:update;autoUpdateTime" json:"updated_at,omitempty"`
-}
-
-func (p *UserDBModel) TableName() string {
-	return "o_users"
-}