diff --git a/.asf.yaml b/.asf.yaml index 3f53bf5883..2cc4b1d1b4 100644 --- a/.asf.yaml +++ b/.asf.yaml @@ -18,9 +18,8 @@ github: features: issues: true - # Enable wiki for documentation wiki: true - # Enable projects for project management boards + # Enable projects for project (task)management boards projects: true discussions: true description: A graph database that supports more than 100+ billion data, high performance and scalability (Include OLTP Engine & REST-API & Backends) @@ -46,11 +45,12 @@ github: required_pull_request_reviews: dismiss_stale_reviews: true require_code_owner_reviews: false - required_approving_review_count: 2 + required_approving_review_count: 1 # (for non-committer): assign/edit/close issues & PR, without write access to the code collaborators: - - Pengzna - haohao0103 + - kenssa4eedfd + - Tsukilc # refer https://cwiki.apache.org/confluence/display/INFRA/Git+-+.asf.yaml+features#Git.asf.yamlfeatures-Notificationsettingsforrepositories notifications: diff --git a/hugegraph-commons/hugegraph-dist/scripts/dependency/regenerate_known_dependencies.sh b/.dockerignore similarity index 57% rename from hugegraph-commons/hugegraph-dist/scripts/dependency/regenerate_known_dependencies.sh rename to .dockerignore index 91f8b986ad..ee61478a15 100644 --- a/hugegraph-commons/hugegraph-dist/scripts/dependency/regenerate_known_dependencies.sh +++ b/.dockerignore @@ -1,4 +1,3 @@ -#!/usr/bin/env bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with @@ -16,18 +15,46 @@ # limitations under the License. # -BASE_PATH=$(cd "$(dirname "$0")" || exit; pwd) -DEP_PATH=$BASE_PATH/all_dependencies -FILE_NAME=${1:-known-dependencies.txt} +# IMPORTANT: .dockerignore does NOT inherit .gitignore — patterns must be restated. -if [[ -d $DEP_PATH ]]; then - echo "rm -r -f DEP_PATH" - rm -r -f "$DEP_PATH" -fi +# Build output +**/target/ -cd "$BASE_PATH"/../../../ || exit +# Pre-extracted release dirs / archives +apache-hugegraph-*/ +**/*.tar +**/*.tar.gz +**/*.zip +**/*.war -mvn dependency:copy-dependencies -DincludeScope=runtime -DoutputDirectory="$DEP_PATH" +# IDE / OS +.idea/ +.vscode/ +**/*.iml +**/*.iws +**/.DS_Store -ls "$DEP_PATH" | egrep -v "^hugegraph|hubble" | sort -n > "$BASE_PATH"/"$FILE_NAME" -rm -r -f "$DEP_PATH" +# Build / runtime artifacts +**/logs/ +**/*.log +**/*.class +**/gen-java/ +**/upload-files/ +**/build/ +**/node_modules/ + +# Env files +.env.local +.env.*.local + +# Git internals +.git +.gitignore +.gitattributes +.github + +# Compose / docs not needed in build context +**/docker-compose*.yml +**/docker-compose*.yaml +**/*.md +docs/ diff --git a/hugegraph-commons/hugegraph-dist/scripts/dependency/check_dependencies.sh b/.github/workflows/docker-build-ci.yml similarity index 55% rename from hugegraph-commons/hugegraph-dist/scripts/dependency/check_dependencies.sh rename to .github/workflows/docker-build-ci.yml index 642c455aa9..2d88b72e7a 100644 --- a/hugegraph-commons/hugegraph-dist/scripts/dependency/check_dependencies.sh +++ b/.github/workflows/docker-build-ci.yml @@ -1,4 +1,3 @@ -#!/usr/bin/env bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with @@ -16,17 +15,34 @@ # limitations under the License. # -BASE_PATH=$(cd "$(dirname "$0")" || exit; pwd) +name: "Docker Build CI" -# check whether there are new third-party dependencies by diff command, -# diff generated 'current-dependencies.txt' file with 'known-dependencies.txt' file. -diff -w -B -U0 <(sort < "${BASE_PATH}"/known-dependencies.txt) \ - <(sort < "${BASE_PATH}"/current-dependencies.txt) > "${BASE_PATH}"/result.txt +on: + push: + branches: + - master + - 'release-*' + pull_request: + paths: + - '**/Dockerfile*' + - '.dockerignore' -# if has new third-party,the Action will fail and print diff -if [ -s "${BASE_PATH}"/result.txt ]; then - cat "${BASE_PATH}"/result.txt - exit 1 -else - echo 'All third dependencies is known!' -fi +jobs: + docker-build: + runs-on: ubuntu-24.04 + strategy: + fail-fast: false + matrix: + dockerfile: + - hugegraph-pd/Dockerfile + - hugegraph-store/Dockerfile + - hugegraph-server/Dockerfile + - hugegraph-server/Dockerfile-hstore + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Build ${{ matrix.dockerfile }} + run: | + docker build -f ${{ matrix.dockerfile }} . diff --git a/.github/workflows/pd-store-ci.yml b/.github/workflows/pd-store-ci.yml index d4f2ea382f..29ac9c3ac8 100644 --- a/.github/workflows/pd-store-ci.yml +++ b/.github/workflows/pd-store-ci.yml @@ -52,6 +52,11 @@ jobs: mvn -U -ntp dependency:get -Dartifact=org.apache.hugegraph:hugegraph-struct:$REVISION fi + - name: Run hugegraph-struct test + if: ${{ hashFiles('hugegraph-struct/pom.xml') != '' }} + run: | + mvn -U -ntp -pl hugegraph-struct test + pd: needs: struct runs-on: ubuntu-latest @@ -102,6 +107,12 @@ jobs: run: | mvn clean package -U -Dmaven.javadoc.skip=true -Dmaven.test.skip=true -ntp --fail-at-end + - name: Run start-hugegraph-pd.sh foreground mode tests + run: | + VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) + PD_DIR=hugegraph-pd/apache-hugegraph-pd-$VERSION/ + $TRAVIS_DIR/test-start-hugegraph-pd.sh $PD_DIR + - name: Prepare env and service run: | $TRAVIS_DIR/start-pd.sh @@ -158,6 +169,12 @@ jobs: run: | mvn clean package -U -Dmaven.javadoc.skip=true -Dmaven.test.skip=true -ntp --fail-at-end + - name: Run start-hugegraph-store.sh foreground mode tests + run: | + VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) + STORE_DIR=hugegraph-store/apache-hugegraph-store-$VERSION/ + $TRAVIS_DIR/test-start-hugegraph-store.sh $STORE_DIR + - name: Prepare env and service run: | $TRAVIS_DIR/start-pd.sh diff --git a/.github/workflows/rerun-ci.yml b/.github/workflows/rerun-ci.yml new file mode 100644 index 0000000000..3fdd4c0f56 --- /dev/null +++ b/.github/workflows/rerun-ci.yml @@ -0,0 +1,85 @@ +name: "Rerun CI" + +on: + workflow_run: + workflows: + - "HugeGraph-Server CI" + - "HugeGraph-Commons CI" + - "HugeGraph-PD & Store & Hstore CI" + - "Cluster Test CI" + types: + - completed + +permissions: {} + +env: + MAX_RERUNS: '2' + RETRY_DELAY_SECONDS: '180' + +jobs: + decide-rerun-action: + if: ${{ github.event.workflow_run.conclusion == 'failure' }} + runs-on: ubuntu-latest + outputs: + action: ${{ steps.decision.outputs.action }} + steps: + - name: Decide rerun action + id: decision + env: + WORKFLOW_NAME: ${{ github.event.workflow_run.name }} + RUN_ID: ${{ github.event.workflow_run.id }} + RUN_ATTEMPT: ${{ github.event.workflow_run.run_attempt }} + EVENT_NAME: ${{ github.event.workflow_run.event }} + HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }} + run: | + set -euo pipefail + + action="skip" + reason="unsupported event: $EVENT_NAME" + + if [[ "$EVENT_NAME" == "push" || "$EVENT_NAME" == "pull_request" ]]; then + if (( RUN_ATTEMPT > MAX_RERUNS )); then + reason="retry limit reached" + else + action="rerun" + reason="within retry limit" + fi + fi + + { + echo "action=$action" + echo "reason=$reason" + } >> "$GITHUB_OUTPUT" + + { + echo "### Rerun CI decision" + echo "" + echo "- Workflow: $WORKFLOW_NAME" + echo "- Source event: $EVENT_NAME" + echo "- Head branch: $HEAD_BRANCH" + echo "- Run ID: $RUN_ID" + echo "- Current attempt: $RUN_ATTEMPT" + echo "- Max automatic reruns: $MAX_RERUNS" + echo "- Delay seconds: $RETRY_DELAY_SECONDS" + echo "- Action: $action" + echo "- Reason: $reason" + } >> "$GITHUB_STEP_SUMMARY" + + rerun-failed-jobs: + needs: decide-rerun-action + if: needs.decide-rerun-action.outputs.action == 'rerun' + permissions: + actions: write + contents: read + runs-on: ubuntu-latest + steps: + - name: Wait before rerun + run: | + sleep "$RETRY_DELAY_SECONDS" + + - name: Rerun failed jobs + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + GH_REPO: ${{ github.repository }} + run: | + gh run rerun ${{ github.event.workflow_run.id }} --failed diff --git a/.github/workflows/server-ci.yml b/.github/workflows/server-ci.yml index f91bd809a3..20619797cc 100644 --- a/.github/workflows/server-ci.yml +++ b/.github/workflows/server-ci.yml @@ -70,6 +70,14 @@ jobs: run: | mvn clean compile -U -Dmaven.javadoc.skip=true -ntp + - name: Run start-hugegraph.sh foreground mode tests + if: ${{ env.BACKEND == 'rocksdb' }} + run: | + mvn package -Dmaven.test.skip=true -pl hugegraph-server/hugegraph-dist -am -ntp + VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) + SERVER_DIR=hugegraph-server/apache-hugegraph-server-$VERSION/ + $TRAVIS_DIR/test-start-hugegraph.sh $SERVER_DIR + - name: Run unit test run: | $TRAVIS_DIR/run-unit-test.sh $BACKEND @@ -100,3 +108,76 @@ jobs: with: token: ${{ secrets.CODECOV_TOKEN }} file: ${{ env.REPORT_DIR }}/*.xml + + build-server-macos-rocksdb: + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - os: macos-15-intel + server_java_options: '' + - os: macos-15 + server_java_options: '-Xms512m -Xmx2g' + env: + USE_STAGE: 'false' # Whether to include the stage repository. + TRAVIS_DIR: hugegraph-server/hugegraph-dist/src/assembly/travis + REPORT_DIR: target/site/jacoco + BACKEND: rocksdb + JAVA_VERSION: '11' + SERVER_JAVA_OPTIONS: ${{ matrix.server_java_options }} + + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + fetch-depth: 5 + + - name: Install Java ${{ env.JAVA_VERSION }} + uses: actions/setup-java@v4 + with: + java-version: ${{ env.JAVA_VERSION }} + distribution: 'zulu' + + - name: Cache Maven packages + uses: actions/cache@v4 + with: + path: ~/.m2 + key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-m2 + + - name: Use staged maven repo settings + if: ${{ env.USE_STAGE == 'true' }} + run: | + cp $HOME/.m2/settings.xml /tmp/settings.xml + cp -vf .github/configs/settings.xml $HOME/.m2/settings.xml && cat $HOME/.m2/settings.xml + + - name: Compile + run: | + mvn clean compile -pl hugegraph-server/hugegraph-test -am -U -Dmaven.javadoc.skip=true -ntp + + - name: Run RocksDB core test + run: | + $TRAVIS_DIR/run-core-test.sh $BACKEND + + - name: Run RocksDB API test + run: | + $TRAVIS_DIR/run-api-test.sh $BACKEND $REPORT_DIR + + - name: Show server log on failure + if: failure() + run: | + VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) + SERVER_DIR=hugegraph-server/apache-hugegraph-server-$VERSION/ + if [ -f "$SERVER_DIR/logs/hugegraph-server.log" ]; then + tail -n 200 "$SERVER_DIR/logs/hugegraph-server.log" + fi + + - name: Stop RocksDB server + if: always() + run: | + VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) + SERVER_DIR=hugegraph-server/apache-hugegraph-server-$VERSION/ + if [ -f "$SERVER_DIR/bin/pid" ]; then + $TRAVIS_DIR/stop-server.sh $SERVER_DIR || true + fi diff --git a/.gitignore b/.gitignore index f9670e332f..e27322b73a 100644 --- a/.gitignore +++ b/.gitignore @@ -91,6 +91,11 @@ hs_err_pid* hugegraph-server/hugegraph-dist/docker/data/ # AI-IDE prompt files (We only keep AGENTS.md, other files could soft-linked it when needed) +# Serena MCP memories +.serena/* +!.serena/project.yml +!.serena/memories/ +.mcp.json # Claude Projects CLAUDE.md CLAUDE_*.md @@ -112,3 +117,4 @@ codeium-instructions.md .ai-instructions.md *.ai-prompt.md WARP.md +.mcp.json diff --git a/.licenserc.yaml b/.licenserc.yaml index 3ebf89162d..8da741f65a 100644 --- a/.licenserc.yaml +++ b/.licenserc.yaml @@ -59,6 +59,7 @@ header: # `header` section is configurations for source codes license header. - 'LICENSE' - 'NOTICE' - 'DISCLAIMER' + - '.serena/**' - '**/*.versionsBackup' - '**/*.versionsBackup' - '**/*.proto' diff --git a/.serena/.gitignore b/.serena/.gitignore new file mode 100644 index 0000000000..14d86ad623 --- /dev/null +++ b/.serena/.gitignore @@ -0,0 +1 @@ +/cache diff --git a/.serena/memories/architecture_and_modules.md b/.serena/memories/architecture_and_modules.md new file mode 100644 index 0000000000..8d6c85888e --- /dev/null +++ b/.serena/memories/architecture_and_modules.md @@ -0,0 +1,35 @@ +# Architecture and Module Structure + +## Three-Tier Architecture + +### 1. Client Layer +- Gremlin/Cypher queries, REST APIs, Swagger UI + +### 2. Server Layer (hugegraph-server, 13 submodules) +- **REST API** (hugegraph-api): GraphAPI, SchemaAPI, GremlinAPI, CypherAPI, AuthAPI, GraphSpaceAPI (distributed only), ManagerAPI (distributed only) +- **Graph Engine** (hugegraph-core): Schema (with TTL update), traversal, task scheduling, GraphSpace multi-tenancy +- **Backend Interface**: Pluggable via `BackendStore` + +### 3. Storage Layer +- RocksDB (default/embedded), HStore (distributed/production) +- Legacy (≤1.5.0, deprecated, excluded from context): MySQL, PostgreSQL, Cassandra, ScyllaDB, HBase, Palo + +## Module Structure (7 top-level modules) + +### hugegraph-server (13 submodules) +`hugegraph-core`, `hugegraph-api` (includes `opencypher/`, `space/`), `hugegraph-dist`, `hugegraph-test`, `hugegraph-example`, plus backends: `hugegraph-rocksdb`, `hugegraph-hstore`, `hugegraph-hbase`, `hugegraph-mysql`, `hugegraph-postgresql`, `hugegraph-cassandra`, `hugegraph-scylladb`, `hugegraph-palo` + +### hugegraph-pd (8 submodules) +Placement Driver: `hg-pd-core`, `hg-pd-service`, `hg-pd-client`, `hg-pd-common`, `hg-pd-grpc`, `hg-pd-cli`, `hg-pd-dist`, `hg-pd-test` + +### hugegraph-store (9 submodules) +Distributed storage + Raft: `hg-store-core`, `hg-store-node`, `hg-store-client`, `hg-store-common`, `hg-store-grpc`, `hg-store-rocksdb`, `hg-store-cli`, `hg-store-dist`, `hg-store-test` + +### Others +- **hugegraph-commons**: Shared utilities, RPC framework +- **hugegraph-struct**: Data structures (must build before PD/Store) +- **install-dist**: Distribution packaging, license files +- **hugegraph-cluster-test**: Cluster integration tests + +## Distributed Deployment (BETA) +PD + Store + Server (3+ nodes each), all gRPC. Docker compose configs in `docker/` directory, using bridge networking (migrated from host mode). diff --git a/.serena/memories/code_style_and_conventions.md b/.serena/memories/code_style_and_conventions.md new file mode 100644 index 0000000000..159920cd3b --- /dev/null +++ b/.serena/memories/code_style_and_conventions.md @@ -0,0 +1,28 @@ +# Code Style and Conventions + +## Style Tools +- `.editorconfig` — Primary style definition +- `style/checkstyle.xml` — Enforcement (note: `hugegraph-style.xml` was removed) +- `.licenserc.yaml` + apache-rat-plugin + skywalking-eyes — License header validation + +## Core Rules +- **Line length**: 100 chars (120 for XML) +- **Indent**: 4 spaces, continuation 8 spaces +- **Charset**: UTF-8, LF line endings, final newline +- **Imports**: Sorted `$*` → `java` → `javax` → `org` → `com` → `*`, no star imports (threshold 100) +- **Braces**: `if`/`while`/`for` forced if multiline, `do-while` always +- **Blank lines**: Max 1 in code/declarations +- **JavaDoc**: `

` on empty lines, no wrap if one line + +## Naming +- Packages: `org.apache.hugegraph.*` (lowercase dot-separated) +- Classes: PascalCase, Methods/Variables: camelCase, Constants: UPPER_SNAKE_CASE + +## License +- All source files require Apache 2.0 header +- gRPC generated code excluded from checks +- Validate: `mvn apache-rat:check -ntp` + `mvn editorconfig:check` + +## Build +- Java 11 target, `-Xlint:unchecked`, Lombok 1.18.30 (provided/optional) +- Swagger: `io.swagger.core.v3:swagger-jaxrs2-jakarta` for REST API docs diff --git a/.serena/memories/ecosystem_and_related_projects.md b/.serena/memories/ecosystem_and_related_projects.md new file mode 100644 index 0000000000..6bb1344d66 --- /dev/null +++ b/.serena/memories/ecosystem_and_related_projects.md @@ -0,0 +1,23 @@ +# HugeGraph Ecosystem and Related Projects + +## This Repo: apache/hugegraph (server, OLTP) + +## Ecosystem +| Repo | Purpose | +|------|---------| +| hugegraph-toolchain | Loader, Hubble (visualization), Tools CLI, Java Client | +| hugegraph-computer | OLAP: PageRank, Connected Components, Shortest Path | +| incubator-hugegraph-ai | Graph RAG, KG construction, NL→Gremlin/Cypher | +| hugegraph-doc | Docs & website (hugegraph.apache.org) | + +## Data Flow +``` +Sources → hugegraph-loader → hugegraph-server → Hubble / Computer / AI +``` + +## Integrations +- Big Data: Flink, Spark, HDFS +- Queries: Gremlin (TinkerPop 3.5.1), OpenCypher, REST API + Swagger UI +- Storage: RocksDB (default), HStore (distributed) + +## Version: Server 1.7.0, TinkerPop 3.5.1, Java 11+ diff --git a/.serena/memories/implementation_patterns_and_guidelines.md b/.serena/memories/implementation_patterns_and_guidelines.md new file mode 100644 index 0000000000..c2b98313e2 --- /dev/null +++ b/.serena/memories/implementation_patterns_and_guidelines.md @@ -0,0 +1,50 @@ +# Implementation Patterns and Guidelines + +## Backend Architecture +- Backends implement `BackendStore` interface from `hugegraph-core` +- Each backend = separate Maven module under `hugegraph-server/` +- Configured via `hugegraph.properties` → `backend` property +- **Active backends (focus here)**: RocksDB (default/embedded), HStore (distributed) +- **Legacy backends** (deprecated, excluded from Serena context): MySQL, PostgreSQL, Cassandra, ScyllaDB, HBase, Palo + +## GraphSpace Multi-Tenancy +- Core: `hugegraph-core/.../space/` (GraphSpace, SchemaTemplate, Service, register/) +- API: `hugegraph-api/.../api/space/GraphSpaceAPI.java` (includes GS profile endpoints) +- **Standalone mode**: GraphSpaceAPI and ManagerAPI are disabled + +## Auth System +- Disabled by default, enable via `bin/enable-auth.sh` +- ConfigAuthenticator was removed, use standard auth +- Multi-level: Users, Groups, Projects, Targets, Access control +- Location: `hugegraph-api/.../api/auth/` + +## gRPC Protocol +- PD protos: `hugegraph-pd/hg-pd-grpc/src/main/proto/` +- Store protos: `hugegraph-store/hg-store-grpc/src/main/proto/` +- After `.proto` changes: `mvn clean compile` → `target/generated-sources/protobuf/` + +## Query Languages +- **Gremlin**: Native TinkerPop 3.5.1 +- **OpenCypher**: `hugegraph-api/opencypher/` +- TinkerPop exceptions are passed through in Gremlin responses + +## Schema +- Labels support TTL with runtime update +- Edge label conflicting conditions are handled safely + +## Testing +- **Profiles**: `unit-test`, `core-test`, `api-test`, `tinkerpop-structure-test`, `tinkerpop-process-test` +- **Backends in CI**: memory, rocksdb, hbase (matrix) +- **Single test class**: `mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory -Dtest=ClassName` +- TinkerPop tests: only on `release-*`/`test-*` branches +- Raft tests: only on `test*`/`raft*` branches + +## Docker +- Single-node: `docker/docker-compose.yml` (bridge network, pd+store+server) +- Cluster: `docker/docker-compose-3pd-3store-3server.yml` +- Container logs: stdout-based + +## CI Pipelines +- `server-ci.yml`: compile + unit/core/API tests (memory/rocksdb/hbase × Java 11) +- `rerun-ci.yml`: auto-rerun flaky failures (max 2 reruns, 180s delay) +- `auto-pr-review.yml`: auto-comment on new PRs diff --git a/.serena/memories/key_file_locations.md b/.serena/memories/key_file_locations.md new file mode 100644 index 0000000000..3f2a60dee0 --- /dev/null +++ b/.serena/memories/key_file_locations.md @@ -0,0 +1,44 @@ +# Key File and Directory Locations + +## Build & Config +- `pom.xml` — Root multi-module POM +- `.editorconfig` — Code style rules +- `style/checkstyle.xml` — Checkstyle enforcement (hugegraph-style.xml was removed) +- `.licenserc.yaml` — License checker config + +## Server (hugegraph-server) +- Core engine: `hugegraph-core/src/main/java/org/apache/hugegraph/` → `backend/`, `schema/`, `traversal/`, `task/` +- GraphSpace: `hugegraph-core/.../space/` → `GraphSpace.java`, `SchemaTemplate.java`, `Service.java`, `register/` +- REST APIs: `hugegraph-api/src/main/java/org/apache/hugegraph/api/` → `graph/`, `schema/`, `gremlin/`, `cypher/`, `auth/`, `space/` (GraphSpaceAPI), `metrics/`, `arthas/` +- OpenCypher: `hugegraph-api/.../opencypher/` +- Backend interface: `hugegraph-core/.../backend/store/BackendStore.java` +- Distribution: `hugegraph-dist/src/assembly/static/` → `bin/`, `conf/`, `lib/`, `logs/` +- Tests: `hugegraph-test/src/main/java/.../` → `unit/`, `core/`, `api/`, `tinkerpop/` + +## Docker +- `docker/docker-compose.yml` — Single-node (bridge network, pd+store+server) +- `docker/docker-compose-3pd-3store-3server.yml` — 3-node cluster +- `docker/docker-compose.dev.yml` — Dev mode + +## PD Module +- Proto: `hugegraph-pd/hg-pd-grpc/src/main/proto/` +- Dist: `hugegraph-pd/hg-pd-dist/src/assembly/static/` + +## Store Module +- Proto: `hugegraph-store/hg-store-grpc/src/main/proto/` +- Dist: `hugegraph-store/hg-store-dist/src/assembly/static/` + +## CI Workflows (.github/workflows/) +- `server-ci.yml` — Server tests (matrix: memory/rocksdb/hbase × Java 11) +- `pd-store-ci.yml` — PD, Store & HStore tests +- `commons-ci.yml` — Commons tests +- `cluster-test-ci.yml` — Cluster integration +- `licence-checker.yml` — License headers +- `rerun-ci.yml` — Auto-rerun for flaky workflows +- `auto-pr-review.yml` — Auto-comment on new PRs +- `check-dependencies.yml` — Dependency checks +- `codeql-analysis.yml` — CodeQL security scanning +- `stale.yml` — Stale issue/PR cleanup + +## Docs +- `README.md`, `BUILDING.md`, `CONTRIBUTING.md`, `AGENTS.md`, `CLAUDE.md` diff --git a/.serena/memories/project_overview.md b/.serena/memories/project_overview.md new file mode 100644 index 0000000000..c494aaed44 --- /dev/null +++ b/.serena/memories/project_overview.md @@ -0,0 +1,27 @@ +# Apache HugeGraph Project Overview + +## Project Purpose +Apache HugeGraph is a fast-speed, highly-scalable graph database supporting 10+ billion vertices/edges for OLTP workloads. Graduated from Apache Incubator (incubating branding removed). + +## Key Capabilities +- Apache TinkerPop 3 compliant graph database +- Gremlin + OpenCypher query languages +- Schema metadata management (VertexLabel, EdgeLabel, PropertyKey, IndexLabel) with TTL update support +- Multi-type indexes (exact, range, complex conditions) +- Pluggable backend storage (RocksDB default, HStore distributed) +- GraphSpace multi-tenancy (standalone mode disables GraphSpaceAPI/ManagerAPI) +- Swagger UI for REST API documentation +- Integration with Flink/Spark/HDFS + +## Technology Stack +- **Language**: Java 11+ (required) +- **Build**: Maven 3.5+ +- **Graph Framework**: Apache TinkerPop 3.5.1 +- **RPC**: gRPC + Protocol Buffers +- **API Docs**: Swagger (io.swagger.core.v3) +- **Storage**: RocksDB (default/embedded), HStore (distributed/production) +- **Legacy backends** (≤1.5.0): MySQL, PostgreSQL, Cassandra, ScyllaDB, HBase, Palo + +## Version +- Current: 1.7.0 (`${revision}` property, Maven flatten plugin) +- License: Apache License 2.0 diff --git a/.serena/memories/suggested_commands.md b/.serena/memories/suggested_commands.md new file mode 100644 index 0000000000..346304432f --- /dev/null +++ b/.serena/memories/suggested_commands.md @@ -0,0 +1,58 @@ +# Suggested Development Commands + +## Build +```bash +mvn clean install -DskipTests # Full build +mvn clean install -pl hugegraph-server -am -DskipTests # Server only +mvn clean compile -U -Dmaven.javadoc.skip=true -ntp # Compile only +mvn clean package -DskipTests # Distribution → install-dist/target/ +``` + +## Test +```bash +# Server tests (memory/rocksdb/hbase backends) +mvn test -pl hugegraph-server/hugegraph-test -am -P unit-test +mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory +mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,rocksdb +mvn test -pl hugegraph-server/hugegraph-test -am -P api-test,rocksdb + +# Single test class +mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory -Dtest=YourTestClass + +# TinkerPop compliance (release/test branches only) +mvn test -pl hugegraph-server/hugegraph-test -am -P tinkerpop-structure-test,memory + +# PD/Store (build struct first) +mvn install -pl hugegraph-struct -am -DskipTests +mvn test -pl hugegraph-pd/hg-pd-test -am +mvn test -pl hugegraph-store/hg-store-test -am +``` + +## Validation +```bash +mvn apache-rat:check -ntp # License headers +mvn editorconfig:check # Code style (.editorconfig) +mvn checkstyle:check # Code style (style/checkstyle.xml) +mvn clean compile -Dmaven.javadoc.skip=true # Compile warnings +``` + +## Server Ops +Scripts in `hugegraph-server/hugegraph-dist/src/assembly/static/bin/` (or extracted distribution `bin/`): +```bash +bin/init-store.sh && bin/start-hugegraph.sh # Init + start +bin/stop-hugegraph.sh # Stop +bin/enable-auth.sh # Enable auth +``` + +## Docker +```bash +cd docker && docker compose up -d # Single-node (bridge network) +cd docker && docker compose -f docker-compose-3pd-3store-3server.yml up -d # Cluster +``` + +## Distributed Build (BETA) +```bash +mvn install -pl hugegraph-struct -am -DskipTests # 1. Struct first +mvn clean package -pl hugegraph-pd -am -DskipTests # 2. PD +mvn clean package -pl hugegraph-store -am -DskipTests # 3. Store +``` diff --git a/.serena/memories/task_completion_checklist.md b/.serena/memories/task_completion_checklist.md new file mode 100644 index 0000000000..5e8ec4d82e --- /dev/null +++ b/.serena/memories/task_completion_checklist.md @@ -0,0 +1,32 @@ +# Task Completion Checklist + +## 1. Code Quality (MANDATORY) +```bash +mvn apache-rat:check -ntp # License headers +mvn editorconfig:check # Style (.editorconfig) +mvn checkstyle:check # Style (style/checkstyle.xml) +mvn clean compile -Dmaven.javadoc.skip=true # Compile warnings +``` + +## 2. Testing +- Choose backend: `memory` (fast), `rocksdb` (realistic), `hbase` (distributed) +- Single test: `-Dtest=ClassName` works with all profiles +- Bug fix → existing tests; New feature → write tests; Refactor → affected module tests + +## 3. Dependencies (if adding new) +1. License file → `install-dist/release-docs/licenses/` +2. Declare in `install-dist/release-docs/LICENSE` +3. Append NOTICE → `install-dist/release-docs/NOTICE` +4. Run `./install-dist/scripts/dependency/regenerate_known_dependencies.sh` + +## 4. CI Awareness +- `server-ci.yml`: memory/rocksdb/hbase × Java 11 +- `rerun-ci.yml`: auto-retries flaky failures +- `licence-checker.yml`: header validation +- Raft tests: only `test*`/`raft*` branches +- TinkerPop tests: only `release-*`/`test-*` branches + +## 5. Commit +- NEVER commit unless explicitly asked +- Format: `feat|fix|refactor(module): msg` +- Include issue ID if available diff --git a/.serena/project.yml b/.serena/project.yml new file mode 100644 index 0000000000..3329e5b5af --- /dev/null +++ b/.serena/project.yml @@ -0,0 +1,168 @@ +# list of languages for which language servers are started; choose from: +# al bash clojure cpp csharp +# csharp_omnisharp dart elixir elm erlang +# fortran fsharp go groovy haskell +# java julia kotlin lua markdown +# matlab nix pascal perl php +# php_phpactor powershell python python_jedi r +# rego ruby ruby_solargraph rust scala +# swift terraform toml typescript typescript_vts +# vue yaml zig +# (This list may be outdated. For the current list, see values of Language enum here: +# https://github.com/oraios/serena/blob/main/src/solidlsp/ls_config.py +# For some languages, there are alternative language servers, e.g. csharp_omnisharp, ruby_solargraph.) +# Note: +# - For C, use cpp +# - For JavaScript, use typescript +# - For Free Pascal/Lazarus, use pascal +# Special requirements: +# Some languages require additional setup/installations. +# See here for details: https://oraios.github.io/serena/01-about/020_programming-languages.html#language-servers +# When using multiple languages, the first language server that supports a given file will be used for that file. +# The first language is the default language and the respective language server will be used as a fallback. +# Note that when using the JetBrains backend, language servers are not used and this list is correspondingly ignored. +languages: +- java + +# the encoding used by text files in the project +# For a list of possible encodings, see https://docs.python.org/3.11/library/codecs.html#standard-encodings +encoding: "utf-8" + +# whether to use project's .gitignore files to ignore files +ignore_all_files_in_gitignore: true + +# list of additional paths to ignore in this project. +# Same syntax as gitignore, so you can use * and **. +# Note: global ignored_paths from serena_config.yml are also applied additively. +ignored_paths: + # --- Deprecated backends (focus on RocksDB/HStore only) --- + - "hugegraph-server/hugegraph-cassandra/**" + - "hugegraph-server/hugegraph-scylladb/**" + - "hugegraph-server/hugegraph-mysql/**" + - "hugegraph-server/hugegraph-postgresql/**" + - "hugegraph-server/hugegraph-palo/**" + - "hugegraph-server/hugegraph-hbase/**" + # --- gRPC generated Java (235k lines, never hand-edited, regenerated by mvn compile) --- + - "hugegraph-pd/hg-pd-grpc/src/main/java/**" + - "hugegraph-store/hg-store-grpc/src/main/java/**" + # --- License/legal files (585 txt files, only touched when adding dependencies) --- + - "install-dist/release-docs/licenses/**" + - "install-dist/scripts/dependency/known-dependencies.txt" + # --- Rarely modified tests/examples --- + - "hugegraph-server/hugegraph-test/**/tinkerpop/**" + - "hugegraph-server/hugegraph-example/**" + - "hugegraph-cluster-test/**" + # --- Note: target/, .flattened-pom.xml, .idea/*, apache-hugegraph-*/ already covered by .gitignore --- + +# whether the project is in read-only mode +# If set to true, all editing tools will be disabled and attempts to use them will result in an error +# Added on 2025-04-18 +read_only: false + +# list of tool names to exclude. +# This extends the existing exclusions (e.g. from the global configuration) +# +# Below is the complete list of tools for convenience. +# To make sure you have the latest list of tools, and to view their descriptions, +# execute `uv run scripts/print_tool_overview.py`. +# +# * `activate_project`: Activates a project by name. +# * `check_onboarding_performed`: Checks whether project onboarding was already performed. +# * `create_text_file`: Creates/overwrites a file in the project directory. +# * `delete_lines`: Deletes a range of lines within a file. +# * `delete_memory`: Deletes a memory from Serena's project-specific memory store. +# * `execute_shell_command`: Executes a shell command. +# * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced. +# * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type). +# * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type). +# * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes. +# * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file. +# * `initial_instructions`: Gets the initial instructions for the current project. +# Should only be used in settings where the system prompt cannot be set, +# e.g. in clients you have no control over, like Claude Desktop. +# * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol. +# * `insert_at_line`: Inserts content at a given line in a file. +# * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol. +# * `list_dir`: Lists files and directories in the given directory (optionally with recursion). +# * `list_memories`: Lists memories in Serena's project-specific memory store. +# * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building). +# * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context). +# * `read_file`: Reads a file within the project directory. +# * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store. +# * `remove_project`: Removes a project from the Serena configuration. +# * `replace_lines`: Replaces a range of lines within a file with new content. +# * `replace_symbol_body`: Replaces the full definition of a symbol. +# * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen. +# * `search_for_pattern`: Performs a search for a pattern in the project. +# * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase. +# * `switch_modes`: Activates modes by providing a list of their names +# * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information. +# * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task. +# * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed. +# * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store. +excluded_tools: [] + +# initial prompt for the project. It will always be given to the LLM upon activating the project +# (contrary to the memories, which are loaded on demand). +initial_prompt: "" +# the name by which the project can be referenced within Serena +project_name: "server" + +# list of tools to include that would otherwise be disabled (particularly optional tools that are disabled by default). +# This extends the existing inclusions (e.g. from the global configuration). +included_optional_tools: [] + +# list of mode names to that are always to be included in the set of active modes +# The full set of modes to be activated is base_modes + default_modes. +# If the setting is undefined, the base_modes from the global configuration (serena_config.yml) apply. +# Otherwise, this setting overrides the global configuration. +# Set this to [] to disable base modes for this project. +# Set this to a list of mode names to always include the respective modes for this project. +base_modes: + +# list of mode names that are to be activated by default. +# The full set of modes to be activated is base_modes + default_modes. +# If the setting is undefined, the default_modes from the global configuration (serena_config.yml) apply. +# Otherwise, this overrides the setting from the global configuration (serena_config.yml). +# This setting can, in turn, be overridden by CLI parameters (--mode). +default_modes: + +# fixed set of tools to use as the base tool set (if non-empty), replacing Serena's default set of tools. +# This cannot be combined with non-empty excluded_tools or included_optional_tools. +fixed_tools: [] + +# time budget (seconds) per tool call for the retrieval of additional symbol information +# such as docstrings or parameter information. +# This overrides the corresponding setting in the global configuration; see the documentation there. +# If null or missing, use the setting from the global configuration. +symbol_info_budget: + +# The language backend to use for this project. +# If not set, the global setting from serena_config.yml is used. +# Valid values: LSP, JetBrains +# Note: the backend is fixed at startup. If a project with a different backend +# is activated post-init, an error will be returned. +language_backend: + +# list of regex patterns which, when matched, mark a memory entry as read‑only. +# Extends the list from the global configuration, merging the two lists. +read_only_memory_patterns: [] + +# line ending convention to use when writing source files. +# Possible values: unset (use global setting), "lf", "crlf", or "native" (platform default) +# This does not affect Serena's own files (e.g. memories and configuration files), which always use native line endings. +line_ending: + +# list of regex patterns for memories to completely ignore. +# Matching memories will not appear in list_memories or activate_project output +# and cannot be accessed via read_memory or write_memory. +# To access ignored memory files, use the read_file tool on the raw file path. +# Extends the list from the global configuration, merging the two lists. +# Example: ["_archive/.*", "_episodes/.*"] +ignored_memory_patterns: [] + +# advanced configuration option allowing to configure language server-specific options. +# Maps the language key to the options. +# Have a look at the docstring of the constructors of the LS implementations within solidlsp (e.g., for C# or PHP) to see which options are available. +# No documentation on options means no options are available. +ls_specific_settings: {} diff --git a/AGENTS.md b/AGENTS.md index a868739d84..2d6e81b15b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,261 +1,108 @@ # AGENTS.md -This file provides guidance to an AI coding tool when working with code in this repository. +Single source of truth for AI coding agents. +README.md covers human-facing deployment/ecosystem context; only consult it on demand. -## Project Overview +## Stack & Modules -Apache HugeGraph is a fast-speed and highly-scalable graph database that supports billions of vertices and edges. It is compliant with Apache TinkerPop 3 and supports both Gremlin and Cypher query languages. +Apache HugeGraph — Apache TinkerPop 3 compliant graph database. +Java 11+, Maven 3.5+. Version managed via `${revision}` (currently `1.8.0`). -**Technology Stack**: -- Java 11+ (required) -- Apache Maven 3.5+ -- Apache TinkerPop 3.5.1 -- gRPC for distributed communication -- RocksDB as default storage backend - -## Architecture - -### Multi-Module Structure - -This is a Maven multi-module project with 7 main modules: - -1. **hugegraph-server**: Core graph engine, REST APIs, and backend implementations (13 submodules) -2. **hugegraph-pd**: Placement Driver (meta server) for distributed deployments (8 submodules) -3. **hugegraph-store**: Distributed storage backend with RocksDB and Raft (9 submodules) -4. **hugegraph-commons**: Shared utilities (locks, configs, RPC framework) -5. **hugegraph-struct**: Data structure definitions -6. **install-dist**: Distribution packaging -7. **hugegraph-cluster-test**: Cluster integration tests - -### Three-Tier Architecture - -```bash -Client Layer (Gremlin/Cypher queries, REST APIs) - ↓ -Server Layer (hugegraph-server) - ├─ REST API Layer (hugegraph-api): GraphAPI, SchemaAPI, GremlinAPI, CypherAPI, AuthAPI - ├─ Graph Engine Layer (hugegraph-core): Schema management, traversal optimization, task scheduling - └─ Backend Interface: Abstraction over storage backends - ↓ -Storage Layer (pluggable backends) - ├─ RocksDB (default, embedded) - ├─ HStore (distributed, production) - └─ Legacy: MySQL, PostgreSQL, Cassandra, ScyllaDB, HBase, Palo +``` +Client (Gremlin / Cypher / REST) + │ +Server = hugegraph-server + ├─ hugegraph-api REST, Gremlin/Cypher, auth + ├─ hugegraph-core engine, schema, traversal, BackendStore interface + └─ Backend impls rocksdb (default, embedded) │ hstore (distributed) + ▼ + hugegraph-pd (placement) + hugegraph-store (Raft) ``` -### Distributed Components (Optional) - -For production distributed deployments: -- **hugegraph-pd**: Service discovery, partition management, metadata coordination -- **hugegraph-store**: Distributed storage with Raft consensus (typically 3+ nodes) -- **hugegraph-server**: Multiple server instances (typically 3+) - -All inter-service communication uses gRPC with Protocol Buffers. +Top-level modules: `hugegraph-server` · `hugegraph-pd` · `hugegraph-store` · +`hugegraph-commons` (shared utils & RPC) · `hugegraph-struct` (data types; dep of PD/Store). -### Key Architectural Patterns +Server submodules worth knowing: `hugegraph-core`, `hugegraph-api`, +`hugegraph-rocksdb`, `hugegraph-hstore`, `hugegraph-test`, `hugegraph-dist`. -1. **Pluggable Backend Architecture**: Storage backends implement the `BackendStore` interface, allowing new backends without modifying core code -2. **TinkerPop Compliance**: Full Apache TinkerPop 3 implementation with custom optimization strategies -3. **gRPC Communication**: All distributed components communicate via gRPC (proto definitions in `*/grpc/` directories) -4. **Multi-Language Queries**: Native Gremlin support + OpenCypher implementation in `hugegraph-api/opencypher` +## Code Search Anchors -## Build & Development Commands +| Area | Path | +|---|---| +| Graph engine | `hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/` | +| REST APIs | `hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/` | +| Backend interface | `hugegraph-server/hugegraph-core/.../backend/store/BackendStore.java` | +| Auth | `hugegraph-server/hugegraph-api/.../api/auth/` | +| gRPC protos | `hugegraph-{pd,store}/hg-{pd,store}-grpc/src/main/proto/` | -### Prerequisites Check -```bash -# Verify Java version (11+ required) -java -version +Config roots (under each dist module's `src/assembly/static/conf/`): +- Server — `hugegraph.properties`, `rest-server.properties`, `gremlin-server.yaml` +- PD / Store — `application.yml` -# Verify Maven version (3.5+ required) -mvn -version -``` +## Build -### Full Build ```bash -# Clean build with all modules +# All modules mvn clean install -DskipTests -# Build with tests -mvn clean install - -# Build specific module (e.g., server only) +# Single module mvn clean install -pl hugegraph-server -am -DskipTests ``` -### Testing +Distributed build order (for HStore-enabled dev): -#### Server Module Tests ```bash -# Unit tests (memory backend) -mvn test -pl hugegraph-server/hugegraph-test -am -P unit-test - -# Core tests with specific backend -mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory -mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,rocksdb -mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,hbase - -# API tests with backend -mvn test -pl hugegraph-server/hugegraph-test -am -P api-test,rocksdb - -# TinkerPop compliance tests (for release branches) -mvn test -pl hugegraph-server/hugegraph-test -am -P tinkerpop-structure-test,memory -mvn test -pl hugegraph-server/hugegraph-test -am -P tinkerpop-process-test,memory +mvn install -pl hugegraph-struct -am -DskipTests # 1. shared data types +mvn clean package -pl hugegraph-pd -am -DskipTests # 2. placement driver +mvn clean package -pl hugegraph-store -am -DskipTests # 3. distributed storage +mvn clean package -pl hugegraph-server -am -DskipTests # 4. server ``` -#### PD & Store Module Tests -```bash -# Build and test hugegraph-struct first (dependency) -mvn install -pl hugegraph-struct -am -DskipTests - -# Test PD module -mvn test -pl hugegraph-pd/hg-pd-test -am +Runtime scripts (human-run) live in `hugegraph-server/hugegraph-dist/src/assembly/static/bin/`: +`init-store.sh`, `start-hugegraph.sh`, `stop-hugegraph.sh`. -# Test Store module -mvn test -pl hugegraph-store/hg-store-test -am -``` +## Testing -### Code Quality & Validation +Server tests implicitly prefix `mvn test -pl hugegraph-server/hugegraph-test -am`: -```bash -# License header check (Apache RAT) -mvn apache-rat:check +| Profile | Suffix | +|---|---| +| Unit | `-P unit-test` | +| Core | `-P core-test,rocksdb` (swap `rocksdb` for `memory`) | +| API | `-P api-test,rocksdb` | +| TinkerPop structure / process | `-P tinkerpop-{structure,process}-test,memory` | +| Single class | `-P core-test,rocksdb -Dtest=YourTestClass` | -# Code style check (EditorConfig) -mvn editorconfig:check - -# Compile with warnings -mvn clean compile -Dmaven.javadoc.skip=true -``` - -### Running the Server - -Scripts are located in `hugegraph-server/hugegraph-dist/src/assembly/static/bin/`: +PD / Store tests (need `hugegraph-struct` installed first): ```bash -# Initialize storage backend -bin/init-store.sh - -# Start server -bin/start-hugegraph.sh - -# Stop server -bin/stop-hugegraph.sh - -# Gremlin console -bin/gremlin-console.sh - -# Enable authentication -bin/enable-auth.sh -``` - -### Creating Distribution Package - -```bash -# Build distribution tarball (auto-enabled by default) -mvn clean package -DskipTests - -# Skip assembly creation (if needed) -mvn clean package -DskipTests -Dskip-assembly-hugegraph - -# Output: install-dist/target/hugegraph-.tar.gz -``` - -## Important File Locations - -### Configuration Files -- Server configs: `hugegraph-server/hugegraph-dist/src/assembly/static/conf/` - - `hugegraph.properties` - Main server configuration - - `rest-server.properties` - REST API settings - - `gremlin-server.yaml` - Gremlin server configuration -- PD configs: `hugegraph-pd/hg-pd-dist/src/assembly/static/conf/` -- Store configs: `hugegraph-store/hg-store-dist/src/assembly/static/conf/` - -### Proto Definitions (gRPC) -- PD protos: `hugegraph-pd/hg-pd-grpc/src/main/proto/` -- Store protos: `hugegraph-store/hg-store-grpc/src/main/proto/` - -### Core Implementation Paths -- Graph engine: `hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/` -- REST APIs: `hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/` -- Backend implementations: `hugegraph-server/hugegraph-{backend}/` (e.g., `hugegraph-rocksdb`) - -## Development Workflow - -### Code Style -Import the code style configuration from `hugegraph-style.xml` in your IDE (IntelliJ IDEA recommended). - -### Adding Dependencies - -When adding third-party dependencies: -1. Add license files to `install-dist/release-docs/licenses/` -2. Declare dependency in `install-dist/release-docs/LICENSE` -3. Append NOTICE info to `install-dist/release-docs/NOTICE` (if upstream has NOTICE) -4. Update `install-dist/scripts/dependency/known-dependencies.txt` (run `regenerate_known_dependencies.sh`) - -### Backend Development - -When working on storage backends: -- All backends extend `hugegraph-server/hugegraph-core` abstractions -- Implement the `BackendStore` interface -- Each backend is a separate Maven module in `hugegraph-server/` -- Backend selection is configured in `hugegraph.properties` via the `backend` property - -### gRPC Protocol Changes - -When modifying `.proto` files: -- Generated Java code goes to `*/grpc/` packages (excluded from Apache RAT checks) -- Run `mvn clean compile` to regenerate gRPC stubs -- Generated files are in `target/generated-sources/protobuf/` - -### Authentication System - -Authentication is optional and disabled by default: -- Enable via `bin/enable-auth.sh` or configuration -- Auth implementation: `hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/` -- Multi-level: Users, Groups, Projects, Targets, Access control -- Required for production deployments - -## Common Workflows - -### Running a Single Test Class -```bash -# Use Maven's -Dtest parameter -mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory -Dtest=YourTestClass +mvn install -pl hugegraph-struct -am -DskipTests +mvn test -pl hugegraph-pd/hg-pd-test -am +mvn test -pl hugegraph-store/hg-store-test -am ``` -### Working with Distributed Components - -The distributed architecture (PD + Store) is in BETA. For distributed development: -1. Build struct module first: `mvn install -pl hugegraph-struct -am -DskipTests` -2. Build PD: `mvn clean package -pl hugegraph-pd -am -DskipTests` -3. Build Store: `mvn clean package -pl hugegraph-store -am -DskipTests` -4. Build Server with HStore backend: `mvn clean package -pl hugegraph-server -am -DskipTests` - -See Docker Compose example: `hugegraph-server/hugegraph-dist/docker/example/` - -### Debugging Tips +Before writing new tests, check existing suites under `hugegraph-server/hugegraph-test/`. -- Enable detailed logging in `hugegraph-server/hugegraph-dist/src/assembly/static/conf/log4j2.xml` -- Use `bin/dump-conf.sh` to view effective configuration -- Arthas diagnostics tool is included (version 3.7.1) -- Monitor with `bin/monitor-hugegraph.sh` +## Style & Pre-commit -## CI/CD Profiles +- Line 100, 4-space indent, LF, UTF-8, **no star imports** +- Commit format: `feat|fix|refactor(module): msg` +- Run before pushing: + ```bash + mvn editorconfig:format # enforce code style + mvn clean compile -Dmaven.javadoc.skip=true # surface warnings + ``` -The project uses multiple GitHub Actions workflows: -- `server-ci.yml`: Server module tests (memory, rocksdb, hbase backends) -- `pd-store-ci.yml`: PD and Store module tests -- `commons-ci.yml`: Commons module tests -- `cluster-test-ci.yml`: Distributed cluster integration tests -- `licence-checker.yml`: Apache RAT license validation +## Cross-module notes -## Special Notes +- `.proto` edits: `mvn clean compile` regenerates gRPC stubs under + `target/generated-sources/protobuf/` (output packages `*/grpc/` are excluded from Apache RAT). +- Adding a third-party dep: update `install-dist/release-docs/{LICENSE,NOTICE,licenses/}` + and `install-dist/scripts/dependency/known-dependencies.txt`. +- `hugegraph-commons` is shared by every module; `hugegraph-struct` must precede PD/Store; + server backends depend on `hugegraph-core`. -### Cross-Module Dependencies -- `hugegraph-commons` is a shared dependency for all modules -- `hugegraph-struct` must be built before PD and Store -- Server backends depend on `hugegraph-core` +## Additional context files -### Version Management -- Version is managed via `${revision}` property (currently `1.7.0`) -- Flatten Maven plugin used for CI-friendly versioning +`.serena/memories/` — notably `suggested_commands.md` and `task_completion_checklist.md` +when a task needs depth beyond this file. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1ee0499bb7..7056afd978 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -19,13 +19,13 @@ Before submitting the code, we need to do some preparation: 1. Sign up or login to GitHub: [https://github.com](https://github.com) -2. Fork HugeGraph repo from GitHub: [https://github.com/apache/incubator-hugegraph/fork](https://github.com/apache/incubator-hugegraph/fork) +2. Fork HugeGraph repo from GitHub: [https://github.com/apache/hugegraph/fork](https://github.com/apache/hugegraph/fork) -3. Clone code from fork repo to local: [https://github.com/${GITHUB_USER_NAME}/incubator-hugegraph](https://github.com/${GITHUB_USER_NAME}/incubator-hugegraph) +3. Clone code from fork repo to local: [https://github.com/${GITHUB_USER_NAME}/hugegraph](https://github.com/${GITHUB_USER_NAME}/hugegraph) ```shell # clone code from remote to local repo - git clone https://github.com/${GITHUB_USER_NAME}/incubator-hugegraph.git hugegraph + git clone https://github.com/${GITHUB_USER_NAME}/hugegraph.git hugegraph ``` 4. Configure local HugeGraph repo @@ -34,7 +34,7 @@ Before submitting the code, we need to do some preparation: cd hugegraph # add upstream to synchronize the latest code - git remote add hugegraph https://github.com/apache/incubator-hugegraph + git remote add hugegraph https://github.com/apache/hugegraph # set name and email to push code to github git config user.name "{full-name}" # like "Jermy Li" @@ -43,7 +43,7 @@ Before submitting the code, we need to do some preparation: ## 2. Create an Issue on GitHub -If you encounter bugs or have any questions, please go to [GitHub Issues](https://github.com/apache/incubator-hugegraph/issues) to report them and feel free to [create an issue](https://github.com/apache/incubator-hugegraph/issues/new). +If you encounter bugs or have any questions, please go to [GitHub Issues](https://github.com/apache/hugegraph/issues) to report them and feel free to [create an issue](https://github.com/apache/hugegraph/issues/new). ## 3. Make changes of code locally @@ -71,14 +71,14 @@ vim hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeFacto # run test locally (optional) mvn test -Pcore-test,memory ``` -Note: To be consistent with the code style easily, if you use [IDEA](https://www.jetbrains.com/idea/) as your IDE, you can directly [import](https://www.jetbrains.com/help/idea/configuring-code-style.html) our code style [configuration file](./hugegraph-style.xml). +Note: Code style is defined by the `.editorconfig` file at the repository root. Checkstyle rules are defined in `style/checkstyle.xml`. Configure your IDE accordingly. ##### 3.2.1 Check licenses If we want to add new third-party dependencies to the `HugeGraph` project, we need to do the following things: -1. Find the third-party dependent repository, put the dependent `license` file into [./hugegraph-dist/release-docs/licenses/](https://github.com/apache/incubator-hugegraph/tree/master/hugegraph-dist/release-docs/licenses) path. -2. Declare the dependency in [./install-dist/release-docs/LICENSE](https://github.com/apache/incubator-hugegraph/blob/master/install-dist/release-docs/LICENSE) `LICENSE` information. -3. Find the NOTICE file in the repository and append it to [./install-dist/release-docs/NOTICE](https://github.com/apache/incubator-hugegraph/blob/master/install-dist/release-docs/NOTICE) file (skip this step if there is no NOTICE file). -4. Execute locally [./install-dist/scripts/dependency/regenerate_known_dependencies.sh](https://github.com/apache/incubator-hugegraph/blob/master/install-dist/scripts/dependency/regenerate_known_dependencies.sh) to update the dependency list [known-dependencies.txt](https://github.com/apache/incubator-hugegraph/blob/master/install-dist/scripts/dependency/known-dependencies.txt) (or manually update). +1. Find the third-party dependent repository, put the dependent `license` file into [./install-dist/release-docs/licenses/](https://github.com/apache/hugegraph/tree/master/install-dist/release-docs/licenses) path. +2. Declare the dependency in [./install-dist/release-docs/LICENSE](https://github.com/apache/hugegraph/blob/master/install-dist/release-docs/LICENSE) `LICENSE` information. +3. Find the NOTICE file in the repository and append it to [./install-dist/release-docs/NOTICE](https://github.com/apache/hugegraph/blob/master/install-dist/release-docs/NOTICE) file (skip this step if there is no NOTICE file). +4. Execute locally [./install-dist/scripts/dependency/regenerate_known_dependencies.sh](https://github.com/apache/hugegraph/blob/master/install-dist/scripts/dependency/regenerate_known_dependencies.sh) to update the dependency list [known-dependencies.txt](https://github.com/apache/hugegraph/blob/master/install-dist/scripts/dependency/known-dependencies.txt) (or manually update). **Example**: A new third-party dependency is introduced into the project -> `ant-1.9.1.jar` - The project source code is located at: https://github.com/apache/ant/tree/rel/1.9.1 diff --git a/DISCLAIMER b/DISCLAIMER deleted file mode 100644 index be718eef3b..0000000000 --- a/DISCLAIMER +++ /dev/null @@ -1,7 +0,0 @@ -Apache HugeGraph (incubating) is an effort undergoing incubation at The Apache Software Foundation (ASF), sponsored by the Apache Incubator PMC. - -Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, -and decision making process have stabilized in a manner consistent with other successful ASF projects. - -While incubation status is not necessarily a reflection of the completeness or stability of the code, -it does indicate that the project has yet to be fully endorsed by the ASF. diff --git a/NOTICE b/NOTICE index aa6764af84..8e48b813b8 100644 --- a/NOTICE +++ b/NOTICE @@ -1,5 +1,5 @@ -Apache HugeGraph(incubating) -Copyright 2022-2025 The Apache Software Foundation +Apache HugeGraph +Copyright 2022-2026 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). diff --git a/README.md b/README.md index 45414a832c..f24f6f7bfd 100644 --- a/README.md +++ b/README.md @@ -7,13 +7,19 @@

[![License](https://img.shields.io/badge/license-Apache%202-0E78BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html) -[![HugeGraph-CI](https://github.com/apache/incubator-hugegraph/actions/workflows/ci.yml/badge.svg)](https://github.com/apache/incubator-hugegraph/actions/workflows/ci.yml) -[![License checker](https://github.com/apache/incubator-hugegraph/actions/workflows/licence-checker.yml/badge.svg)](https://github.com/apache/incubator-hugegraph/actions/workflows/licence-checker.yml) +[![HugeGraph-Server CI](https://github.com/apache/hugegraph/actions/workflows/server-ci.yml/badge.svg)](https://github.com/apache/hugegraph/actions/workflows/server-ci.yml) +[![HugeGraph-PD & Store CI](https://github.com/apache/hugegraph/actions/workflows/pd-store-ci.yml/badge.svg)](https://github.com/apache/hugegraph/actions/workflows/pd-store-ci.yml) [![GitHub Releases Downloads](https://img.shields.io/github/downloads/apache/hugegraph/total.svg)](https://github.com/apache/hugegraph/releases) [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/apache/hugegraph)
+--- + +**Quick Navigation:** [Architecture](#architecture) • [Quick Start](#quick-start) • [Module Map](#module-map) • [Ecosystem](#ecosystem) • [For Contributors](#for-contributors) • [Community](#community) + +--- + ## What is Apache HugeGraph? [HugeGraph](https://hugegraph.apache.org/) is a fast and highly-scalable [graph database](https://en.wikipedia.org/wiki/Graph_database). @@ -23,79 +29,375 @@ achieved through the powerful [Gremlin](https://tinkerpop.apache.org/gremlin.htm ## Features -- Compliant to [Apache TinkerPop 3](https://tinkerpop.apache.org/), supports [Gremlin](https://tinkerpop.apache.org/gremlin.html) & [Cypher](https://en.wikipedia.org/wiki/Cypher) language -- Schema Metadata Management, including VertexLabel, EdgeLabel, PropertyKey and IndexLabel -- Multi-type Indexes, supporting exact query, range query and complex conditions combination query -- Plug-in Backend Store Framework, mainly support `RocksDB`/`HStore` + `HBase` for now and you could choose other backends in the [legacy version](https://hugegraph.apache.org/docs/download/download/) ≤ `1.5.0` (like `MySQL/PG`/`Cassandra` ...) -- Integration with `Flink/Spark/HDFS`, and friendly to connect other big data platforms -- Complete graph ecosystem (including both in/out-memory `Graph Computing` + `Graph Visualization & Tools` + `Graph Learning & AI`, see [here](#3-build-from-source)) +- **Schema Metadata Management**: VertexLabel, EdgeLabel, PropertyKey, and IndexLabel +- **Multi-type Indexes**: Exact query, range query, and complex conditions combination query +- **Plug-in Backend Store Framework**: Mainly supports `RocksDB`/`HStore` + `HBase`; other backends available in [legacy versions](https://hugegraph.apache.org/docs/download/download/) ≤ `1.5.0` (MySQL/PostgreSQL/Cassandra...) +- **Big Data Integration**: Seamless integration with `Flink`/`Spark`/`HDFS` +- **Complete Graph Ecosystem**: In/out-memory Graph Computing + Graph Visualization & Tools + Graph Learning & AI +- **Dual Query Language Support**: [Gremlin](https://tinkerpop.apache.org/gremlin.html) (via [Apache TinkerPop 3](https://tinkerpop.apache.org/)) and [Cypher](https://en.wikipedia.org/wiki/Cypher_(query_language)) (OpenCypher) + +## Ecosystem + +Complete **HugeGraph** ecosystem components: + +1. **[hugegraph-toolchain](https://github.com/apache/hugegraph-toolchain)** - Graph tools suite + - [Loader](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-loader) - Data import tool + - [Dashboard](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-hubble) - Web visualization platform + - [Tool](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-tools) - Command-line utilities + - [Client](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-client) - Java/Python client SDK + +2. **[hugegraph-computer](https://github.com/apache/hugegraph-computer)** - Integrated **graph computing** system + +3. **[hugegraph-ai](https://github.com/apache/hugegraph-ai)** - **Graph AI/LLM/Knowledge Graph** integration + +4. **[hugegraph-website](https://github.com/apache/hugegraph-doc)** - **Documentation & website** repository + +## Architecture + +HugeGraph supports both **standalone** and **distributed** deployments: + +``` + ┌─────────────────────────────────────────────────────┐ + │ Client Layer │ + │ Gremlin Console │ REST API │ Cypher │ SDK/Tools │ + └─────────────────────────┬───────────────────────────┘ + │ + ┌─────────────────────────▼───────────────────────────┐ + │ HugeGraph Server (:8080) │ + │ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │ + │ │ REST API │ │ Gremlin │ │ Cypher Engine │ │ + │ │(Jersey 3)│ │ (TP 3.5) │ │ (OpenCypher) │ │ + │ └────┬─────┘ └────┬─────┘ └────────┬─────────┘ │ + │ └─────────────┼─────────────────┘ │ + │ ┌────────▼────────┐ │ + │ │ Graph Engine │ │ + │ │(hugegraph-core) │ │ + │ └────────┬────────┘ │ + └─────────────────────┼───────────────────────────────┘ + │ + ┌────────────────────────────────┼────────────────────────────────┐ + │ │ │ +┌────────────▼────────────┐ ┌───────────────▼───────────────┐ ┌───────────▼──────────┐ +│ Standalone Mode │ │ Distributed Mode │ │ Legacy Backends │ +│ ┌───────────────────┐ │ │ ┌─────────────────────────┐ │ │ (≤v1.5) │ +│ │ RocksDB │ │ │ │ HugeGraph-PD │ │ │ MySQL │ PostgreSQL │ +│ │ (embedded) │ │ │ │ (Raft, 3-5 nodes) │ │ │ Cassandra │ +│ └───────────────────┘ │ │ │ :8620/:8686 │ │ │ HBase (≤v1.7) │ +│ │ │ └────────────┬────────────┘ │ └──────────────────────┘ +│ Use Case: │ │ │ │ +│ Development/Testing │ │ ┌────────────▼────────────┐ │ +│ Single Node │ │ │ HugeGraph-Store │ │ +│ │ │ │ (Raft + RocksDB) │ │ +│ Data Scale: < 1TB │ │ │ (3+ nodes) :8520 │ │ +└─────────────────────────┘ │ └─────────────────────────┘ │ + │ │ + │ Use Case: │ + │ Production/HA/Cluster │ + │ │ + │ Data Scale: < 1000 TB │ + └───────────────────────────────┘ +``` + +### Deployment Mode Comparison + +| Mode | Components | Use Case | Data Scale | High Availability | +|------|------------|----------|------------|-------------------| +| **Standalone** | Server + RocksDB | Development, Testing, Single Node | < 1TB | Basic | +| **Distributed** | Server + PD (3-5 nodes) + Store (3+ nodes) | Production, HA, Horizontal Scaling | < 1000 TB | Yes | + +### Module Overview + +| Module | Description | +|--------|-------------| +| [hugegraph-server](hugegraph-server) | Core graph engine with REST API, Gremlin/Cypher support, and pluggable backends (RocksDB default) | +| [hugegraph-pd](hugegraph-pd/README.md) | Placement Driver for distributed mode - handles meta storage, partition management and cluster scheduling | +| [hugegraph-store](hugegraph-store/README.md) | Distributed storage with Raft consensus for high availability and horizontal scaling | +| [hugegraph-commons](hugegraph-commons) | Shared utilities, RPC framework and common components | + +
+📊 Click to view detailed architecture diagram (Mermaid) + +```mermaid +flowchart TB + subgraph Clients["Client Layer"] + GC[Gremlin Console] + REST[REST Client] + CYPHER[Cypher Client] + SDK[SDK/Tools] + end + + subgraph Server["HugeGraph Server :8080"] + API[REST API
Jersey 3] + GS[Gremlin Server
TinkerPop 3.5] + CS[Cypher Engine
OpenCypher] + CORE[Graph Engine
hugegraph-core] + + API --> CORE + GS --> CORE + CS --> CORE + end + + subgraph Storage["Storage Layer"] + subgraph Standalone["Standalone Mode"] + ROCKS[(RocksDB
Embedded)] + end + + subgraph Distributed["Distributed Mode"] + PD[HugeGraph-PD
Raft Cluster
:8620/:8686] + STORE[HugeGraph-Store
Raft + RocksDB
:8520] + PD <--> STORE + end + + subgraph Legacy["Legacy Backends (≤v1.5)"] + MYSQL[(MySQL)] + PG[(PostgreSQL)] + CASS[(Cassandra)] + HBASE[(HBase, ≤v1.7)] + end + end + + Clients --> Server + CORE --> ROCKS + CORE --> PD + CORE -.-> Legacy + + style Server fill:#e1f5ff + style Distributed fill:#fff4e1 + style Standalone fill:#f0f0f0 +``` + +
## Quick Start -### 1. Docker (For Test) +### 5 Minutes Quick Start + +```bash +# Start HugeGraph (standalone mode) +docker run -itd --name=hugegraph -p 8080:8080 hugegraph/hugegraph:1.7.0 -Use Docker to quickly start a HugeGraph server with `RocksDB` (in the background) for **testing or development**: +# Verify server is running +curl http://localhost:8080/versions +# Try a Gremlin query +curl -X POST http://localhost:8080/gremlin \ + -H "Content-Type: application/json" \ + -d '{"gremlin":"g.V().limit(5)"}' ``` -# (Optional) -# - add "-e PRELOAD=true" to auto-load a sample graph -docker run -itd --name=graph -e PASSWORD=xxx -p 8080:8080 hugegraph/hugegraph:1.5.0 + +> **Production Note**: For production environments or public network exposure, you **must** enable the [AuthSystem](https://hugegraph.apache.org/docs/config/config-authentication/) for security. + +### Prerequisites + +- **Java 11+** (required) +- **Maven 3.5+** (for building from source) + +### Option 1: Docker (Fastest) + +Docker is the quickest way to get started for **testing or development**: + +```bash +# Basic usage +docker run -itd --name=hugegraph -p 8080:8080 hugegraph/hugegraph:1.7.0 + +# With sample graph preloaded +docker run -itd --name=hugegraph -e PRELOAD=true -p 8080:8080 hugegraph/hugegraph:1.7.0 + +# With authentication enabled +docker run -itd --name=hugegraph -e PASSWORD=your_password -p 8080:8080 hugegraph/hugegraph:1.7.0 ``` -Please visit [doc page](https://hugegraph.apache.org/docs/quickstart/hugegraph-server/#3-deploy) or -the [README](hugegraph-server/hugegraph-dist/docker/README.md) for more details. ([Docker Compose](./hugegraph-server/hugegraph-dist/docker/example)) +For advanced Docker configurations, see: -> Note: -> 1. The Docker image of HugeGraph is a convenience release, but not **official distribution** artifacts. You can find more details from [ASF Release Distribution Policy](https://infra.apache.org/release-distribution.html#dockerhub). -> 2. Recommend to use `release tag` (like `1.5.0`/`1.x.0`) for the stable version. Use `latest` tag to experience the newest functions in development. +* [Docker Documentation](https://hugegraph.apache.org/docs/quickstart/hugegraph-server/#3-deploy) +* [Docker Compose Examples](./docker/) +* [Docker README](./docker/README.md) +* [Server Docker README](hugegraph-server/hugegraph-dist/docker/README.md) -### 2. Download +> **Docker Desktop (Mac/Windows)**: The 3-node distributed cluster (`docker/docker-compose-3pd-3store-3server.yml`) uses Docker bridge networking and works on all platforms including Docker Desktop. Allocate at least 12 GB memory to Docker Desktop. -Visit [Download Page](https://hugegraph.apache.org/docs/download/download/) and refer the [doc](https://hugegraph.apache.org/docs/quickstart/hugegraph-server/#32-download-the-binary-tar-tarball) -to download the latest release package and start the server. +> **Note**: Docker images are convenience releases, not **official ASF distribution artifacts**. See [ASF Release Distribution Policy](https://infra.apache.org/release-distribution.html#dockerhub) for details. +> +> **Version Tags**: Use release tags (e.g., `1.7.0`) for stable deployments. The `latest` tag should only be used for testing or development. -**Note:** if you want to use it in the production environment or expose it to the public network, must enable the [AuthSystem](https://hugegraph.apache.org/docs/config/config-authentication/) to ensure safe. -### 3. Build From Source +
+Option 2: Download Binary Package -Visit [Build From Source Page](https://hugegraph.apache.org/docs/quickstart/hugegraph-server/#33-source-code-compilation) and follow the -steps to build the source code and start the server. +Download pre-built packages from the [Download Page](https://hugegraph.apache.org/docs/download/download/): -The project [doc page](https://hugegraph.apache.org/docs/) contains more information on HugeGraph -and provides detailed documentation for users. (Structure / Usage / API / Configs...) +```bash +# Download and extract +# For historical 1.7.0 and earlier releases, use the archive URL and +# set PACKAGE=apache-hugegraph-incubating-{version} instead. +BASE_URL="https://downloads.apache.org/hugegraph/{version}" +PACKAGE="apache-hugegraph-{version}" +# Historical alternative: +# BASE_URL="https://archive.apache.org/dist/incubator/hugegraph/{version}" +# PACKAGE="apache-hugegraph-incubating-{version}" -And here are links of other **HugeGraph** component/repositories: +wget ${BASE_URL}/${PACKAGE}.tar.gz +tar -xzf ${PACKAGE}.tar.gz +cd ${PACKAGE} -1. [hugegraph-toolchain](https://github.com/apache/hugegraph-toolchain) (graph tools **[loader](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-loader)/[dashboard](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-hubble)/[tool](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-tools)/[client](https://github.com/apache/hugegraph-toolchain/tree/master/hugegraph-client)**) -2. [hugegraph-computer](https://github.com/apache/hugegraph-computer) (integrated **graph computing** system) -3. [hugegraph-ai](https://github.com/apache/incubator-hugegraph-ai) (integrated **Graph AI/LLM/KG** system) -4. [hugegraph-website](https://github.com/apache/hugegraph-doc) (**doc & website** code) +# Initialize backend storage +bin/init-store.sh -## License +# Start server +bin/start-hugegraph.sh -HugeGraph is licensed under [Apache 2.0 License](LICENSE). +# Check server status +bin/monitor-hugegraph.sh +``` + +For detailed instructions, see the [Binary Installation Guide](https://hugegraph.apache.org/docs/quickstart/hugegraph-server/#32-download-the-binary-tar-tarball). + +
+ +
+Option 3: Build from Source + +Build from source for development or customization: + +```bash +# Clone repository +git clone https://github.com/apache/hugegraph.git +cd hugegraph + +# Build all modules (skip tests for faster build) +mvn clean package -DskipTests + +# Extract built package +tar -xzf target/apache-hugegraph-{version}.tar.gz +cd apache-hugegraph-{version}/apache-hugegraph-server-{version} + +# Initialize and start +bin/init-store.sh +bin/start-hugegraph.sh +``` + +For detailed build instructions, see [BUILDING.md](BUILDING.md) and [Build from Source Guide](https://hugegraph.apache.org/docs/quickstart/hugegraph-server/#33-source-code-compilation). + +
+ +
+Verify Installation + +Once the server is running, verify the installation: + +```bash +# Check server version +curl http://localhost:8080/versions + +# Expected output: +# { +# "versions": { +# "version": "v1", +# "core": "1.7.0", +# "gremlin": "3.5.1", +# "api": "1.7.0" +# } +# } + +# Try Gremlin console (if installed locally) +bin/gremlin-console.sh + +# In Gremlin console: +gremlin> :remote connect tinkerpop.server conf/remote.yaml +gremlin> :> g.V().limit(5) +``` + +For comprehensive documentation, visit the [HugeGraph Documentation](https://hugegraph.apache.org/docs/). + +
+ +## Module Map + +**Developer Navigation**: Find the right module for your task + +| I want to... | Module | Key Path | +|--------------|--------|----------| +| Understand graph operations | `hugegraph-core` | `StandardHugeGraph.java` | +| Modify REST APIs | `hugegraph-api` | `src/.../api/` | +| Add storage backend | `hugegraph-core` | `BackendStore.java` | +| Develop Gremlin features | `hugegraph-core` | `src/.../traversal/` | +| Develop Cypher features | `hugegraph-api` | `src/.../opencypher/` | +| Work on distributed coordination | `hugegraph-pd` | `hg-pd-core/` | +| Work on distributed storage | `hugegraph-store` | `hg-store-core/` | +| Add backend implementations | `hugegraph-server/hugegraph-{backend}` | `hugegraph-rocksdb/`, `hugegraph-hstore/` | +| Understand configuration | `hugegraph-dist` | `src/assembly/static/conf/` | +| Run tests | `hugegraph-test` | Test suites with multiple profiles | + +For detailed architecture and development guidance, see [AGENTS.md](AGENTS.md). + +
+For Contributors + +**New to HugeGraph?** Follow this path to get started: + +1. **Understand the Architecture** + - Read [AGENTS.md](AGENTS.md) for detailed module structure and development patterns + - Review the [Architecture Diagram](#architecture) above + +2. **Set Up Your Environment** + - Install Java 11+ and Maven 3.5+ + - Follow [BUILDING.md](BUILDING.md) for build instructions + - Configure your IDE to use `.editorconfig` for code style and `style/checkstyle.xml` for Checkstyle rules + +3. **Find Your First Issue** + - Browse [Good First Issues](https://github.com/apache/hugegraph/issues?q=label%3A%22good+first+issue%22) + - Check [Help Wanted Issues](https://github.com/apache/hugegraph/issues?q=label%3A%22help+wanted%22) + +4. **Learn the Codebase** + - Use the [Module Map](#module-map) to navigate + - Try [DeepWiki](https://deepwiki.com/apache/hugegraph) for AI-powered codebase understanding + - Run tests to understand behavior: `mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory` + - Try modifying a test and see what breaks + +5. **Code Standards** + - Line length: 100 characters + - Indentation: 4 spaces + - No star imports + - Commit format: `feat|fix|refactor(module): description` + +6. **Submit Your Contribution** + - Read [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines + - Follow the [Contribution Guidelines](https://hugegraph.apache.org/docs/contribution-guidelines/) + - Use [GitHub Desktop](https://desktop.github.com/) to simplify the PR process + +
## Contributing -- Welcome to contribute to HugeGraph, please see [`How to Contribute`](CONTRIBUTING.md) & [Guidelines](https://hugegraph.apache.org/docs/contribution-guidelines/) for more information. -- Note: It's recommended to use [GitHub Desktop](https://desktop.github.com/) to greatly simplify the PR and commit process. -- Thank you to all the people who already contributed to HugeGraph! +Welcome to contribute to HugeGraph! -[![contributors graph](https://contrib.rocks/image?repo=apache/hugegraph)](https://github.com/apache/incubator-hugegraph/graphs/contributors) +- **How to Contribute**: See [CONTRIBUTING.md](CONTRIBUTING.md) and [Contribution Guidelines](https://hugegraph.apache.org/docs/contribution-guidelines/) +- **Code Style**: Configure your IDE to use `.editorconfig` for code style and `style/checkstyle.xml` for Checkstyle rules +- **PR Tool**: [GitHub Desktop](https://desktop.github.com/) is recommended for simpler workflow -## Thanks +Thank you to all the contributors who have helped make HugeGraph better! + +[![contributors graph](https://contrib.rocks/image?repo=apache/hugegraph)](https://github.com/apache/hugegraph/graphs/contributors) + +## License -HugeGraph relies on the [TinkerPop](http://tinkerpop.apache.org) framework, we refer to the storage structure of Titan and the schema definition of DataStax. -Thanks to TinkerPop, thanks to Titan, thanks to DataStax. Thanks to all other organizations or authors who contributed to the project. +HugeGraph is licensed under [Apache 2.0 License](LICENSE). + +## Community -You are welcome to contribute to HugeGraph, -and we are looking forward to working with you to build an excellent open-source community. +**Get Help & Stay Connected** -## Contact Us +- **[GitHub Issues](https://github.com/apache/hugegraph/issues)**: Report bugs and request features (quick response) +- **Mailing List**: [dev@hugegraph.apache.org](mailto:dev@hugegraph.apache.org) ([subscribe here](https://hugegraph.apache.org/docs/contribution-guidelines/subscribe/)) +- **Slack**: [ASF HugeGraph Channel](https://the-asf.slack.com/archives/C059UU2FJ23) +- **WeChat**: Scan the QR code to follow Apache HugeGraph official account -- [GitHub Issues](https://github.com/apache/hugegraph/issues): Feedback on usage issues and functional requirements (quick response) -- Feedback Email: [dev@hugegraph.apache.org](mailto:dev@hugegraph.apache.org) ([subscriber](https://hugegraph.apache.org/docs/contribution-guidelines/subscribe/) only) -- WeChat public account: Apache HugeGraph, welcome to scan this QR code to follow us. +

+WeChat QR Code +

+ +## Thanks - QR png +HugeGraph relies on the [Apache TinkerPop](http://tinkerpop.apache.org) framework. We are grateful to the TinkerPop community, Titan, and DataStax for their foundational work. Thanks to all contributors and organizations who have helped make HugeGraph possible. +You are welcome to contribute to HugeGraph, and we look forward to working with you to build an excellent open-source community. diff --git a/docker/README.md b/docker/README.md new file mode 100644 index 0000000000..9bc21b1ba7 --- /dev/null +++ b/docker/README.md @@ -0,0 +1,259 @@ +# HugeGraph Docker Deployment + +This directory contains Docker Compose files for running HugeGraph: + +| File | Description | +|------|-------------| +| `docker-compose.yml` | Single-node cluster using pre-built images from Docker Hub | +| `docker-compose.dev.yml` | Single-node cluster built from source (for developers) | +| `docker-compose-3pd-3store-3server.yml` | 3-node distributed cluster (PD + Store + Server) | + +## Prerequisites + +- **Docker Engine** 20.10+ (or Docker Desktop 4.x+) +- **Docker Compose** v2 (included in Docker Desktop) +- **Memory**: Allocate at least **12 GB** to Docker Desktop (Settings → Resources → Memory). The 3-node cluster runs 9 JVM processes (3 PD + 3 Store + 3 Server) which are memory-intensive. Insufficient memory causes OOM kills that appear as silent Raft failures. + +> [!IMPORTANT] +> The 12 GB minimum is for Docker Desktop. On Linux with native Docker, ensure the host has at least 12 GB of free memory. +--- + +## Single-Node Setup + +Two compose files are available for running a single-node cluster (1 PD + 1 Store + 1 Server): + +### Option A: Quick Start (pre-built images) + +Uses pre-built images from Docker Hub. Best for **end users** who want to run HugeGraph quickly. + +```bash +cd docker +HUGEGRAPH_VERSION=1.7.0 docker compose up -d +``` + +- Images: `hugegraph/pd:1.7.0`, `hugegraph/store:1.7.0`, `hugegraph/server:1.7.0` +- `pull_policy: always` — always pulls the specified image tag + +> **Note**: Use release tags (e.g., `1.7.0`) for stable deployments. The `latest` tag is intended for testing or development only. +- PD healthcheck endpoint: `/v1/health` +- Single PD, single Store (`HG_PD_INITIAL_STORE_LIST: store:8500`), single Server +- Server healthcheck endpoint: `/versions` + +### Option B: Development Build (build from source) + +Builds images locally from source Dockerfiles. Best for **developers** who want to test local changes. + +```bash +cd docker +docker compose -f docker-compose.dev.yml up -d +``` + +- Images: built from source via `build: context: ..` with Dockerfiles +- No `pull_policy` — builds locally, doesn't pull +- Entrypoint scripts are baked into the built image (no volume mounts) +- PD healthcheck endpoint: `/v1/health` +- Otherwise identical env vars and structure to the quickstart file + +### Key Differences + +| | `docker-compose.yml` (quickstart) | `docker-compose.dev.yml` (dev build) | +|---|---|---| +| **Images** | Pull from Docker Hub | Build from source | +| **Who it's for** | End users | Developers | +| **pull_policy** | `always` | not set (build) | + +**Verify** (both options): +```bash +curl http://localhost:8080/versions +``` + +--- + +## 3-Node Cluster Quickstart + +```bash +cd docker +HUGEGRAPH_VERSION=1.7.0 docker compose -f docker-compose-3pd-3store-3server.yml up -d + +# To stop and remove all data volumes (clean restart) +docker compose -f docker-compose-3pd-3store-3server.yml down -v +``` + +**Startup ordering** is enforced via `depends_on` with `condition: service_healthy`: + +1. **PD nodes** start first and must pass healthchecks (`/v1/health`) +2. **Store nodes** start after all PD nodes are healthy +3. **Server nodes** start after all Store nodes are healthy + +This ensures PD and Store are healthy before the server starts. The server entrypoint still performs a best-effort partition wait after launch, so partition assignment may take a little longer. + +**Verify the cluster is healthy**: + +```bash +# Check PD health +curl http://localhost:8620/v1/health + +# Check Store health +curl http://localhost:8520/v1/health + +# Check Server (Graph API) +curl http://localhost:8080/versions + +# List registered stores via PD +curl http://localhost:8620/v1/stores + +# List partitions +curl http://localhost:8620/v1/partitions +``` + +--- + +## Environment Variable Reference + +Configuration is injected via environment variables. The old `docker/configs/application-pd*.yml` and `docker/configs/application-store*.yml` files are no longer used. + +### PD Environment Variables + +| Variable | Required | Default | Maps To (`application.yml`) | Description | +|----------|----------|---------|-----------------------------|-------------| +| `HG_PD_GRPC_HOST` | Yes | — | `grpc.host` | This node's hostname/IP for gRPC | +| `HG_PD_RAFT_ADDRESS` | Yes | — | `raft.address` | This node's Raft address (e.g. `pd0:8610`) | +| `HG_PD_RAFT_PEERS_LIST` | Yes | — | `raft.peers-list` | All PD peers (e.g. `pd0:8610,pd1:8610,pd2:8610`) | +| `HG_PD_INITIAL_STORE_LIST` | Yes | — | `pd.initial-store-list` | Expected stores (e.g. `store0:8500,store1:8500,store2:8500`) | +| `HG_PD_GRPC_PORT` | No | `8686` | `grpc.port` | gRPC server port | +| `HG_PD_REST_PORT` | No | `8620` | `server.port` | REST API port | +| `HG_PD_DATA_PATH` | No | `/hugegraph-pd/pd_data` | `pd.data-path` | Metadata storage path | +| `HG_PD_INITIAL_STORE_COUNT` | No | `1` | `pd.initial-store-count` | Min stores for cluster availability | + +**Deprecated aliases** (still work but log a warning): + +| Deprecated | Use Instead | +|------------|-------------| +| `GRPC_HOST` | `HG_PD_GRPC_HOST` | +| `RAFT_ADDRESS` | `HG_PD_RAFT_ADDRESS` | +| `RAFT_PEERS` | `HG_PD_RAFT_PEERS_LIST` | +| `PD_INITIAL_STORE_LIST` | `HG_PD_INITIAL_STORE_LIST` | + +### Store Environment Variables + +| Variable | Required | Default | Maps To (`application.yml`) | Description | +|----------|----------|---------|-----------------------------|-------------| +| `HG_STORE_PD_ADDRESS` | Yes | — | `pdserver.address` | PD gRPC addresses (e.g. `pd0:8686,pd1:8686,pd2:8686`) | +| `HG_STORE_GRPC_HOST` | Yes | — | `grpc.host` | This node's hostname (e.g. `store0`) | +| `HG_STORE_RAFT_ADDRESS` | Yes | — | `raft.address` | This node's Raft address (e.g. `store0:8510`) | +| `HG_STORE_GRPC_PORT` | No | `8500` | `grpc.port` | gRPC server port | +| `HG_STORE_REST_PORT` | No | `8520` | `server.port` | REST API port | +| `HG_STORE_DATA_PATH` | No | `/hugegraph-store/storage` | `app.data-path` | Data storage path | + +**Deprecated aliases** (still work but log a warning): + +| Deprecated | Use Instead | +|------------|-------------| +| `PD_ADDRESS` | `HG_STORE_PD_ADDRESS` | +| `GRPC_HOST` | `HG_STORE_GRPC_HOST` | +| `RAFT_ADDRESS` | `HG_STORE_RAFT_ADDRESS` | + +### Server Environment Variables + +| Variable | Required | Default | Maps To | Description | +|----------|----------|---------|-----------------------------|-------------| +| `HG_SERVER_BACKEND` | Yes | — | `backend` in `hugegraph.properties` | Storage backend (e.g. `hstore`) | +| `HG_SERVER_PD_PEERS` | Yes | — | `pd.peers` | PD cluster addresses (e.g. `pd0:8686,pd1:8686,pd2:8686`) | +| `STORE_REST` | No | — | Used by `wait-partition.sh` | Store REST endpoint for partition verification (e.g. `store0:8520`) | +| `PASSWORD` | No | — | Enables auth mode | Optional authentication password | + +**Deprecated aliases** (still work but log a warning): + +| Deprecated | Use Instead | +|------------|-------------| +| `BACKEND` | `HG_SERVER_BACKEND` | +| `PD_PEERS` | `HG_SERVER_PD_PEERS` | + +--- + +## Port Reference + +The table below reflects the published host ports in `docker-compose-3pd-3store-3server.yml`. +The single-node compose file (`docker-compose.yml`) only publishes the REST/API ports (`8620`, `8520`, `8080`) by default. + +| Service | Container Port | Host Port | Protocol | Purpose | +|---------|---------------|-----------|----------|---------| +| pd0 | 8620 | 8620 | HTTP | REST API | +| pd0 | 8686 | 8686 | gRPC | PD gRPC | +| pd0 | 8610 | — | TCP | Raft (internal only) | +| pd1 | 8620 | 8621 | HTTP | REST API | +| pd1 | 8686 | 8687 | gRPC | PD gRPC | +| pd2 | 8620 | 8622 | HTTP | REST API | +| pd2 | 8686 | 8688 | gRPC | PD gRPC | +| store0 | 8500 | 8500 | gRPC | Store gRPC | +| store0 | 8510 | 8510 | TCP | Raft | +| store0 | 8520 | 8520 | HTTP | REST API | +| store1 | 8500 | 8501 | gRPC | Store gRPC | +| store1 | 8510 | 8511 | TCP | Raft | +| store1 | 8520 | 8521 | HTTP | REST API | +| store2 | 8500 | 8502 | gRPC | Store gRPC | +| store2 | 8510 | 8512 | TCP | Raft | +| store2 | 8520 | 8522 | HTTP | REST API | +| server0 | 8080 | 8080 | HTTP | Graph API | +| server1 | 8080 | 8081 | HTTP | Graph API | +| server2 | 8080 | 8082 | HTTP | Graph API | + +--- + +## Healthcheck Endpoints + +| Service | Endpoint | Expected | +|---------|----------|----------| +| PD | `GET /v1/health` | `200 OK` | +| Store | `GET /v1/health` | `200 OK` | +| Server | `GET /versions` | `200 OK` with version JSON | + +--- + +## Troubleshooting + +### Containers Exiting or Restarting (OOM Kills) + +**Symptom**: Containers exit with code 137, or restart loops. Raft logs show election timeouts. + +**Cause**: Docker Desktop does not have enough memory. The 9 JVM processes require at least 12 GB. + +**Fix**: Docker Desktop → Settings → Resources → Memory → set to **12 GB** or higher. Restart Docker Desktop. + +```bash +# Check if containers were OOM killed +docker inspect hg-pd0 | grep -i oom +docker stats --no-stream +``` + +### Raft Leader Election Failure + +**Symptom**: PD logs show repeated `Leader election timeout`. Store nodes cannot register. + +**Cause**: PD nodes cannot reach each other on the Raft port (8610), or `HG_PD_RAFT_PEERS_LIST` is misconfigured. + +**Fix**: +1. Verify all PD containers are running: `docker compose -f docker-compose-3pd-3store-3server.yml ps` +2. Check PD logs: `docker logs hg-pd0` +3. Verify network connectivity: `docker exec hg-pd0 ping pd1` +4. Ensure `HG_PD_RAFT_PEERS_LIST` is identical on all PD nodes + +### Partition Assignment Not Completing + +**Symptom**: Server starts but graph operations fail. Store logs show `partition not found`. + +**Cause**: PD has not finished assigning partitions to stores, or stores did not register successfully. + +**Fix**: +1. Check registered stores: `curl http://localhost:8620/v1/stores` +2. Check partition status: `curl http://localhost:8620/v1/partitions` +3. Wait for partition assignment (can take 1–3 minutes after all stores register) +4. Check server logs for the `wait-partition.sh` script output: `docker logs hg-server0` + +### Connection Refused Errors + +**Symptom**: Stores cannot connect to PD, or Server cannot connect to Store. + +**Cause**: Services are using `127.0.0.1` instead of container hostnames, or the `hg-net` bridge network is misconfigured. + +**Fix**: Ensure all `HG_*` env vars use container hostnames (`pd0`, `store0`, etc.), not `127.0.0.1` or `localhost`. diff --git a/docker/configs/application-pd0.yml b/docker/configs/application-pd0.yml deleted file mode 100644 index 6531cbafb2..0000000000 --- a/docker/configs/application-pd0.yml +++ /dev/null @@ -1,63 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -spring: - application: - name: hugegraph-pd - -management: - metrics: - export: - prometheus: - enabled: true - endpoints: - web: - exposure: - include: "*" - -logging: - config: 'file:./conf/log4j2.xml' -license: - verify-path: ./conf/verify-license.json - license-path: ./conf/hugegraph.license -grpc: - port: 8686 - host: 127.0.0.1 - -server: - port: 8620 - -pd: - data-path: ./pd_data - patrol-interval: 1800 - initial-store-count: 3 - initial-store-list: 127.0.0.1:8500,127.0.0.1:8501,127.0.0.1:8502 - -raft: - address: 127.0.0.1:8610 - peers-list: 127.0.0.1:8610,127.0.0.1:8611,127.0.0.1:8612 - -store: - max-down-time: 172800 - monitor_data_enabled: true - monitor_data_interval: 1 minute - monitor_data_retention: 1 day - initial-store-count: 1 - -partition: - default-shard-count: 1 - store-max-shard-count: 12 diff --git a/docker/configs/application-pd1.yml b/docker/configs/application-pd1.yml deleted file mode 100644 index 0cf9f54297..0000000000 --- a/docker/configs/application-pd1.yml +++ /dev/null @@ -1,63 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -spring: - application: - name: hugegraph-pd - -management: - metrics: - export: - prometheus: - enabled: true - endpoints: - web: - exposure: - include: "*" - -logging: - config: 'file:./conf/log4j2.xml' -license: - verify-path: ./conf/verify-license.json - license-path: ./conf/hugegraph.license -grpc: - port: 8687 - host: 127.0.0.1 - -server: - port: 8621 - -pd: - data-path: ./pd_data - patrol-interval: 1800 - initial-store-count: 3 - initial-store-list: 127.0.0.1:8500,127.0.0.1:8501,127.0.0.1:8502 - -raft: - address: 127.0.0.1:8611 - peers-list: 127.0.0.1:8610,127.0.0.1:8611,127.0.0.1:8612 - -store: - max-down-time: 172800 - monitor_data_enabled: true - monitor_data_interval: 1 minute - monitor_data_retention: 1 day - initial-store-count: 1 - -partition: - default-shard-count: 1 - store-max-shard-count: 12 diff --git a/docker/configs/application-pd2.yml b/docker/configs/application-pd2.yml deleted file mode 100644 index a0d2c79ea3..0000000000 --- a/docker/configs/application-pd2.yml +++ /dev/null @@ -1,63 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -spring: - application: - name: hugegraph-pd - -management: - metrics: - export: - prometheus: - enabled: true - endpoints: - web: - exposure: - include: "*" - -logging: - config: 'file:./conf/log4j2.xml' -license: - verify-path: ./conf/verify-license.json - license-path: ./conf/hugegraph.license -grpc: - port: 8688 - host: 127.0.0.1 - -server: - port: 8622 - -pd: - data-path: ./pd_data - patrol-interval: 1800 - initial-store-count: 3 - initial-store-list: 127.0.0.1:8500,127.0.0.1:8501,127.0.0.1:8502 - -raft: - address: 127.0.0.1:8612 - peers-list: 127.0.0.1:8610,127.0.0.1:8611,127.0.0.1:8612 - -store: - max-down-time: 172800 - monitor_data_enabled: true - monitor_data_interval: 1 minute - monitor_data_retention: 1 day - initial-store-count: 1 - -partition: - default-shard-count: 1 - store-max-shard-count: 12 diff --git a/docker/configs/application-store0.yml b/docker/configs/application-store0.yml deleted file mode 100644 index d093f1bfbd..0000000000 --- a/docker/configs/application-store0.yml +++ /dev/null @@ -1,57 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -pdserver: - address: 127.0.0.1:8686,127.0.0.1:8687,127.0.0.1:8688 - -management: - metrics: - export: - prometheus: - enabled: true - endpoints: - web: - exposure: - include: "*" - -grpc: - host: 127.0.0.1 - port: 8500 - netty-server: - max-inbound-message-size: 1000MB -raft: - disruptorBufferSize: 1024 - address: 127.0.0.1:8510 - max-log-file-size: 600000000000 - snapshotInterval: 1800 -server: - port: 8520 - -app: - data-path: ./storage - -spring: - application: - name: store-node-grpc-server - profiles: - active: default - include: pd - -logging: - config: 'file:./conf/log4j2.xml' - level: - root: info diff --git a/docker/configs/application-store1.yml b/docker/configs/application-store1.yml deleted file mode 100644 index 0aeba62cf6..0000000000 --- a/docker/configs/application-store1.yml +++ /dev/null @@ -1,57 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -pdserver: - address: 127.0.0.1:8686,127.0.0.1:8687,127.0.0.1:8688 - -management: - metrics: - export: - prometheus: - enabled: true - endpoints: - web: - exposure: - include: "*" - -grpc: - host: 127.0.0.1 - port: 8501 - netty-server: - max-inbound-message-size: 1000MB -raft: - disruptorBufferSize: 1024 - address: 127.0.0.1:8511 - max-log-file-size: 600000000000 - snapshotInterval: 1800 -server: - port: 8521 - -app: - data-path: ./storage - -spring: - application: - name: store-node-grpc-server - profiles: - active: default - include: pd - -logging: - config: 'file:./conf/log4j2.xml' - level: - root: info diff --git a/docker/configs/application-store2.yml b/docker/configs/application-store2.yml deleted file mode 100644 index e18dc62a3c..0000000000 --- a/docker/configs/application-store2.yml +++ /dev/null @@ -1,57 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -pdserver: - address: 127.0.0.1:8686,127.0.0.1:8687,127.0.0.1:8688 - -management: - metrics: - export: - prometheus: - enabled: true - endpoints: - web: - exposure: - include: "*" - -grpc: - host: 127.0.0.1 - port: 8502 - netty-server: - max-inbound-message-size: 1000MB -raft: - disruptorBufferSize: 1024 - address: 127.0.0.1:8512 - max-log-file-size: 600000000000 - snapshotInterval: 1800 -server: - port: 8522 - -app: - data-path: ./storage - -spring: - application: - name: store-node-grpc-server - profiles: - active: default - include: pd - -logging: - config: 'file:./conf/log4j2.xml' - level: - root: info diff --git a/docker/configs/server1-conf/graphs/hugegraph.properties b/docker/configs/server1-conf/graphs/hugegraph.properties deleted file mode 100644 index 66cbccb731..0000000000 --- a/docker/configs/server1-conf/graphs/hugegraph.properties +++ /dev/null @@ -1,19 +0,0 @@ -# auth config: org.apache.hugegraph.auth.HugeFactoryAuthProxy -gremlin.graph=org.apache.hugegraph.HugeFactory - -# cache config -vertex.cache_type=l2 -edge.cache_type=l2 - -store=hugegraph -backend=hstore -serializer=binary - -# pd config -pd.peers=127.0.0.1:8686,127.0.0.1:8687,127.0.0.1:8688 - -# task config -task.scheduler_type=local -task.schedule_period=10 -task.retry=0 -task.wait_timeout=10 diff --git a/docker/configs/server1-conf/gremlin-driver-settings.yaml b/docker/configs/server1-conf/gremlin-driver-settings.yaml deleted file mode 100644 index 2f60ff8379..0000000000 --- a/docker/configs/server1-conf/gremlin-driver-settings.yaml +++ /dev/null @@ -1,25 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8181 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } -} diff --git a/docker/configs/server1-conf/gremlin-server.yaml b/docker/configs/server1-conf/gremlin-server.yaml deleted file mode 100644 index df73386b26..0000000000 --- a/docker/configs/server1-conf/gremlin-server.yaml +++ /dev/null @@ -1,127 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# host and port of gremlin server, need to be consistent with host and port in rest-server.properties -host: 127.0.0.1 -port: 8181 - -# timeout in ms of gremlin query -evaluationTimeout: 30000 - -channelizer: org.apache.tinkerpop.gremlin.server.channel.WsAndHttpChannelizer -# don't set graph at here, this happens after support for dynamically adding graph -graphs: { -} -scriptEngines: { - gremlin-groovy: { - staticImports: [ - org.opencypher.gremlin.process.traversal.CustomPredicates.*', - org.opencypher.gremlin.traversal.CustomFunctions.* - ], - plugins: { - org.apache.hugegraph.plugin.HugeGraphGremlinPlugin: {}, - org.apache.tinkerpop.gremlin.server.jsr223.GremlinServerGremlinPlugin: {}, - org.apache.tinkerpop.gremlin.jsr223.ImportGremlinPlugin: { - classImports: [ - java.lang.Math, - org.apache.hugegraph.backend.id.IdGenerator, - org.apache.hugegraph.type.define.Directions, - org.apache.hugegraph.type.define.NodeRole, - org.apache.hugegraph.masterelection.GlobalMasterInfo, - org.apache.hugegraph.util.DateUtil, - org.apache.hugegraph.traversal.algorithm.CollectionPathsTraverser, - org.apache.hugegraph.traversal.algorithm.CountTraverser, - org.apache.hugegraph.traversal.algorithm.CustomizedCrosspointsTraverser, - org.apache.hugegraph.traversal.algorithm.CustomizePathsTraverser, - org.apache.hugegraph.traversal.algorithm.FusiformSimilarityTraverser, - org.apache.hugegraph.traversal.algorithm.HugeTraverser, - org.apache.hugegraph.traversal.algorithm.JaccardSimilarTraverser, - org.apache.hugegraph.traversal.algorithm.KneighborTraverser, - org.apache.hugegraph.traversal.algorithm.KoutTraverser, - org.apache.hugegraph.traversal.algorithm.MultiNodeShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.NeighborRankTraverser, - org.apache.hugegraph.traversal.algorithm.PathsTraverser, - org.apache.hugegraph.traversal.algorithm.PersonalRankTraverser, - org.apache.hugegraph.traversal.algorithm.SameNeighborTraverser, - org.apache.hugegraph.traversal.algorithm.ShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.SingleSourceShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.SubGraphTraverser, - org.apache.hugegraph.traversal.algorithm.TemplatePathsTraverser, - org.apache.hugegraph.traversal.algorithm.steps.EdgeStep, - org.apache.hugegraph.traversal.algorithm.steps.RepeatEdgeStep, - org.apache.hugegraph.traversal.algorithm.steps.WeightedEdgeStep, - org.apache.hugegraph.traversal.optimize.ConditionP, - org.apache.hugegraph.traversal.optimize.Text, - org.apache.hugegraph.traversal.optimize.TraversalUtil, - org.opencypher.gremlin.traversal.CustomFunctions, - org.opencypher.gremlin.traversal.CustomPredicate - ], - methodImports: [ - java.lang.Math#*, - org.opencypher.gremlin.traversal.CustomPredicate#*, - org.opencypher.gremlin.traversal.CustomFunctions#* - ] - }, - org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: { - files: [scripts/empty-sample.groovy] - } - } - } -} -serializers: - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV2d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV3d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } -metrics: { - consoleReporter: {enabled: false, interval: 180000}, - csvReporter: {enabled: false, interval: 180000, fileName: ./metrics/gremlin-server-metrics.csv}, - jmxReporter: {enabled: false}, - slf4jReporter: {enabled: false, interval: 180000}, - gangliaReporter: {enabled: false, interval: 180000, addressingMode: MULTICAST}, - graphiteReporter: {enabled: false, interval: 180000} -} -maxInitialLineLength: 4096 -maxHeaderSize: 8192 -maxChunkSize: 8192 -maxContentLength: 65536 -maxAccumulationBufferComponents: 1024 -resultIterationBatchSize: 64 -writeBufferLowWaterMark: 32768 -writeBufferHighWaterMark: 65536 -ssl: { - enabled: false -} diff --git a/docker/configs/server1-conf/log4j2.xml b/docker/configs/server1-conf/log4j2.xml deleted file mode 100644 index f1dd7e8395..0000000000 --- a/docker/configs/server1-conf/log4j2.xml +++ /dev/null @@ -1,144 +0,0 @@ - - - - - - logs - hugegraph-server - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docker/configs/server1-conf/remote-objects.yaml b/docker/configs/server1-conf/remote-objects.yaml deleted file mode 100644 index 94ebc99190..0000000000 --- a/docker/configs/server1-conf/remote-objects.yaml +++ /dev/null @@ -1,30 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8181 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - # The duplication of HugeGraphIoRegistry is meant to fix a bug in the - # 'org.apache.tinkerpop.gremlin.driver.Settings:from(Configuration)' method. - ioRegistries: [ - org.apache.hugegraph.io.HugeGraphIoRegistry, - org.apache.hugegraph.io.HugeGraphIoRegistry - ] - } -} diff --git a/docker/configs/server1-conf/remote.yaml b/docker/configs/server1-conf/remote.yaml deleted file mode 100644 index 2f60ff8379..0000000000 --- a/docker/configs/server1-conf/remote.yaml +++ /dev/null @@ -1,25 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8181 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } -} diff --git a/docker/configs/server1-conf/rest-server.properties b/docker/configs/server1-conf/rest-server.properties deleted file mode 100644 index 6e2257ce97..0000000000 --- a/docker/configs/server1-conf/rest-server.properties +++ /dev/null @@ -1,28 +0,0 @@ -# bind url -restserver.url=http://127.0.0.1:8081 -# gremlin server url, need to be consistent with host and port in gremlin-server.yaml -gremlinserver.url=http://127.0.0.1:8181 - -graphs=./conf/graphs - -# configuration of arthas -arthas.telnet_port=8562 -arthas.http_port=8561 -arthas.ip=127.0.0.1 -arthas.disabled_commands=jad - -# authentication configs -# choose 'org.apache.hugegraph.auth.StandardAuthenticator' or -# 'org.apache.hugegraph.auth.ConfigAuthenticator' -#auth.authenticator= - -# rpc server configs for multi graph-servers or raft-servers -rpc.server_host=127.0.0.1 -rpc.server_port=8091 - -# lightweight load balancing (beta) -server.id=server-1 -server.role=master - -# slow query log -log.slow_query_threshold=1000 diff --git a/docker/configs/server2-conf/graphs/hugegraph.properties b/docker/configs/server2-conf/graphs/hugegraph.properties deleted file mode 100644 index 66cbccb731..0000000000 --- a/docker/configs/server2-conf/graphs/hugegraph.properties +++ /dev/null @@ -1,19 +0,0 @@ -# auth config: org.apache.hugegraph.auth.HugeFactoryAuthProxy -gremlin.graph=org.apache.hugegraph.HugeFactory - -# cache config -vertex.cache_type=l2 -edge.cache_type=l2 - -store=hugegraph -backend=hstore -serializer=binary - -# pd config -pd.peers=127.0.0.1:8686,127.0.0.1:8687,127.0.0.1:8688 - -# task config -task.scheduler_type=local -task.schedule_period=10 -task.retry=0 -task.wait_timeout=10 diff --git a/docker/configs/server2-conf/gremlin-driver-settings.yaml b/docker/configs/server2-conf/gremlin-driver-settings.yaml deleted file mode 100644 index 55f38ab97d..0000000000 --- a/docker/configs/server2-conf/gremlin-driver-settings.yaml +++ /dev/null @@ -1,25 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8182 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } -} diff --git a/docker/configs/server2-conf/gremlin-server.yaml b/docker/configs/server2-conf/gremlin-server.yaml deleted file mode 100644 index 048dded559..0000000000 --- a/docker/configs/server2-conf/gremlin-server.yaml +++ /dev/null @@ -1,127 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# host and port of gremlin server, need to be consistent with host and port in rest-server.properties -host: 127.0.0.1 -port: 8182 - -# timeout in ms of gremlin query -evaluationTimeout: 30000 - -channelizer: org.apache.tinkerpop.gremlin.server.channel.WsAndHttpChannelizer -# don't set graph at here, this happens after support for dynamically adding graph -graphs: { -} -scriptEngines: { - gremlin-groovy: { - staticImports: [ - org.opencypher.gremlin.process.traversal.CustomPredicates.*', - org.opencypher.gremlin.traversal.CustomFunctions.* - ], - plugins: { - org.apache.hugegraph.plugin.HugeGraphGremlinPlugin: {}, - org.apache.tinkerpop.gremlin.server.jsr223.GremlinServerGremlinPlugin: {}, - org.apache.tinkerpop.gremlin.jsr223.ImportGremlinPlugin: { - classImports: [ - java.lang.Math, - org.apache.hugegraph.backend.id.IdGenerator, - org.apache.hugegraph.type.define.Directions, - org.apache.hugegraph.type.define.NodeRole, - org.apache.hugegraph.masterelection.GlobalMasterInfo, - org.apache.hugegraph.util.DateUtil, - org.apache.hugegraph.traversal.algorithm.CollectionPathsTraverser, - org.apache.hugegraph.traversal.algorithm.CountTraverser, - org.apache.hugegraph.traversal.algorithm.CustomizedCrosspointsTraverser, - org.apache.hugegraph.traversal.algorithm.CustomizePathsTraverser, - org.apache.hugegraph.traversal.algorithm.FusiformSimilarityTraverser, - org.apache.hugegraph.traversal.algorithm.HugeTraverser, - org.apache.hugegraph.traversal.algorithm.JaccardSimilarTraverser, - org.apache.hugegraph.traversal.algorithm.KneighborTraverser, - org.apache.hugegraph.traversal.algorithm.KoutTraverser, - org.apache.hugegraph.traversal.algorithm.MultiNodeShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.NeighborRankTraverser, - org.apache.hugegraph.traversal.algorithm.PathsTraverser, - org.apache.hugegraph.traversal.algorithm.PersonalRankTraverser, - org.apache.hugegraph.traversal.algorithm.SameNeighborTraverser, - org.apache.hugegraph.traversal.algorithm.ShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.SingleSourceShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.SubGraphTraverser, - org.apache.hugegraph.traversal.algorithm.TemplatePathsTraverser, - org.apache.hugegraph.traversal.algorithm.steps.EdgeStep, - org.apache.hugegraph.traversal.algorithm.steps.RepeatEdgeStep, - org.apache.hugegraph.traversal.algorithm.steps.WeightedEdgeStep, - org.apache.hugegraph.traversal.optimize.ConditionP, - org.apache.hugegraph.traversal.optimize.Text, - org.apache.hugegraph.traversal.optimize.TraversalUtil, - org.opencypher.gremlin.traversal.CustomFunctions, - org.opencypher.gremlin.traversal.CustomPredicate - ], - methodImports: [ - java.lang.Math#*, - org.opencypher.gremlin.traversal.CustomPredicate#*, - org.opencypher.gremlin.traversal.CustomFunctions#* - ] - }, - org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: { - files: [scripts/empty-sample.groovy] - } - } - } -} -serializers: - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV2d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV3d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } -metrics: { - consoleReporter: {enabled: false, interval: 180000}, - csvReporter: {enabled: false, interval: 180000, fileName: ./metrics/gremlin-server-metrics.csv}, - jmxReporter: {enabled: false}, - slf4jReporter: {enabled: false, interval: 180000}, - gangliaReporter: {enabled: false, interval: 180000, addressingMode: MULTICAST}, - graphiteReporter: {enabled: false, interval: 180000} -} -maxInitialLineLength: 4096 -maxHeaderSize: 8192 -maxChunkSize: 8192 -maxContentLength: 65536 -maxAccumulationBufferComponents: 1024 -resultIterationBatchSize: 64 -writeBufferLowWaterMark: 32768 -writeBufferHighWaterMark: 65536 -ssl: { - enabled: false -} diff --git a/docker/configs/server2-conf/log4j2.xml b/docker/configs/server2-conf/log4j2.xml deleted file mode 100644 index f1dd7e8395..0000000000 --- a/docker/configs/server2-conf/log4j2.xml +++ /dev/null @@ -1,144 +0,0 @@ - - - - - - logs - hugegraph-server - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docker/configs/server2-conf/remote-objects.yaml b/docker/configs/server2-conf/remote-objects.yaml deleted file mode 100644 index 39679d8c30..0000000000 --- a/docker/configs/server2-conf/remote-objects.yaml +++ /dev/null @@ -1,30 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8182 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - # The duplication of HugeGraphIoRegistry is meant to fix a bug in the - # 'org.apache.tinkerpop.gremlin.driver.Settings:from(Configuration)' method. - ioRegistries: [ - org.apache.hugegraph.io.HugeGraphIoRegistry, - org.apache.hugegraph.io.HugeGraphIoRegistry - ] - } -} diff --git a/docker/configs/server2-conf/rest-server.properties b/docker/configs/server2-conf/rest-server.properties deleted file mode 100644 index e55fb6b635..0000000000 --- a/docker/configs/server2-conf/rest-server.properties +++ /dev/null @@ -1,26 +0,0 @@ -# bind url -restserver.url=http://127.0.0.1:8082 -# gremlin server url, need to be consistent with host and port in gremlin-server.yaml -gremlinserver.url=http://127.0.0.1:8182 - -graphs=./conf/graphs - -# configuration of arthas -arthas.telnet_port=8572 -arthas.http_port=8571 -arthas.ip=127.0.0.1 -arthas.disabled_commands=jad - -# authentication configs -# choose 'org.apache.hugegraph.auth.StandardAuthenticator' or -# 'org.apache.hugegraph.auth.ConfigAuthenticator' -#auth.authenticator= - -# rpc server configs for multi graph-servers or raft-servers -rpc.server_host=127.0.0.1 -rpc.server_port=8092 -#rpc.server_timeout=30 - -# lightweight load balancing (beta) -server.id=server-2 -server.role=worker diff --git a/docker/configs/server3-conf/graphs/hugegraph.properties b/docker/configs/server3-conf/graphs/hugegraph.properties deleted file mode 100644 index 66cbccb731..0000000000 --- a/docker/configs/server3-conf/graphs/hugegraph.properties +++ /dev/null @@ -1,19 +0,0 @@ -# auth config: org.apache.hugegraph.auth.HugeFactoryAuthProxy -gremlin.graph=org.apache.hugegraph.HugeFactory - -# cache config -vertex.cache_type=l2 -edge.cache_type=l2 - -store=hugegraph -backend=hstore -serializer=binary - -# pd config -pd.peers=127.0.0.1:8686,127.0.0.1:8687,127.0.0.1:8688 - -# task config -task.scheduler_type=local -task.schedule_period=10 -task.retry=0 -task.wait_timeout=10 diff --git a/docker/configs/server3-conf/gremlin-driver-settings.yaml b/docker/configs/server3-conf/gremlin-driver-settings.yaml deleted file mode 100644 index 00ef046699..0000000000 --- a/docker/configs/server3-conf/gremlin-driver-settings.yaml +++ /dev/null @@ -1,25 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8183 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } -} diff --git a/docker/configs/server3-conf/gremlin-server.yaml b/docker/configs/server3-conf/gremlin-server.yaml deleted file mode 100644 index e153926bc9..0000000000 --- a/docker/configs/server3-conf/gremlin-server.yaml +++ /dev/null @@ -1,127 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# host and port of gremlin server, need to be consistent with host and port in rest-server.properties -host: 127.0.0.1 -port: 8183 - -# timeout in ms of gremlin query -evaluationTimeout: 30000 - -channelizer: org.apache.tinkerpop.gremlin.server.channel.WsAndHttpChannelizer -# don't set graph at here, this happens after support for dynamically adding graph -graphs: { -} -scriptEngines: { - gremlin-groovy: { - staticImports: [ - org.opencypher.gremlin.process.traversal.CustomPredicates.*', - org.opencypher.gremlin.traversal.CustomFunctions.* - ], - plugins: { - org.apache.hugegraph.plugin.HugeGraphGremlinPlugin: {}, - org.apache.tinkerpop.gremlin.server.jsr223.GremlinServerGremlinPlugin: {}, - org.apache.tinkerpop.gremlin.jsr223.ImportGremlinPlugin: { - classImports: [ - java.lang.Math, - org.apache.hugegraph.backend.id.IdGenerator, - org.apache.hugegraph.type.define.Directions, - org.apache.hugegraph.type.define.NodeRole, - org.apache.hugegraph.masterelection.GlobalMasterInfo, - org.apache.hugegraph.util.DateUtil, - org.apache.hugegraph.traversal.algorithm.CollectionPathsTraverser, - org.apache.hugegraph.traversal.algorithm.CountTraverser, - org.apache.hugegraph.traversal.algorithm.CustomizedCrosspointsTraverser, - org.apache.hugegraph.traversal.algorithm.CustomizePathsTraverser, - org.apache.hugegraph.traversal.algorithm.FusiformSimilarityTraverser, - org.apache.hugegraph.traversal.algorithm.HugeTraverser, - org.apache.hugegraph.traversal.algorithm.JaccardSimilarTraverser, - org.apache.hugegraph.traversal.algorithm.KneighborTraverser, - org.apache.hugegraph.traversal.algorithm.KoutTraverser, - org.apache.hugegraph.traversal.algorithm.MultiNodeShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.NeighborRankTraverser, - org.apache.hugegraph.traversal.algorithm.PathsTraverser, - org.apache.hugegraph.traversal.algorithm.PersonalRankTraverser, - org.apache.hugegraph.traversal.algorithm.SameNeighborTraverser, - org.apache.hugegraph.traversal.algorithm.ShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.SingleSourceShortestPathTraverser, - org.apache.hugegraph.traversal.algorithm.SubGraphTraverser, - org.apache.hugegraph.traversal.algorithm.TemplatePathsTraverser, - org.apache.hugegraph.traversal.algorithm.steps.EdgeStep, - org.apache.hugegraph.traversal.algorithm.steps.RepeatEdgeStep, - org.apache.hugegraph.traversal.algorithm.steps.WeightedEdgeStep, - org.apache.hugegraph.traversal.optimize.ConditionP, - org.apache.hugegraph.traversal.optimize.Text, - org.apache.hugegraph.traversal.optimize.TraversalUtil, - org.opencypher.gremlin.traversal.CustomFunctions, - org.opencypher.gremlin.traversal.CustomPredicate - ], - methodImports: [ - java.lang.Math#*, - org.opencypher.gremlin.traversal.CustomPredicate#*, - org.opencypher.gremlin.traversal.CustomFunctions#* - ] - }, - org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: { - files: [scripts/empty-sample.groovy] - } - } - } -} -serializers: - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV2d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } - - {className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV3d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } - } -metrics: { - consoleReporter: {enabled: false, interval: 180000}, - csvReporter: {enabled: false, interval: 180000, fileName: ./metrics/gremlin-server-metrics.csv}, - jmxReporter: {enabled: false}, - slf4jReporter: {enabled: false, interval: 180000}, - gangliaReporter: {enabled: false, interval: 180000, addressingMode: MULTICAST}, - graphiteReporter: {enabled: false, interval: 180000} -} -maxInitialLineLength: 4096 -maxHeaderSize: 8192 -maxChunkSize: 8192 -maxContentLength: 65536 -maxAccumulationBufferComponents: 1024 -resultIterationBatchSize: 64 -writeBufferLowWaterMark: 32768 -writeBufferHighWaterMark: 65536 -ssl: { - enabled: false -} diff --git a/docker/configs/server3-conf/log4j2.xml b/docker/configs/server3-conf/log4j2.xml deleted file mode 100644 index f1dd7e8395..0000000000 --- a/docker/configs/server3-conf/log4j2.xml +++ /dev/null @@ -1,144 +0,0 @@ - - - - - - logs - hugegraph-server - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docker/configs/server3-conf/remote-objects.yaml b/docker/configs/server3-conf/remote-objects.yaml deleted file mode 100644 index ce99fcb2f6..0000000000 --- a/docker/configs/server3-conf/remote-objects.yaml +++ /dev/null @@ -1,30 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8183 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - # The duplication of HugeGraphIoRegistry is meant to fix a bug in the - # 'org.apache.tinkerpop.gremlin.driver.Settings:from(Configuration)' method. - ioRegistries: [ - org.apache.hugegraph.io.HugeGraphIoRegistry, - org.apache.hugegraph.io.HugeGraphIoRegistry - ] - } -} diff --git a/docker/configs/server3-conf/remote.yaml b/docker/configs/server3-conf/remote.yaml deleted file mode 100644 index 00ef046699..0000000000 --- a/docker/configs/server3-conf/remote.yaml +++ /dev/null @@ -1,25 +0,0 @@ -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -hosts: [localhost] -port: 8183 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } -} diff --git a/docker/configs/server3-conf/rest-server.properties b/docker/configs/server3-conf/rest-server.properties deleted file mode 100644 index af1d7301db..0000000000 --- a/docker/configs/server3-conf/rest-server.properties +++ /dev/null @@ -1,25 +0,0 @@ -# bind url -restserver.url=http://127.0.0.1:8083 -# gremlin server url, need to be consistent with host and port in gremlin-server.yaml -gremlinserver.url=http://127.0.0.1:8183 - -graphs=./conf/graphs - -# configuration of arthas -arthas.telnet_port=8582 -arthas.http_port=8581 -arthas.ip=127.0.0.1 -arthas.disabled_commands=jad - -# authentication configs -# choose 'org.apache.hugegraph.auth.StandardAuthenticator' or -# 'org.apache.hugegraph.auth.ConfigAuthenticator' -#auth.authenticator= - -# rpc server configs for multi graph-servers or raft-servers -rpc.server_host=127.0.0.1 -rpc.server_port=8093 - -# lightweight load balancing (beta) -server.id=server-3 -server.role=worker diff --git a/docker/docker-compose-3pd-3store-3server.yml b/docker/docker-compose-3pd-3store-3server.yml index f704c1c0f6..fc7930351b 100644 --- a/docker/docker-compose-3pd-3store-3server.yml +++ b/docker/docker-compose-3pd-3store-3server.yml @@ -15,166 +15,188 @@ # limitations under the License. # -# TODO: reuse the configs for same type containers -# User could modify the node nums and the port by themselves -version: "3" +name: hugegraph-3x3 + +networks: + hg-net: + driver: bridge + +volumes: + hg-pd0-data: + hg-pd1-data: + hg-pd2-data: + hg-store0-data: + hg-store1-data: + hg-store2-data: + +# ── Shared service defaults ────────────────────────────────────────── +x-pd-common: &pd-common + image: hugegraph/pd:${HUGEGRAPH_VERSION:-latest} + pull_policy: missing + restart: unless-stopped + networks: [hg-net] + healthcheck: + test: ["CMD-SHELL", "curl -fsS http://localhost:8620/v1/health >/dev/null || exit 1"] + interval: 15s + timeout: 10s + retries: 30 + start_period: 120s + +x-store-common: &store-common + image: hugegraph/store:${HUGEGRAPH_VERSION:-latest} + pull_policy: missing + restart: unless-stopped + networks: [hg-net] + depends_on: + pd0: { condition: service_healthy } + pd1: { condition: service_healthy } + pd2: { condition: service_healthy } + healthcheck: + test: ["CMD-SHELL", "curl -fsS http://localhost:8520/v1/health >/dev/null || exit 1"] + interval: 15s + timeout: 15s + retries: 40 + start_period: 120s + +x-server-common: &server-common + image: hugegraph/server:${HUGEGRAPH_VERSION:-latest} + pull_policy: missing + restart: unless-stopped + networks: [hg-net] + depends_on: + store0: { condition: service_healthy } + store1: { condition: service_healthy } + store2: { condition: service_healthy } + environment: + STORE_REST: store0:8520 + HG_SERVER_BACKEND: hstore + HG_SERVER_PD_PEERS: pd0:8686,pd1:8686,pd2:8686 + healthcheck: + test: ["CMD-SHELL", "curl -fsS http://localhost:8080/versions >/dev/null || exit 1"] + interval: 10s + timeout: 5s + retries: 30 + start_period: 60s + +# ── Services ────────────────────────────────────────────────────────── services: + # --- PD cluster (3 nodes) --- pd0: - image: hugegraph/pd - container_name: pd0 + <<: *pd-common + container_name: hg-pd0 hostname: pd0 - network_mode: host - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8620"] - interval: 10s - timeout: 5s - retries: 3 + networks: [ hg-net ] + environment: + HG_PD_GRPC_HOST: pd0 + HG_PD_GRPC_PORT: "8686" + HG_PD_REST_PORT: "8620" + HG_PD_RAFT_ADDRESS: pd0:8610 + HG_PD_RAFT_PEERS_LIST: pd0:8610,pd1:8610,pd2:8610 + HG_PD_INITIAL_STORE_LIST: store0:8500,store1:8500,store2:8500 + HG_PD_DATA_PATH: /hugegraph-pd/pd_data + HG_PD_INITIAL_STORE_COUNT: 3 + ports: ["8620:8620", "8686:8686"] volumes: - - ./configs/application-pd0.yml:/hugegraph-pd/conf/application.yml + - hg-pd0-data:/hugegraph-pd/pd_data pd1: - image: hugegraph/pd - container_name: pd1 + <<: *pd-common + container_name: hg-pd1 hostname: pd1 - network_mode: host - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8621"] - interval: 10s - timeout: 5s - retries: 3 + networks: [ hg-net ] + environment: + HG_PD_GRPC_HOST: pd1 + HG_PD_GRPC_PORT: "8686" + HG_PD_REST_PORT: "8620" + HG_PD_RAFT_ADDRESS: pd1:8610 + HG_PD_RAFT_PEERS_LIST: pd0:8610,pd1:8610,pd2:8610 + HG_PD_INITIAL_STORE_LIST: store0:8500,store1:8500,store2:8500 + HG_PD_DATA_PATH: /hugegraph-pd/pd_data + HG_PD_INITIAL_STORE_COUNT: 3 + ports: ["8621:8620", "8687:8686"] volumes: - - ./configs/application-pd1.yml:/hugegraph-pd/conf/application.yml + - hg-pd1-data:/hugegraph-pd/pd_data pd2: - image: hugegraph/pd - container_name: pd2 + <<: *pd-common + container_name: hg-pd2 hostname: pd2 - network_mode: host - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8622"] - interval: 10s - timeout: 5s - retries: 3 + networks: [ hg-net ] + environment: + HG_PD_GRPC_HOST: pd2 + HG_PD_GRPC_PORT: "8686" + HG_PD_REST_PORT: "8620" + HG_PD_RAFT_ADDRESS: pd2:8610 + HG_PD_RAFT_PEERS_LIST: pd0:8610,pd1:8610,pd2:8610 + HG_PD_INITIAL_STORE_LIST: store0:8500,store1:8500,store2:8500 + HG_PD_DATA_PATH: /hugegraph-pd/pd_data + HG_PD_INITIAL_STORE_COUNT: 3 + ports: ["8622:8620", "8688:8686"] volumes: - - ./configs/application-pd2.yml:/hugegraph-pd/conf/application.yml + - hg-pd2-data:/hugegraph-pd/pd_data + # --- Store cluster (3 nodes) --- store0: - image: hugegraph/store - container_name: store0 + <<: *store-common + container_name: hg-store0 hostname: store0 - network_mode: host - depends_on: - pd0: - condition: service_healthy - pd1: - condition: service_healthy - pd2: - condition: service_healthy - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8520"] - interval: 10s - timeout: 5s - retries: 3 + environment: + HG_STORE_PD_ADDRESS: pd0:8686,pd1:8686,pd2:8686 + HG_STORE_GRPC_HOST: store0 + HG_STORE_GRPC_PORT: "8500" + HG_STORE_REST_PORT: "8520" + HG_STORE_RAFT_ADDRESS: store0:8510 + HG_STORE_DATA_PATH: /hugegraph-store/storage + ports: ["8500:8500", "8510:8510", "8520:8520"] volumes: - - ./configs/application-store0.yml:/hugegraph-store/conf/application.yml + - hg-store0-data:/hugegraph-store/storage store1: - image: hugegraph/store - container_name: store1 + <<: *store-common + container_name: hg-store1 hostname: store1 - network_mode: host - depends_on: - pd0: - condition: service_healthy - pd1: - condition: service_healthy - pd2: - condition: service_healthy - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8521"] - interval: 10s - timeout: 5s - retries: 3 + environment: + HG_STORE_PD_ADDRESS: pd0:8686,pd1:8686,pd2:8686 + HG_STORE_GRPC_HOST: store1 + HG_STORE_GRPC_PORT: "8500" + HG_STORE_REST_PORT: "8520" + HG_STORE_RAFT_ADDRESS: store1:8510 + HG_STORE_DATA_PATH: /hugegraph-store/storage + ports: ["8501:8500", "8511:8510", "8521:8520"] volumes: - - ./configs/application-store1.yml:/hugegraph-store/conf/application.yml + - hg-store1-data:/hugegraph-store/storage store2: - image: hugegraph/store - container_name: store2 + <<: *store-common + container_name: hg-store2 hostname: store2 - network_mode: host - depends_on: - pd0: - condition: service_healthy - pd1: - condition: service_healthy - pd2: - condition: service_healthy - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8522"] - interval: 10s - timeout: 5s - retries: 3 + environment: + HG_STORE_PD_ADDRESS: pd0:8686,pd1:8686,pd2:8686 + HG_STORE_GRPC_HOST: store2 + HG_STORE_GRPC_PORT: "8500" + HG_STORE_REST_PORT: "8520" + HG_STORE_RAFT_ADDRESS: store2:8510 + HG_STORE_DATA_PATH: /hugegraph-store/storage + ports: ["8502:8500", "8512:8510", "8522:8520"] volumes: - - ./configs/application-store2.yml:/hugegraph-store/conf/application.yml + - hg-store2-data:/hugegraph-store/storage + + # --- Server cluster (3 nodes) --- + server0: + <<: *server-common + container_name: hg-server0 + hostname: server0 + ports: ["8080:8080"] server1: - image: hugegraph/server - container_name: server1 + <<: *server-common + container_name: hg-server1 hostname: server1 - network_mode: host - depends_on: - store0: - condition: service_healthy - store1: - condition: service_healthy - store2: - condition: service_healthy - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8081"] - interval: 10s - timeout: 5s - retries: 3 - volumes: - - ./configs/server1-conf:/hugegraph-server/conf + ports: ["8081:8080"] server2: - image: hugegraph/server - container_name: server2 + <<: *server-common + container_name: hg-server2 hostname: server2 - network_mode: host - depends_on: - store0: - condition: service_healthy - store1: - condition: service_healthy - store2: - condition: service_healthy - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8082"] - interval: 10s - timeout: 5s - retries: 3 - volumes: - - ./configs/server2-conf:/hugegraph-server/conf - - server3: - image: hugegraph/server - container_name: server3 - hostname: server3 - network_mode: host - depends_on: - store0: - condition: service_healthy - store1: - condition: service_healthy - store2: - condition: service_healthy - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8083"] - interval: 10s - timeout: 5s - retries: 3 - volumes: - - ./configs/server3-conf:/hugegraph-server/conf + ports: ["8082:8080"] diff --git a/docker/docker-compose.dev.yml b/docker/docker-compose.dev.yml new file mode 100644 index 0000000000..aa0736a38b --- /dev/null +++ b/docker/docker-compose.dev.yml @@ -0,0 +1,106 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +name: hugegraph-single + +networks: + hg-net: + driver: bridge + +volumes: + hg-pd-data: + hg-store-data: + +services: + pd: + build: + context: .. + dockerfile: hugegraph-pd/Dockerfile + container_name: hg-pd + hostname: pd + restart: unless-stopped + networks: [hg-net] + environment: + HG_PD_GRPC_HOST: pd + HG_PD_GRPC_PORT: "8686" + HG_PD_REST_PORT: "8620" + HG_PD_RAFT_ADDRESS: pd:8610 + HG_PD_RAFT_PEERS_LIST: pd:8610 + HG_PD_INITIAL_STORE_LIST: store:8500 + HG_PD_DATA_PATH: /hugegraph-pd/pd_data + ports: + - "8620:8620" + volumes: + - hg-pd-data:/hugegraph-pd/pd_data + healthcheck: + test: ["CMD-SHELL", "curl -fsS http://localhost:8620/v1/health >/dev/null || exit 1"] + interval: 10s + timeout: 5s + retries: 12 + start_period: 20s + + store: + build: + context: .. + dockerfile: hugegraph-store/Dockerfile + container_name: hg-store + hostname: store + restart: unless-stopped + networks: [hg-net] + depends_on: + pd: + condition: service_healthy + environment: + HG_STORE_PD_ADDRESS: pd:8686 + HG_STORE_GRPC_HOST: store + HG_STORE_GRPC_PORT: "8500" + HG_STORE_REST_PORT: "8520" + HG_STORE_RAFT_ADDRESS: store:8510 + HG_STORE_DATA_PATH: /hugegraph-store/storage + ports: + - "8520:8520" + volumes: + - hg-store-data:/hugegraph-store/storage + healthcheck: + test: ["CMD-SHELL", "curl -fsS http://localhost:8520/v1/health >/dev/null || exit 1"] + interval: 10s + timeout: 10s + retries: 30 + start_period: 30s + + server: + build: + context: .. + dockerfile: hugegraph-server/Dockerfile-hstore + container_name: hg-server + hostname: server + restart: unless-stopped + networks: [hg-net] + depends_on: + store: + condition: service_healthy + environment: + HG_SERVER_BACKEND: hstore + HG_SERVER_PD_PEERS: pd:8686 + ports: + - "8080:8080" + healthcheck: + test: ["CMD-SHELL", "curl -fsS http://localhost:8080/versions >/dev/null || exit 1"] + interval: 10s + timeout: 5s + retries: 30 + start_period: 60s diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml index 0c90c1e451..953c438f58 100644 --- a/docker/docker-compose.yml +++ b/docker/docker-compose.yml @@ -14,45 +14,90 @@ # See the License for the specific language governing permissions and # limitations under the License. # +name: hugegraph-single -version: "3" +networks: + hg-net: + driver: bridge + +volumes: + hg-pd-data: + hg-store-data: services: + pd: - image: hugegraph/pd - container_name: pd + image: hugegraph/pd:${HUGEGRAPH_VERSION:-latest} + pull_policy: always + container_name: hg-pd hostname: pd - network_mode: host + restart: unless-stopped + networks: [hg-net] + environment: + HG_PD_GRPC_HOST: pd + HG_PD_GRPC_PORT: "8686" + HG_PD_REST_PORT: "8620" + HG_PD_RAFT_ADDRESS: pd:8610 + HG_PD_RAFT_PEERS_LIST: pd:8610 + HG_PD_INITIAL_STORE_LIST: store:8500 + HG_PD_DATA_PATH: /hugegraph-pd/pd_data + ports: + - "8620:8620" + volumes: + - hg-pd-data:/hugegraph-pd/pd_data healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8620"] + test: ["CMD-SHELL", "curl -fsS http://localhost:8620/v1/health >/dev/null || exit 1"] interval: 10s timeout: 5s - retries: 3 + retries: 12 + start_period: 30s store: - image: hugegraph/store - container_name: store + image: hugegraph/store:${HUGEGRAPH_VERSION:-latest} + pull_policy: always + container_name: hg-store hostname: store - network_mode: host + restart: unless-stopped + networks: [hg-net] depends_on: pd: condition: service_healthy + environment: + HG_STORE_PD_ADDRESS: pd:8686 + HG_STORE_GRPC_HOST: store + HG_STORE_GRPC_PORT: "8500" + HG_STORE_REST_PORT: "8520" + HG_STORE_RAFT_ADDRESS: store:8510 + HG_STORE_DATA_PATH: /hugegraph-store/storage + ports: + - "8520:8520" + volumes: + - hg-store-data:/hugegraph-store/storage healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8520"] + test: ["CMD-SHELL", "curl -fsS http://localhost:8520/v1/health >/dev/null || exit 1"] interval: 10s - timeout: 5s - retries: 3 + timeout: 10s + retries: 30 + start_period: 60s server: - image: hugegraph/server - container_name: server + image: hugegraph/server:${HUGEGRAPH_VERSION:-latest} + pull_policy: always + container_name: hg-server hostname: server - network_mode: host + restart: unless-stopped + networks: [hg-net] depends_on: store: condition: service_healthy + environment: + HG_SERVER_BACKEND: hstore + HG_SERVER_PD_PEERS: pd:8686 + ports: + - "8080:8080" healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8080"] + test: ["CMD-SHELL", "curl -fsS http://localhost:8080/versions >/dev/null || exit 1"] interval: 10s timeout: 5s - retries: 3 + retries: 30 + start_period: 60s diff --git a/docker/hbase/Dockerfile b/docker/hbase/Dockerfile new file mode 100644 index 0000000000..d533415ce7 --- /dev/null +++ b/docker/hbase/Dockerfile @@ -0,0 +1,109 @@ +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Standalone HBase 2.6.5 image for HugeGraph HBase backend testing. +# Exposes ZooKeeper on 2181 with znode /hbase (matching hugegraph.properties defaults). + +FROM eclipse-temurin:11-jre-jammy + +ARG HBASE_VERSION=2.6.5 +ARG HBASE_PRIMARY_URL=https://archive.apache.org/dist/hbase/${HBASE_VERSION}/hbase-${HBASE_VERSION}-bin.tar.gz +ARG HBASE_FALLBACK_URL=https://downloads.apache.org/hbase/${HBASE_VERSION}/hbase-${HBASE_VERSION}-bin.tar.gz +ARG ALLOW_UNVERIFIED_DOWNLOAD=false + +ENV HBASE_VERSION=${HBASE_VERSION} +ENV HBASE_HOME=/opt/hbase +ENV PATH=${HBASE_HOME}/bin:${PATH} + +RUN apt-get update && apt-get install -y --no-install-recommends \ + curl \ + netcat-openbsd \ + && rm -rf /var/lib/apt/lists/* + +RUN set -eux; \ + download_ok=0; \ + downloaded_url=""; \ + for url in "${HBASE_PRIMARY_URL}" "${HBASE_FALLBACK_URL}"; do \ + [ -n "${url}" ] || continue; \ + echo "Downloading HBase from ${url}"; \ + if curl -fL --retry 8 --retry-delay 5 --retry-all-errors \ + --connect-timeout 30 --max-time 1800 "${url}" -o /tmp/hbase.tar.gz; then \ + download_ok=1; \ + downloaded_url="${url}"; \ + break; \ + fi; \ + echo "Download failed for ${url}, trying next source..."; \ + rm -f /tmp/hbase.tar.gz; \ + done; \ + if [ "${download_ok}" -ne 1 ]; then \ + echo "Unable to download HBase ${HBASE_VERSION} tarball from configured sources"; \ + exit 1; \ + fi; \ + checksum_ok=0; \ + for checksum_url in "${downloaded_url}.sha512" "${HBASE_PRIMARY_URL}.sha512" "${HBASE_FALLBACK_URL}.sha512"; do \ + [ -n "${checksum_url}" ] || continue; \ + if curl -fL --retry 5 --retry-delay 3 --retry-all-errors \ + --connect-timeout 30 "${checksum_url}" -o /tmp/hbase.tar.gz.sha512 2>/dev/null; then \ + checksum_ok=1; \ + break; \ + fi; \ + done; \ + if [ "${checksum_ok}" -eq 1 ]; then \ + echo "Verifying SHA512 checksum..."; \ + expected_hash=$(grep -Eio '[a-f0-9]{128}' /tmp/hbase.tar.gz.sha512 | head -n 1 | tr 'A-F' 'a-f' || true); \ + if [ -z "$expected_hash" ]; then \ + expected_hash=$(awk '{for (i = 1; i <= NF; i++) if (length($i) >= 8 && $i ~ /^[0-9A-Fa-f]+$/) hash = hash $i} END {if (length(hash) >= 128) print tolower(substr(hash, 1, 128))}' /tmp/hbase.tar.gz.sha512 || true); \ + fi; \ + if [ -n "$expected_hash" ]; then \ + actual_hash=$(sha512sum /tmp/hbase.tar.gz | awk '{print $1}'); \ + if [ "$expected_hash" = "$actual_hash" ]; then \ + echo "SHA512 verified OK"; \ + else \ + echo "ERROR: SHA512 mismatch"; \ + echo " Expected: $expected_hash"; \ + echo " Actual: $actual_hash"; \ + exit 1; \ + fi; \ + else \ + if [ "${ALLOW_UNVERIFIED_DOWNLOAD}" = "true" ]; then \ + echo "WARNING: Could not parse SHA512 file (ALLOW_UNVERIFIED_DOWNLOAD=true)"; \ + else \ + echo "ERROR: Could not parse SHA512 file"; \ + exit 1; \ + fi; \ + fi; \ + else \ + if [ "${ALLOW_UNVERIFIED_DOWNLOAD}" = "true" ]; then \ + echo "WARNING: Could not download SHA512 file (ALLOW_UNVERIFIED_DOWNLOAD=true)"; \ + else \ + echo "ERROR: Could not download SHA512 file"; \ + exit 1; \ + fi; \ + fi; \ + tar -xzf /tmp/hbase.tar.gz -C /opt; \ + mv /opt/hbase-${HBASE_VERSION} ${HBASE_HOME}; \ + rm -f /tmp/hbase.tar.gz /tmp/hbase.tar.gz.sha512 + +# hbase-site.xml: standalone mode, znode=/hbase (matches hugegraph.properties) +COPY hbase-site.xml ${HBASE_HOME}/conf/hbase-site.xml + +# Entrypoint: start HBase then tail the master log +COPY entrypoint.sh /entrypoint.sh +RUN chmod +x /entrypoint.sh + +EXPOSE 2181 16000 16010 16020 16030 + +ENTRYPOINT ["/entrypoint.sh"] + diff --git a/docker/hbase/README.md b/docker/hbase/README.md new file mode 100644 index 0000000000..fd72514602 --- /dev/null +++ b/docker/hbase/README.md @@ -0,0 +1,303 @@ +# HugeGraph + HBase Backend + +This guide covers running HugeGraph with HBase backend. + +> All commands below run from the repository root (this project folder). + +Use this once at the start of your terminal session: + +```bash +ROOT_DIR="$(git rev-parse --show-toplevel 2>/dev/null || pwd)" +cd "$ROOT_DIR" +``` + +--- + +## Quick Start Paths (Choose One) + +
+Option 1: Standalone HugeGraph (using start-hugegraph.sh) + +Prerequisite: build local artifact first. +mvn clean package -DskipTests +``` +cd "$ROOT_DIR" +``` + +```bash +# 1) Start HBase +docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml down -v +docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml build --no-cache hbase +HBASE_MASTER_HOSTNAME=localhost HBASE_REGIONSERVER_HOSTNAME=localhost \ +docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml up -d +until docker exec hg-hbase-test nc -z localhost 2181 >/dev/null 2>&1; do sleep 2; done +echo "HBase ZooKeeper is reachable on 2181" +# Optional troubleshooting stream: +# docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml logs -f hbase +``` +```bash +# 2) Configure HugeGraph (standalone runtime) +SERVER_DIR="$(find . -maxdepth 4 -type d -path './hugegraph-server/apache-hugegraph-server-*' | head -n 1)" +[ -n "$SERVER_DIR" ] || { echo "Build artifact not found"; exit 1; } +CONF="$SERVER_DIR/conf/graphs/hugegraph.properties" + +perl -pi -e 's/^backend=.*/backend=hbase/' "$CONF" +perl -pi -e 's/^serializer=.*/serializer=hbase/' "$CONF" +perl -pi -e 's/^#(hbase\.hosts=.*)/$1/' "$CONF" +perl -pi -e 's/^#(hbase\.port=.*)/$1/' "$CONF" +perl -pi -e 's/^#(hbase\.znode_parent=.*)/$1/' "$CONF" +perl -pi -e 's/^hbase\.hosts=.*/hbase.hosts=localhost/' "$CONF" +perl -pi -e 's/^hbase\.port=.*/hbase.port=2181/' "$CONF" +perl -pi -e 's|^hbase\.znode_parent=.*|hbase.znode_parent=/hbase|' "$CONF" + +grep -E '^(backend|serializer|hbase\.)' "$CONF" +``` + +```bash +# 3) Init and start server +cd "$SERVER_DIR" +printf 'pa\npa\n' | ./bin/init-store.sh +./bin/start-hugegraph.sh + +# 4) Verify backend logs mention hbase +cd "$ROOT_DIR" +grep -Eai 'hbase|rocksdb|hstore' "$SERVER_DIR"/logs/*.log | tail -n 30 +``` + +
+ +
+Option 2: Docker HugeGraph (fully containerized) + +``` +cd "$ROOT_DIR" +``` + +```bash +# 1) Start HBase +docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml down -v +docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml build --no-cache hbase +HBASE_HOSTNAME=hbase docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml up -d +until docker exec hg-hbase-test nc -z localhost 2181 >/dev/null 2>&1; do sleep 2; done +echo "HBase ZooKeeper is reachable on 2181" +# Optional troubleshooting stream: +# docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml logs -f hbase +``` + +```bash +# 2) Build HugeGraph server image +docker build -f hugegraph-server/Dockerfile -t hugegraph/server:dev . + +# 3) Resolve HBase network +HBASE_NETWORK="$(docker inspect -f '{{range $k,$v := .NetworkSettings.Networks}}{{println $k}}{{end}}' hg-hbase-test | head -n 1)" +echo "$HBASE_NETWORK" +``` + +```bash +# 4) One-shot init-store +docker rm -f hg-server-init >/dev/null 2>&1 || true +docker run --rm --name hg-server-init \ + --network "$HBASE_NETWORK" \ + hugegraph/server:dev \ + bash -lc ' + set -euo pipefail + CONF=/hugegraph-server/conf/graphs/hugegraph.properties + perl -pi -e "s/^backend=.*/backend=hbase/" "$CONF" + perl -pi -e "s/^serializer=.*/serializer=hbase/" "$CONF" + perl -pi -e "s/^#(hbase\.hosts=.*)/\$1/" "$CONF" + perl -pi -e "s/^#(hbase\.port=.*)/\$1/" "$CONF" + perl -pi -e "s/^#(hbase\.znode_parent=.*)/\$1/" "$CONF" + perl -pi -e "s/^hbase\.hosts=.*/hbase.hosts=hbase/" "$CONF" + perl -pi -e "s/^hbase\.port=.*/hbase.port=2181/" "$CONF" + perl -pi -e "s|^hbase\.znode_parent=.*|hbase.znode_parent=/hbase|" "$CONF" + printf "pa\npa\n" | ./bin/init-store.sh + ' +``` + +```bash +# 5) Start HugeGraph container +docker rm -f hg-server-dev-hbase >/dev/null 2>&1 || true +docker run -d --name hg-server-dev-hbase \ + --network "$HBASE_NETWORK" \ + -p 8080:8080 \ + -p 8182:8182 \ + hugegraph/server:dev \ + bash -lc ' + set -euo pipefail + CONF=/hugegraph-server/conf/graphs/hugegraph.properties + perl -pi -e "s/^backend=.*/backend=hbase/" "$CONF" + perl -pi -e "s/^serializer=.*/serializer=hbase/" "$CONF" + perl -pi -e "s/^#(hbase\.hosts=.*)/\$1/" "$CONF" + perl -pi -e "s/^#(hbase\.port=.*)/\$1/" "$CONF" + perl -pi -e "s/^#(hbase\.znode_parent=.*)/\$1/" "$CONF" + perl -pi -e "s/^hbase\.hosts=.*/hbase.hosts=hbase/" "$CONF" + perl -pi -e "s/^hbase\.port=.*/hbase.port=2181/" "$CONF" + perl -pi -e "s|^hbase\.znode_parent=.*|hbase.znode_parent=/hbase|" "$CONF" + ./bin/start-hugegraph.sh -t 120 + tail -f /hugegraph-server/logs/hugegraph-server.log + ' +``` + +```bash +# 6) Verify hbase backend +docker exec hg-server-dev-hbase bash -lc "grep -E '^(backend|serializer|hbase\.)' /hugegraph-server/conf/graphs/hugegraph.properties" +docker exec hg-server-dev-hbase bash -lc "grep -Ei 'hbase|rocksdb|hstore' /hugegraph-server/logs/*.log | tail -n 30" +``` + +
+ +After either path is up, run the shared tests below. + +--- + +## Common Testing Steps + +### Apache HugeGraph Persistent Runbook (REST Engine) + +### Prerequisites and Constants + +- Base URL: `http://localhost:8080` +- Graph target name: `hugegraph` +- Storage backend: persistent (HBase/Cassandra/RocksDB) + +--- + +### Step 1: Purge Database (Fresh Restart) + +Wipe any conflicting test records and data schema. + +```bash +curl -X DELETE "http://localhost:8080/graphspaces/DEFAULT/graphs/hugegraph/clear?confirm_message=I%27m+sure+to+delete+all+data" +``` + +Status `204 No Content` confirms success. + +--- + +### Step 2: Provision Structural Schema + +1) Register property keys: + +```bash +curl -X POST -H "Content-Type: application/json" \ + -d '{"name": "name", "data_type": "TEXT", "cardinality": "SINGLE"}' \ + "http://localhost:8080/graphs/hugegraph/schema/propertykeys" +``` + +2) Register vertex label (PRIMARY_KEY): + +```bash +curl -X POST -H "Content-Type: application/json" \ + -d '{"name": "person", "id_strategy": "PRIMARY_KEY", "properties": ["name"], "primary_keys": ["name"]}' \ + "http://localhost:8080/graphs/hugegraph/schema/vertexlabels" +``` + +3) Register edge label: + +```bash +curl -X POST -H "Content-Type: application/json" \ + -d '{"name": "knows", "source_label": "person", "target_label": "person", "properties": []}' \ + "http://localhost:8080/graphs/hugegraph/schema/edgelabels" +``` + +--- + +### Step 3: Populate Graph Elements + +1) Batch write vertices (Alice and Bob): + +```bash +curl -X POST -H "Content-Type: application/json" \ + -d '[{"label": "person", "properties": {"name": "Alice"}}, {"label": "person", "properties": {"name": "Bob"}}]' \ + "http://localhost:8080/graphs/hugegraph/graph/vertices/batch" +``` + +Response should include IDs similar to `1:Alice` and `1:Bob`. + +2) Create directed edge (Alice knows Bob): + +```bash +curl -X POST -H "Content-Type: application/json" \ + -d '{"label": "knows", "outV": "1:Alice", "inV": "1:Bob", "properties": {}}' \ + "http://localhost:8080/graphs/hugegraph/graph/edges" +``` + +--- + +### Step 4: Synchronous Verification and Traversal + +1) Verify target K-hop output: + +```bash +curl -s "http://localhost:8080/graphs/hugegraph/traversers/kout?source=%221:Alice%22&direction=OUT&max_depth=1" +``` + +Expected output: `{"vertices":["1:Bob"]}` + +2) Verify relation path structure: + +```bash +curl -s "http://localhost:8080/graphs/hugegraph/traversers/rays?source=%221:Alice%22&direction=OUT&label=knows&max_depth=1" +``` + +Expected output contains: `rays":[{"objects":["1:Alice","1:Bob"]}]` + +--- + +### Troubleshooting Cheat Sheet + +- URI syntax error: do not append literal `"` inside bare URLs. Use URL-encoded values (`%22`). +- Property missing errors: prefer native `/traversers/*` APIs for synchronous reads. + +--- + +## Cleanup + +Run cleanup only after testing is complete. + +### Standalone HugeGraph + Docker HBase + +```bash +cd "$SERVER_DIR" && ./bin/stop-hugegraph.sh +cd "$ROOT_DIR" +docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml down -v +``` + +### Docker HugeGraph + Docker HBase + +```bash +docker rm -f hg-server-init >/dev/null 2>&1 || true +docker rm -f hg-server-dev-hbase +docker compose -p hg-hbase -f docker/hbase/docker-compose.hbase.yml down -v +``` + +--- + +## Troubleshooting + +| Symptom | Fix | +|---|---| +| `UnknownHostException: hbase:16000` | HugeGraph container is not on same Docker network as HBase. Verify `HBASE_NETWORK` and `--network`. | +| RocksDB logs in server output | `backend=rocksdb` still active; re-run backend config and restart. | +| `TableNotFoundException` on API calls | Tables not initialized; re-run `init-store.sh` from selected path. | +| Port 8182 already in use | `lsof -i :8182` then `kill `. | +| HBase container not starting | Check `lsof -i :2181`; increase Docker memory to >= 4 GB. | + +--- + +## Verification Checklist + +- [ ] `backend=hbase` in `hugegraph.properties` +- [ ] Server logs show HBase client messages (not RocksDB/HStore) +- [ ] HBase tables exist in `default_hugegraph:*` +- [ ] REST runbook queries return expected graph data +- [ ] Data survives server restart + +--- + +## References + +- HBase official docs: https://hbase.apache.org/ +- HugeGraph HBase backend: `hugegraph-server/hugegraph-hbase/` +- HBase Docker Compose: `docker/hbase/docker-compose.hbase.yml` +- HBase Docker config: `docker/hbase/hbase-site.xml` diff --git a/docker/hbase/docker-compose.hbase.yml b/docker/hbase/docker-compose.hbase.yml new file mode 100644 index 0000000000..c5266844c5 --- /dev/null +++ b/docker/hbase/docker-compose.hbase.yml @@ -0,0 +1,79 @@ +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# HBase standalone for local HugeGraph HBase backend development & testing. +# +# Usage: +# Start: docker compose -f docker/hbase/docker-compose.hbase.yml up -d +# Standalone HugeGraph on host: +# HBASE_MASTER_HOSTNAME=localhost HBASE_REGIONSERVER_HOSTNAME=localhost \ +# docker compose -f docker/hbase/docker-compose.hbase.yml up -d +# Wait: until docker exec hg-hbase-test nc -z localhost 2181; do sleep 2; done +# Verify: nc -z localhost 2181 && echo "ZooKeeper OK" +# Test: mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,hbase +# Stop: docker compose -f docker/hbase/docker-compose.hbase.yml down -v +# +# HugeGraph test config (hugegraph-server/hugegraph-test/src/main/resources/hugegraph.properties): +# hbase.hosts=localhost +# hbase.port=2181 +# hbase.znode_parent=/hbase +# +# Ports exposed to host: +# 2181 - ZooKeeper (HBase embedded) +# 16000 - HBase Master RPC +# 16010 - HBase Master Web UI -> http://localhost:16010 +# 16020 - HBase RegionServer RPC +# 16030 - HBase RegionServer Web UI -> http://localhost:16030 + +services: + hbase: + build: + context: . + dockerfile: Dockerfile + args: + HBASE_VERSION: "2.6.5" + # Optional overrides for flaky networks/corporate mirrors. + HBASE_PRIMARY_URL: "${HBASE_PRIMARY_URL:-https://downloads.apache.org/hbase/2.6.5/hbase-2.6.5-bin.tar.gz}" + HBASE_FALLBACK_URL: "${HBASE_FALLBACK_URL:-https://archive.apache.org/dist/hbase/2.6.5/hbase-2.6.5-bin.tar.gz}" + image: hugegraph/hbase:2.6.5 + container_name: hg-hbase-test + hostname: "${HBASE_HOSTNAME:-hbase}" + environment: + HBASE_HOSTNAME: "${HBASE_HOSTNAME:-hbase}" + HBASE_MASTER_HOSTNAME: "${HBASE_MASTER_HOSTNAME:-}" + HBASE_REGIONSERVER_HOSTNAME: "${HBASE_REGIONSERVER_HOSTNAME:-}" + ports: + - "2181:2181" # ZooKeeper (matches hbase.port in hugegraph.properties) + - "16000:16000" # Master RPC + - "16010:16010" # Master Web UI -> http://localhost:16010 + - "16020:16020" # RegionServer RPC + - "16030:16030" # RegionServer Web UI -> http://localhost:16030 + volumes: + - hbase-data:/tmp/hbase + - hbase-zk-data:/tmp/zookeeper + healthcheck: + # nc -z confirms ZooKeeper is accepting connections + test: ["CMD", "nc", "-z", "localhost", "2181"] + interval: 10s + timeout: 10s + retries: 15 + start_period: 90s + restart: unless-stopped + +volumes: + hbase-data: + hbase-zk-data: + + diff --git a/docker/hbase/entrypoint.sh b/docker/hbase/entrypoint.sh new file mode 100644 index 0000000000..72cfd38134 --- /dev/null +++ b/docker/hbase/entrypoint.sh @@ -0,0 +1,99 @@ +#!/bin/bash +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +set -e + +HBASE_HOSTNAME="${HBASE_HOSTNAME:-hbase}" +HBASE_MASTER_HOSTNAME="${HBASE_MASTER_HOSTNAME:-${HBASE_HOSTNAME}}" +HBASE_REGIONSERVER_HOSTNAME="${HBASE_REGIONSERVER_HOSTNAME:-${HBASE_HOSTNAME}}" +HBASE_SITE_XML="${HBASE_HOME}/conf/hbase-site.xml" + +escape_sed_replacement() { + local value="$1" + if [[ "$value" == *$'\n'* ]]; then + echo "Property values must not contain newlines" >&2 + exit 1 + fi + printf '%s' "$value" | sed -e 's/[\\&|]/\\&/g' +} + +set_xml_property_value() { + local property_name="$1" + local property_value + property_value=$(escape_sed_replacement "$2") + + # The in-place replacement below expects the standard HBase layout where + # ... is followed by ... on the next line. + # Fail loudly if the property entry is missing to avoid silent misconfig. + if ! grep -Fq "${property_name}" "${HBASE_SITE_XML}"; then + echo "Missing required property '${property_name}' in ${HBASE_SITE_XML}" >&2 + exit 1 + fi + + sed -i "/${property_name//./\\.}<\\/name>/ {n; s|.*|${property_value}|;}" "${HBASE_SITE_XML}" +} + +set_xml_property_value "hbase.master.hostname" "${HBASE_MASTER_HOSTNAME}" +set_xml_property_value "hbase.regionserver.hostname" "${HBASE_REGIONSERVER_HOSTNAME}" + +echo "Starting HBase ${HBASE_VERSION} standalone..." +echo "HBase container hostname fallback: ${HBASE_HOSTNAME}" +echo "HBase advertised master hostname: ${HBASE_MASTER_HOSTNAME}" +echo "HBase advertised regionserver hostname: ${HBASE_REGIONSERVER_HOSTNAME}" + + +# Start services explicitly to avoid SSH-based helper assumptions in containers +${HBASE_HOME}/bin/hbase-daemon.sh start zookeeper +${HBASE_HOME}/bin/hbase-daemon.sh start master +${HBASE_HOME}/bin/hbase-daemon.sh start regionserver + +echo "HBase started. Waiting for ZooKeeper on port 2181..." +zk_attempts=0 +until nc -z localhost 2181; do + zk_attempts=$((zk_attempts + 1)) + if [ "$zk_attempts" -ge 120 ]; then + echo "Timed out waiting for ZooKeeper on 2181" + ${HBASE_HOME}/bin/hbase-daemon.sh status || true + exit 1 + fi + sleep 1 +done +echo "ZooKeeper is ready." + +echo "Waiting for HBase Master..." +master_attempts=0 +until echo "status 'simple'" | ${HBASE_HOME}/bin/hbase shell -n 2>/dev/null | grep -E -q "([1-9][0-9]*[[:space:]]+live[[:space:]]+servers|[1-9][0-9]*[[:space:]]+servers|servers:[[:space:]]*[1-9])"; do + master_attempts=$((master_attempts + 1)) + if [ "$master_attempts" -ge 180 ]; then + echo "Timed out waiting for HBase master/regionserver readiness" + ${HBASE_HOME}/bin/hbase-daemon.sh status || true + tail -n 80 ${HBASE_HOME}/logs/hbase-*.out ${HBASE_HOME}/logs/hbase-*.log \ + 2>/dev/null || true + exit 1 + fi + sleep 3 +done +echo "HBase is ready. Master + RegionServer online." + +# Tail all daemon logs so `docker logs` includes startup/runtime issues +shopt -s nullglob +log_files=("${HBASE_HOME}/logs"/hbase-*.out "${HBASE_HOME}/logs"/hbase-*.log) +if [ ${#log_files[@]} -gt 0 ]; then + exec tail -F "${log_files[@]}" +fi +exec tail -f /dev/null + diff --git a/docker/hbase/hbase-site.xml b/docker/hbase/hbase-site.xml new file mode 100644 index 0000000000..41a555d0ab --- /dev/null +++ b/docker/hbase/hbase-site.xml @@ -0,0 +1,89 @@ + + + + + + + hbase.rootdir + file:///tmp/hbase + + + + hbase.zookeeper.property.dataDir + /tmp/zookeeper + + + + hbase.zookeeper.quorum + localhost + + + hbase.zookeeper.property.clientPort + 2181 + + + + hbase.zookeeper.property.maxClientCnxns + 0 + + + + zookeeper.znode.parent + /hbase + + + + hbase.zookeeper.property.tickTime + 6000 + + + zookeeper.session.timeout + 180000 + + + + hbase.cluster.distributed + true + + + + hbase.wal.provider + filesystem + + + hbase.unsafe.stream.capability.enforce + false + + + hbase.master.hostname + localhost + + + hbase.regionserver.hostname + localhost + + + hbase.master.ipc.address + 0.0.0.0 + + + hbase.regionserver.ipc.address + 0.0.0.0 + + + diff --git a/hugegraph-cluster-test/hugegraph-clustertest-dist/pom.xml b/hugegraph-cluster-test/hugegraph-clustertest-dist/pom.xml index 7ec79efba0..e318f06bd0 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-dist/pom.xml +++ b/hugegraph-cluster-test/hugegraph-clustertest-dist/pom.xml @@ -1,19 +1,19 @@ diff --git a/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/hugegraph.properties.template b/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/hugegraph.properties.template index 2a086bd325..005031fe60 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/hugegraph.properties.template +++ b/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/hugegraph.properties.template @@ -16,8 +16,7 @@ # # gremlin entrance to create graph -# auth config: org.apache.hugegraph.auth.HugeFactoryAuthProxy -gremlin.graph=org.apache.hugegraph.HugeFactory +gremlin.graph=org.apache.hugegraph.auth.HugeFactoryAuthProxy # cache config #schema.cache_capacity=100000 diff --git a/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/rest-server.properties.template b/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/rest-server.properties.template index 8f4e9bf616..01744ac2c0 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/rest-server.properties.template +++ b/hugegraph-cluster-test/hugegraph-clustertest-dist/src/assembly/static/conf/rest-server.properties.template @@ -36,17 +36,18 @@ arthas.disabled_commands=jad # authentication configs # choose 'org.apache.hugegraph.auth.StandardAuthenticator' or # 'org.apache.hugegraph.auth.ConfigAuthenticator' -#auth.authenticator= +auth.authenticator=org.apache.hugegraph.auth.StandardAuthenticator +# true if using hstore mode +usePD=true + +# default password +auth.admin_pa=pa # for StandardAuthenticator mode #auth.graph_store=hugegraph # auth client config #auth.remote_url=127.0.0.1:8899,127.0.0.1:8898,127.0.0.1:8897 -# for ConfigAuthenticator mode -#auth.admin_token= -#auth.user_tokens=[] - # rpc server configs for multi graph-servers or raft-servers rpc.server_host=127.0.0.1 rpc.server_port=$RPC_PORT$ diff --git a/hugegraph-cluster-test/hugegraph-clustertest-minicluster/pom.xml b/hugegraph-cluster-test/hugegraph-clustertest-minicluster/pom.xml index 8feb6181f2..b59648304f 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-minicluster/pom.xml +++ b/hugegraph-cluster-test/hugegraph-clustertest-minicluster/pom.xml @@ -1,19 +1,19 @@ 11 11 UTF-8 - 2.17.0 diff --git a/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/base/ClusterConstant.java b/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/base/ClusterConstant.java index 9120c0cf92..730bbc53ed 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/base/ClusterConstant.java +++ b/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/base/ClusterConstant.java @@ -33,12 +33,12 @@ public class ClusterConstant { public static final String PLUGINS_DIR = "plugins"; public static final String BIN_DIR = "bin"; public static final String CONF_DIR = "conf"; - public static final String PD_PACKAGE_PREFIX = "apache-hugegraph-pd-incubating"; + public static final String PD_PACKAGE_PREFIX = "apache-hugegraph-pd"; public static final String PD_JAR_PREFIX = "hg-pd-service"; - public static final String STORE_PACKAGE_PREFIX = "apache-hugegraph-store-incubating"; + public static final String STORE_PACKAGE_PREFIX = "apache-hugegraph-store"; public static final String STORE_JAR_PREFIX = "hg-store-node"; - public static final String SERVER_PACKAGE_PREFIX = "apache-hugegraph-server-incubating"; - public static final String CT_PACKAGE_PREFIX = "apache-hugegraph-ct-incubating"; + public static final String SERVER_PACKAGE_PREFIX = "apache-hugegraph-server"; + public static final String CT_PACKAGE_PREFIX = "apache-hugegraph-ct"; public static final String APPLICATION_FILE = "application.yml"; public static final String SERVER_PROPERTIES = "rest-server.properties"; public static final String HUGEGRAPH_PROPERTIES = "graphs/hugegraph.properties"; diff --git a/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/node/ServerNodeWrapper.java b/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/node/ServerNodeWrapper.java index e39bc39557..e16b96781e 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/node/ServerNodeWrapper.java +++ b/hugegraph-cluster-test/hugegraph-clustertest-minicluster/src/main/java/org/apache/hugegraph/ct/node/ServerNodeWrapper.java @@ -34,15 +34,21 @@ import static org.apache.hugegraph.ct.base.ClusterConstant.SERVER_TEMPLATE_PATH; import static org.apache.hugegraph.ct.base.ClusterConstant.isJava11OrHigher; +import java.io.BufferedReader; import java.io.File; import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; public class ServerNodeWrapper extends AbstractNodeWrapper { + private static List hgJars = loadHgJarsOnce(); public ServerNodeWrapper(int clusterIndex, int index) { super(clusterIndex, index); this.fileNames = new ArrayList<>( @@ -67,6 +73,38 @@ private static void addJarsToClasspath(File directory, List classpath) { } } + private static void addOrderedJarsToClasspath(File directory, List classpath) { + // Add jar starts with hugegraph in proper order + String path = directory.getAbsolutePath(); + for (String jar : hgJars) { + classpath.add(path + File.separator + jar); + } + if (directory.exists() && directory.isDirectory()) { + File[] files = + directory.listFiles((dir, name) -> name.endsWith(".jar") && !name.contains( + "hugegraph")); + if (files != null) { + for (File file : files) { + classpath.add(file.getAbsolutePath()); + } + } + } + } + + private static List loadHgJarsOnce(){ + ArrayList jars = new ArrayList<>(); + try (InputStream is = ServerNodeWrapper.class.getResourceAsStream("/jar.txt"); + BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) { + String line; + while ((line = reader.readLine()) != null) { + jars.add(line); + } + } catch (IOException e) { + e.printStackTrace(); + } + return Collections.unmodifiableList(jars); + } + @Override public void start() { try { @@ -79,7 +117,7 @@ public void start() { } List classpath = new ArrayList<>(); - addJarsToClasspath(new File(workPath + LIB_DIR), classpath); + addOrderedJarsToClasspath(new File(workPath + LIB_DIR), classpath); addJarsToClasspath(new File(workPath + EXT_DIR), classpath); addJarsToClasspath(new File(workPath + PLUGINS_DIR), classpath); String storeClassPath = String.join(":", classpath); @@ -87,6 +125,8 @@ public void start() { startCmd.addAll(Arrays.asList( "-Dname=HugeGraphServer" + this.index, "--add-exports=java.base/jdk.internal.reflect=ALL-UNNAMED", + "--add-modules=jdk.unsupported", + "--add-exports=java.base/sun.nio.ch=ALL-UNNAMED", "-cp", storeClassPath, "org.apache.hugegraph.dist.HugeGraphServer", "./conf/gremlin-server.yaml", diff --git a/hugegraph-cluster-test/hugegraph-clustertest-test/pom.xml b/hugegraph-cluster-test/hugegraph-clustertest-test/pom.xml index c888404545..735ea66b43 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-test/pom.xml +++ b/hugegraph-cluster-test/hugegraph-clustertest-test/pom.xml @@ -1,19 +1,19 @@ 4.13.2 compile + + jakarta.ws.rs + jakarta.ws.rs-api + 3.0.0 + + + org.glassfish.jersey.inject + jersey-hk2 + 3.0.3 + test + + + org.glassfish.jersey.core + jersey-client + 3.0.3 + compile + @@ -92,6 +109,31 @@ + + org.apache.maven.plugins + maven-resources-plugin + + + generate-version + process-resources + + copy-resources + + + ${project.build.directory}/classes + + + src/main/resources + true + + jar.txt + + + + + + + diff --git a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/BaseMultiClusterTest.java b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/BaseMultiClusterTest.java index 59394101c2..9e90933026 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/BaseMultiClusterTest.java +++ b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/BaseMultiClusterTest.java @@ -20,32 +20,73 @@ import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.List; +import org.apache.hugegraph.SimpleClusterTest.BaseSimpleTest; +import org.apache.hugegraph.SimpleClusterTest.BaseSimpleTest.RestClient; import org.apache.hugegraph.ct.env.BaseEnv; import org.apache.hugegraph.ct.env.MultiNodeEnv; +import org.apache.hugegraph.serializer.direct.util.HugeException; import org.junit.AfterClass; +import org.junit.Assert; import org.junit.BeforeClass; +import jakarta.ws.rs.core.Response; + /** * MultiNode Test generate the cluster env with 3 pd node + 3 store node + 3 server node. * Or you can set different num of nodes by using env = new MultiNodeEnv(pdNum, storeNum, serverNum) * All nodes are deployed in ports generated randomly, the application of nodes are stored - * in /apache-hugegraph-ct-incubating-1.5.0, you can visit each node with rest api. + * in /apache-hugegraph-ct-1.7.0, you can visit each node with rest api. */ public class BaseMultiClusterTest { protected static BaseEnv env; protected static Process p; + protected static List clients = new ArrayList<>(); + protected static String BASE_URL = "http://"; + protected static final String GRAPH = "hugegraphapi"; + protected static final String URL_PREFIX = "graphspaces/DEFAULT/graphs/" + GRAPH; + protected static final String SCHEMA_PKS = "/schema/propertykeys"; @BeforeClass public static void initEnv() { env = new MultiNodeEnv(); env.startCluster(); + clients.clear(); + for (String addr : env.getServerRestAddrs()) { + clients.add(new RestClient(BASE_URL + addr)); + } + initGraph(); } @AfterClass public static void clearEnv() { env.stopCluster(); + for (RestClient client : clients) { + client.close(); + } + } + + protected static void initGraph() { + BaseSimpleTest.RestClient client = clients.get(0); + Response r = client.get(URL_PREFIX); + if (r.getStatus() != 200) { + String body = "{\n" + + " \"backend\": \"hstore\",\n" + + " \"serializer\": \"binary\",\n" + + " \"store\": \"hugegraphapi\",\n" + + " \"search.text_analyzer\": \"jieba\",\n" + + " \"search.text_analyzer_mode\": \"INDEX\"\n" + + "}"; + r = client.post(URL_PREFIX, body); + if (r.getStatus() != 201) { + throw new HugeException(String.format( + "Failed to initialize graph %s %s",GRAPH, r.readEntity(String.class) + )); + } + } } protected String execCmd(String[] cmds) throws IOException { @@ -61,4 +102,21 @@ protected String execCmd(String[] cmds) throws IOException { p.destroy(); return builder.toString(); } + + protected static String assertResponseStatus(int status, + Response response) { + String content = response.readEntity(String.class); + String message = String.format("Response with status %s and content %s", + response.getStatus(), content); + Assert.assertEquals(message, status, response.getStatus()); + return content; + } + + public static Response createAndAssert(RestClient client, String path, + String body, + int status) { + Response r = client.post(path, body); + assertResponseStatus(status, r); + return r; + } } diff --git a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/MultiClusterDeployTest.java b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/MultiClusterDeployTest.java index 0318df1ad0..4229fc35f5 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/MultiClusterDeployTest.java +++ b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/MultiClusterTest/MultiClusterDeployTest.java @@ -18,22 +18,12 @@ package org.apache.hugegraph.MultiClusterTest; import java.io.IOException; -import java.util.Iterator; import java.util.List; -import org.apache.hugegraph.driver.GraphManager; -import org.apache.hugegraph.driver.GremlinManager; -import org.apache.hugegraph.driver.HugeClient; -import org.apache.hugegraph.driver.SchemaManager; +import org.apache.hugegraph.SimpleClusterTest.BaseSimpleTest.RestClient; import org.apache.hugegraph.pd.client.PDClient; import org.apache.hugegraph.pd.client.PDConfig; import org.apache.hugegraph.pd.common.PDException; -import org.apache.hugegraph.structure.constant.T; -import org.apache.hugegraph.structure.graph.Edge; -import org.apache.hugegraph.structure.graph.Path; -import org.apache.hugegraph.structure.graph.Vertex; -import org.apache.hugegraph.structure.gremlin.Result; -import org.apache.hugegraph.structure.gremlin.ResultSet; import org.junit.Assert; import org.junit.Test; @@ -59,11 +49,6 @@ public void testStoreNodesDeployment() throws IOException { List addrs = env.getStoreRestAddrs(); for (String addr : addrs) { String[] cmds = {"curl", addr}; - // TODO: why not use the sb param? - StringBuilder sb = new StringBuilder(); - for (String cmd : cmds) { - sb.append(cmd).append(" "); - } String responseMsg = execCmd(cmds); Assert.assertTrue(responseMsg.startsWith("{")); } @@ -71,133 +56,64 @@ public void testStoreNodesDeployment() throws IOException { @Test public void testServerNodesDeployment() { - List addrs = env.getServerRestAddrs(); - for (String addr : addrs) { - HugeClient hugeClient = HugeClient.builder("http://" + addr, "hugegraph") - .build(); - SchemaManager schema = hugeClient.schema(); - - schema.propertyKey("name").asText().ifNotExist().create(); - schema.propertyKey("age").asInt().ifNotExist().create(); - schema.propertyKey("city").asText().ifNotExist().create(); - schema.propertyKey("weight").asDouble().ifNotExist().create(); - schema.propertyKey("lang").asText().ifNotExist().create(); - schema.propertyKey("date").asDate().ifNotExist().create(); - schema.propertyKey("price").asInt().ifNotExist().create(); - - schema.vertexLabel("person") - .properties("name", "age", "city") - .primaryKeys("name") - .ifNotExist() - .create(); - - schema.vertexLabel("software") - .properties("name", "lang", "price") - .primaryKeys("name") - .ifNotExist() - .create(); - - schema.indexLabel("personByCity") - .onV("person") - .by("city") - .secondary() - .ifNotExist() - .create(); - - schema.indexLabel("personByAgeAndCity") - .onV("person") - .by("age", "city") - .secondary() - .ifNotExist() - .create(); - - schema.indexLabel("softwareByPrice") - .onV("software") - .by("price") - .range() - .ifNotExist() - .create(); - - schema.edgeLabel("knows") - .sourceLabel("person") - .targetLabel("person") - .properties("date", "weight") - .ifNotExist() - .create(); - - schema.edgeLabel("created") - .sourceLabel("person").targetLabel("software") - .properties("date", "weight") - .ifNotExist() - .create(); - - schema.indexLabel("createdByDate") - .onE("created") - .by("date") - .secondary() - .ifNotExist() - .create(); - - schema.indexLabel("createdByWeight") - .onE("created") - .by("weight") - .range() - .ifNotExist() - .create(); - - schema.indexLabel("knowsByWeight") - .onE("knows") - .by("weight") - .range() - .ifNotExist() - .create(); - - GraphManager graph = hugeClient.graph(); - Vertex marko = graph.addVertex(T.LABEL, "person", "name", "marko", - "age", 29, "city", "Beijing"); - Vertex vadas = graph.addVertex(T.LABEL, "person", "name", "vadas", - "age", 27, "city", "Hongkong"); - Vertex lop = graph.addVertex(T.LABEL, "software", "name", "lop", - "lang", "java", "price", 328); - Vertex josh = graph.addVertex(T.LABEL, "person", "name", "josh", - "age", 32, "city", "Beijing"); - Vertex ripple = graph.addVertex(T.LABEL, "software", "name", "ripple", - "lang", "java", "price", 199); - Vertex peter = graph.addVertex(T.LABEL, "person", "name", "peter", - "age", 35, "city", "Shanghai"); - - marko.addEdge("knows", vadas, "date", "2016-01-10", "weight", 0.5); - marko.addEdge("knows", josh, "date", "2013-02-20", "weight", 1.0); - marko.addEdge("created", lop, "date", "2017-12-10", "weight", 0.4); - josh.addEdge("created", lop, "date", "2009-11-11", "weight", 0.4); - josh.addEdge("created", ripple, "date", "2017-12-10", "weight", 1.0); - peter.addEdge("created", lop, "date", "2017-03-24", "weight", 0.2); - - GremlinManager gremlin = hugeClient.gremlin(); - System.out.println("==== Path ===="); - ResultSet resultSet = gremlin.gremlin("g.V().outE().path()").execute(); - Iterator results = resultSet.iterator(); - results.forEachRemaining(result -> { - System.out.println(result.getObject().getClass()); - Object object = result.getObject(); - if (object instanceof Vertex) { - System.out.println(((Vertex) object).id()); - } else if (object instanceof Edge) { - System.out.println(((Edge) object).id()); - } else if (object instanceof Path) { - List elements = ((Path) object).objects(); - elements.forEach(element -> { - System.out.println(element.getClass()); - System.out.println(element); - }); - } else { - System.out.println(object); - } - }); - - hugeClient.close(); - assert true; - break; + for (RestClient client : clients) { + String path = URL_PREFIX + SCHEMA_PKS; + createAndAssert(client, path, "{\n" + + "\"name\": \"name\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(client, path, "{\n" + + "\"name\": \"age\",\n" + + "\"data_type\": \"INT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(client, path, "{\n" + + "\"name\": \"city\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(client, path, "{\n" + + "\"name\": \"lang\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(client, path, "{\n" + + "\"name\": \"date\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(client, path, "{\n" + + "\"name\": \"price\",\n" + + "\"data_type\": \"INT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(client, path, "{\n" + + "\"name\": \"weight\",\n" + + "\"data_type\": \"DOUBLE\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(client, path, "{\n" + + "\"name\": \"rank\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); } } } diff --git a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/BaseSimpleTest.java b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/BaseSimpleTest.java index 61954de811..f0f0c33461 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/BaseSimpleTest.java +++ b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/BaseSimpleTest.java @@ -20,36 +20,61 @@ import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; +import java.util.Map; import org.apache.hugegraph.ct.env.BaseEnv; import org.apache.hugegraph.ct.env.SimpleEnv; -import org.apache.hugegraph.driver.HugeClient; import org.apache.hugegraph.pd.client.PDClient; +import org.apache.hugegraph.serializer.direct.util.HugeException; +import org.glassfish.jersey.client.authentication.HttpAuthenticationFeature; +import org.glassfish.jersey.client.filter.EncodingFilter; +import org.glassfish.jersey.message.GZipEncoder; import org.junit.AfterClass; +import org.junit.Assert; import org.junit.BeforeClass; +import com.google.common.collect.Multimap; + +import jakarta.ws.rs.client.Client; +import jakarta.ws.rs.client.ClientBuilder; +import jakarta.ws.rs.client.Entity; +import jakarta.ws.rs.client.WebTarget; +import jakarta.ws.rs.core.MultivaluedMap; +import jakarta.ws.rs.core.Response; + /** * Simple Test generate the cluster env with 1 pd node + 1 store node + 1 server node. * All nodes are deployed in ports generated randomly; The application of nodes is stored - * in /apache-hugegraph-ct-incubating-1.5.0, you can visit each node with rest api. + * in /apache-hugegraph-ct-1.7.0, you can visit each node with rest api. */ public class BaseSimpleTest { protected static BaseEnv env; protected static Process p; protected static PDClient pdClient; - protected static HugeClient hugeClient; + + protected static String BASE_URL = "http://"; + protected static final String GRAPH = "hugegraphapi"; + protected static final String USERNAME = "admin"; + private static final String PASSWORD = "pa"; + + protected static final String URL_PREFIX = "graphspaces/DEFAULT/graphs/" + GRAPH; + protected static final String SCHEMA_PKS = "/schema/propertykeys"; + protected static RestClient client; @BeforeClass public static void initEnv() { env = new SimpleEnv(); env.startCluster(); + client = new RestClient(BASE_URL + env.getServerRestAddrs().get(0)); + initGraph(); } @AfterClass public static void clearEnv() throws InterruptedException { env.stopCluster(); Thread.sleep(2000); + client.close(); } protected String execCmd(String[] cmds) throws IOException { @@ -66,4 +91,101 @@ protected String execCmd(String[] cmds) throws IOException { return builder.toString(); } + protected static void initGraph() { + Response r = client.get(URL_PREFIX); + if (r.getStatus() != 200) { + String body = "{\n" + + " \"backend\": \"hstore\",\n" + + " \"serializer\": \"binary\",\n" + + " \"store\": \"hugegraphapi\",\n" + + " \"search.text_analyzer\": \"jieba\",\n" + + " \"search.text_analyzer_mode\": \"INDEX\"\n" + + "}"; + r = client.post(URL_PREFIX, body); + if (r.getStatus() != 201) { + throw new HugeException("Failed to create graph: " + GRAPH + + r.readEntity(String.class)); + } + } + } + + public static class RestClient { + + private final Client client; + private final WebTarget target; + + public RestClient(String url) { + this.client = ClientBuilder.newClient(); + this.client.register(EncodingFilter.class); + this.client.register(GZipEncoder.class); + this.client.register(HttpAuthenticationFeature.basic(USERNAME, + PASSWORD)); + this.target = this.client.target(url); + } + + public void close() { + this.client.close(); + } + + public WebTarget target() { + return this.target; + } + + public WebTarget target(String url) { + return this.client.target(url); + } + + public Response get(String path) { + return this.target.path(path).request().get(); + } + + public Response get(String path, String id) { + return this.target.path(path).path(id).request().get(); + } + + public Response get(String path, + MultivaluedMap headers) { + return this.target.path(path).request().headers(headers).get(); + } + + public Response get(String path, Multimap params) { + WebTarget target = this.target.path(path); + for (Map.Entry entries : params.entries()) { + target = target.queryParam(entries.getKey(), entries.getValue()); + } + return target.request().get(); + } + + public Response get(String path, Map params) { + WebTarget target = this.target.path(path); + for (Map.Entry i : params.entrySet()) { + target = target.queryParam(i.getKey(), i.getValue()); + } + return target.request().get(); + } + + public Response post(String path, String content) { + return this.post(path, Entity.json(content)); + } + + public Response post(String path, Entity entity) { + return this.target.path(path).request().post(entity); + } + } + + protected static String assertResponseStatus(int status, + Response response) { + String content = response.readEntity(String.class); + String message = String.format("Response with status %s and content %s", + response.getStatus(), content); + Assert.assertEquals(message, status, response.getStatus()); + return content; + } + + public static Response createAndAssert(String path, String body, + int status) { + Response r = client.post(path, body); + assertResponseStatus(status, r); + return r; + } } diff --git a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/SimpleClusterDeployTest.java b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/SimpleClusterDeployTest.java index 61a73ff0f4..267e186f9e 100644 --- a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/SimpleClusterDeployTest.java +++ b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/java/org/apache/hugegraph/SimpleClusterTest/SimpleClusterDeployTest.java @@ -18,22 +18,11 @@ package org.apache.hugegraph.SimpleClusterTest; import java.io.IOException; -import java.util.Iterator; import java.util.List; -import org.apache.hugegraph.driver.GraphManager; -import org.apache.hugegraph.driver.GremlinManager; -import org.apache.hugegraph.driver.HugeClient; -import org.apache.hugegraph.driver.SchemaManager; import org.apache.hugegraph.pd.client.PDClient; import org.apache.hugegraph.pd.client.PDConfig; import org.apache.hugegraph.pd.common.PDException; -import org.apache.hugegraph.structure.constant.T; -import org.apache.hugegraph.structure.graph.Edge; -import org.apache.hugegraph.structure.graph.Path; -import org.apache.hugegraph.structure.graph.Vertex; -import org.apache.hugegraph.structure.gremlin.Result; -import org.apache.hugegraph.structure.gremlin.ResultSet; import org.junit.Assert; import org.junit.Test; @@ -44,7 +33,7 @@ public void testPDNodesDeployment() { try { List addrs = env.getPDGrpcAddrs(); for (String addr : addrs) { - PDConfig pdConfig = PDConfig.of(addr); + PDConfig pdConfig = PDConfig.of(addr, Long.MAX_VALUE); pdClient = PDClient.create(pdConfig); pdClient.dbCompaction(); } @@ -59,142 +48,69 @@ public void testStoreNodesDeployment() throws IOException { List addrs = env.getStoreRestAddrs(); for (String addr : addrs) { String[] cmds = {"curl", addr}; - // TODO: what's the purpose of this? - StringBuilder sb = new StringBuilder(); - for (String cmd : cmds) { - sb.append(cmd).append(" "); - } String responseMsg = execCmd(cmds); Assert.assertTrue(responseMsg.startsWith("{")); } } @Test - public void testServerNodesDeployment() { - List addrs = env.getServerRestAddrs(); - for (String addr : addrs) { - hugeClient = HugeClient.builder("http://" + addr, "hugegraph").build(); - SchemaManager schema = hugeClient.schema(); - - schema.propertyKey("name").asText().ifNotExist().create(); - schema.propertyKey("age").asInt().ifNotExist().create(); - schema.propertyKey("city").asText().ifNotExist().create(); - schema.propertyKey("weight").asDouble().ifNotExist().create(); - schema.propertyKey("lang").asText().ifNotExist().create(); - schema.propertyKey("date").asDate().ifNotExist().create(); - schema.propertyKey("price").asInt().ifNotExist().create(); - - schema.vertexLabel("person") - .properties("name", "age", "city") - .primaryKeys("name") - .ifNotExist() - .create(); - - schema.vertexLabel("software") - .properties("name", "lang", "price") - .primaryKeys("name") - .ifNotExist() - .create(); - - schema.indexLabel("personByCity") - .onV("person") - .by("city") - .secondary() - .ifNotExist() - .create(); - - schema.indexLabel("personByAgeAndCity") - .onV("person") - .by("age", "city") - .secondary() - .ifNotExist() - .create(); - - schema.indexLabel("softwareByPrice") - .onV("software") - .by("price") - .range() - .ifNotExist() - .create(); - - schema.edgeLabel("knows") - .sourceLabel("person") - .targetLabel("person") - .properties("date", "weight") - .ifNotExist() - .create(); - - schema.edgeLabel("created") - .sourceLabel("person").targetLabel("software") - .properties("date", "weight") - .ifNotExist() - .create(); - - schema.indexLabel("createdByDate") - .onE("created") - .by("date") - .secondary() - .ifNotExist() - .create(); - - schema.indexLabel("createdByWeight") - .onE("created") - .by("weight") - .range() - .ifNotExist() - .create(); - - schema.indexLabel("knowsByWeight") - .onE("knows") - .by("weight") - .range() - .ifNotExist() - .create(); - - GraphManager graph = hugeClient.graph(); - Vertex marko = graph.addVertex(T.LABEL, "person", "name", "marko", - "age", 29, "city", "Beijing"); - Vertex vadas = graph.addVertex(T.LABEL, "person", "name", "vadas", - "age", 27, "city", "Hongkong"); - Vertex lop = graph.addVertex(T.LABEL, "software", "name", "lop", - "lang", "java", "price", 328); - Vertex josh = graph.addVertex(T.LABEL, "person", "name", "josh", - "age", 32, "city", "Beijing"); - Vertex ripple = graph.addVertex(T.LABEL, "software", "name", "ripple", - "lang", "java", "price", 199); - Vertex peter = graph.addVertex(T.LABEL, "person", "name", "peter", - "age", 35, "city", "Shanghai"); - - marko.addEdge("knows", vadas, "date", "2016-01-10", "weight", 0.5); - marko.addEdge("knows", josh, "date", "2013-02-20", "weight", 1.0); - marko.addEdge("created", lop, "date", "2017-12-10", "weight", 0.4); - josh.addEdge("created", lop, "date", "2009-11-11", "weight", 0.4); - josh.addEdge("created", ripple, "date", "2017-12-10", "weight", 1.0); - peter.addEdge("created", lop, "date", "2017-03-24", "weight", 0.2); - - GremlinManager gremlin = hugeClient.gremlin(); - System.out.println("==== Path ===="); - ResultSet resultSet = gremlin.gremlin("g.V().outE().path()").execute(); - Iterator results = resultSet.iterator(); - results.forEachRemaining(result -> { - System.out.println(result.getObject().getClass()); - Object object = result.getObject(); - if (object instanceof Vertex) { - System.out.println(((Vertex) object).id()); - } else if (object instanceof Edge) { - System.out.println(((Edge) object).id()); - } else if (object instanceof Path) { - List elements = ((Path) object).objects(); - elements.forEach(element -> { - System.out.println(element.getClass()); - System.out.println(element); - }); - } else { - System.out.println(object); - } - }); - - hugeClient.close(); - } + public void testServerNode() { + String path = URL_PREFIX + SCHEMA_PKS; + createAndAssert(path, "{\n" + + "\"name\": \"name\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(path, "{\n" + + "\"name\": \"age\",\n" + + "\"data_type\": \"INT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(path, "{\n" + + "\"name\": \"city\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(path, "{\n" + + "\"name\": \"lang\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(path, "{\n" + + "\"name\": \"date\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(path, "{\n" + + "\"name\": \"price\",\n" + + "\"data_type\": \"INT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(path, "{\n" + + "\"name\": \"weight\",\n" + + "\"data_type\": \"DOUBLE\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); + createAndAssert(path, "{\n" + + "\"name\": \"rank\",\n" + + "\"data_type\": \"TEXT\",\n" + + "\"cardinality\": \"SINGLE\",\n" + + "\"check_exist\": false,\n" + + "\"properties\":[]\n" + + "}", 202); } } diff --git a/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/resources/jar.txt b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/resources/jar.txt new file mode 100644 index 0000000000..7a566545ce --- /dev/null +++ b/hugegraph-cluster-test/hugegraph-clustertest-test/src/main/resources/jar.txt @@ -0,0 +1,14 @@ +hugegraph-api-${revision}.jar +hugegraph-cassandra-${revision}.jar +hugegraph-common-${revision}.jar +hugegraph-core-${revision}.jar +hugegraph-dist-${revision}.jar +hugegraph-hbase-${revision}.jar +hugegraph-hstore-${revision}.jar +hugegraph-mysql-${revision}.jar +hugegraph-palo-${revision}.jar +hugegraph-postgresql-${revision}.jar +hugegraph-rocksdb-${revision}.jar +hugegraph-rpc-${revision}.jar +hugegraph-scylladb-${revision}.jar +hugegraph-struct-${revision}.jar diff --git a/hugegraph-cluster-test/pom.xml b/hugegraph-cluster-test/pom.xml index fcc409d6ad..cd54ac0ffe 100644 --- a/hugegraph-cluster-test/pom.xml +++ b/hugegraph-cluster-test/pom.xml @@ -1,19 +1,19 @@ 11 11 UTF-8 - apache-${release.name}-ct-incubating-${project.version} + apache-${release.name}-ct-${project.version} diff --git a/hugegraph-commons/README.md b/hugegraph-commons/README.md index 4ec2ebb5bb..d8cbcbc24a 100644 --- a/hugegraph-commons/README.md +++ b/hugegraph-commons/README.md @@ -3,8 +3,8 @@ [![License](https://img.shields.io/badge/license-Apache%202-0E78BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html) [![codecov](https://codecov.io/gh/hugegraph/hugegraph-common/branch/master/graph/badge.svg)](https://codecov.io/gh/hugegraph/hugegraph-common) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.apache.hugegraph/hugegraph-common/badge.svg)](https://mvnrepository.com/artifact/org.apache.hugegraph/hugegraph-common) -[![CodeQL](https://github.com/apache/incubator-hugegraph-commons/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/apache/incubator-hugegraph-commons/actions/workflows/codeql-analysis.yml) -[![hugegraph-commons ci](https://github.com/apache/incubator-hugegraph-commons/actions/workflows/ci.yml/badge.svg)](https://github.com/apache/incubator-hugegraph-commons/actions/workflows/ci.yml) +[![CodeQL](https://github.com/apache/hugegraph-commons/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/apache/hugegraph-commons/actions/workflows/codeql-analysis.yml) +[![hugegraph-commons ci](https://github.com/apache/hugegraph-commons/actions/workflows/ci.yml/badge.svg)](https://github.com/apache/hugegraph-commons/actions/workflows/ci.yml) hugegraph-commons is a common module for [HugeGraph](https://github.com/apache/hugegraph) and its peripheral components. @@ -13,7 +13,7 @@ numeric or collection util classes to simplify the development of HugeGraph and ## Components -- Lock: atomic lock, key lock, lock group and lock manger +- Lock: atomic lock, key lock, lock group and lock manager - Config: register and load config option with security check - Event: listening and notification, do something asynchronously - Iterator: some iterators with extra functions, map, filter, extend, etc. @@ -49,7 +49,7 @@ And here are links of other repositories: - Note: It's recommended to use [GitHub Desktop](https://desktop.github.com/) to greatly simplify the PR and commit process. - Thank you to all the people who already contributed to HugeGraph! -[![contributors graph](https://contrib.rocks/image?repo=apache/hugegraph-commons)](https://github.com/apache/incubator-hugegraph-commons/graphs/contributors) +[![contributors graph](https://contrib.rocks/image?repo=apache/hugegraph-commons)](https://github.com/apache/hugegraph-commons/graphs/contributors) ## Licence @@ -59,8 +59,8 @@ Same as HugeGraph, hugegraph-commons are also licensed under [Apache 2.0](./LICE --- - - [GitHub Issues](https://github.com/apache/incubator-hugegraph-commons/issues): Feedback on usage issues and functional requirements (quick response) + - [GitHub Issues](https://github.com/apache/hugegraph-commons/issues): Feedback on usage issues and functional requirements (quick response) - Feedback Email: [dev@hugegraph.apache.org](mailto:dev@hugegraph.apache.org) ([subscriber](https://hugegraph.apache.org/docs/contribution-guidelines/subscribe/) only) - WeChat public account: Apache HugeGraph, welcome to scan this QR code to follow us. - QR png + QR png diff --git a/hugegraph-commons/hugegraph-common/README.md b/hugegraph-commons/hugegraph-common/README.md index 8614ba126b..bfeef03cd2 100644 --- a/hugegraph-commons/hugegraph-common/README.md +++ b/hugegraph-commons/hugegraph-common/README.md @@ -12,7 +12,7 @@ its components. ## Components -- Lock: atomic lock, key lock, lock group and lock manger +- Lock: atomic lock, key lock, lock group and lock manager - Config: register and load config option with security check - Event: listening and notification, do something asynchronously - Iterator: some iterators with extra functions, map, filter, extend, etc. diff --git a/hugegraph-commons/hugegraph-common/build.sh b/hugegraph-commons/hugegraph-common/build.sh old mode 100644 new mode 100755 diff --git a/hugegraph-commons/hugegraph-common/pom.xml b/hugegraph-commons/hugegraph-common/pom.xml index a57bcf59cd..6b11681716 100644 --- a/hugegraph-commons/hugegraph-common/pom.xml +++ b/hugegraph-commons/hugegraph-common/pom.xml @@ -28,7 +28,7 @@ hugegraph-common ${project.artifactId} - https://github.com/apache/incubator-hugegraph-commons/tree/master/hugegraph-common + https://github.com/apache/hugegraph-commons/tree/master/hugegraph-common hugegraph-common is a common module for HugeGraph and its peripheral components. hugegraph-common encapsulates locks, configurations, events, iterators, rest and some @@ -223,6 +223,14 @@ org.projectlombok lombok + + + + + io.github.jbellis + jvector + 3.0.6 + diff --git a/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/ConfigOption.java b/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/ConfigOption.java index 159f13901f..cffef28f19 100644 --- a/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/ConfigOption.java +++ b/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/ConfigOption.java @@ -20,6 +20,22 @@ import com.google.common.base.Predicate; public class ConfigOption extends TypedOption { + private boolean urlNormalize = false; + private String defaultScheme = null; + + public ConfigOption withUrlNormalization(String scheme) { + this.urlNormalize = true; + this.defaultScheme = scheme; + return this; + } + + public boolean needsUrlNormalization() { + return this.urlNormalize; + } + + public String getDefaultScheme() { + return this.defaultScheme; + } public ConfigOption(String name, String desc, T value) { this(name, desc, null, value); diff --git a/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/HugeConfig.java b/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/HugeConfig.java index 4837154563..9f9ecdea4d 100644 --- a/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/HugeConfig.java +++ b/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/config/HugeConfig.java @@ -43,6 +43,9 @@ public class HugeConfig extends PropertiesConfiguration { private static final Logger LOG = Log.logger(HugeConfig.class); + // Cache for URL normalization metadata (populated lazily per key) + private static final Map URL_NORMALIZATIONS = new HashMap<>(); + private String configPath; public HugeConfig(Configuration config) { @@ -87,9 +90,17 @@ private void setLayoutIfNeeded(Configuration conf) { @SuppressWarnings("unchecked") public R get(TypedOption option) { Object value = this.getProperty(option.name()); + boolean fromDefault = false; + if (value == null) { - return option.defaultValue(); + value = option.defaultValue(); + fromDefault = true; } + + if (!fromDefault) { + value = normalizeUrlOptionIfNeeded(option.name(), value); + } + return (R) value; } @@ -213,4 +224,86 @@ private static Configuration loadConfigFile(File configFile) { e, configFile); } } + + private static Object normalizeUrlOptionIfNeeded(String key, Object value) { + if (value == null) { + return null; + } + + String scheme = defaultSchemeFor(key); + if (scheme == null) { + return value; + } + + // Normalize URL options if configured with .withUrlNormalization() + if (value instanceof String) { + String original = (String) value; + String normalized = prefixSchemeIfMissing(original, scheme); + + if (!original.equals(normalized)) { + LOG.warn("Config '{}' is missing scheme, auto-corrected to '{}'", + key, normalized); + } + + return normalized; + } + + // If it ever hits here, it means config storage returned a non-string type; + // leave it unchanged (safer than forcing toString()). + return value; + } + + private static String defaultSchemeFor(String key) { + // Check if we already cached this key's scheme + if (URL_NORMALIZATIONS.containsKey(key)) { + return URL_NORMALIZATIONS.get(key); + } + + // We don't know yet - look it up NOW from OptionSpace + synchronized (URL_NORMALIZATIONS) { + // Double-check after acquiring lock + if (URL_NORMALIZATIONS.containsKey(key)) { + return URL_NORMALIZATIONS.get(key); + } + + // Look up the option from OptionSpace + TypedOption option = OptionSpace.get(key); + String scheme = null; + + if (option instanceof ConfigOption) { + ConfigOption configOption = (ConfigOption) option; + if (configOption.needsUrlNormalization()) { + scheme = configOption.getDefaultScheme(); + } + } + + // Cache it for next time (even if null) + URL_NORMALIZATIONS.put(key, scheme); + return scheme; + } + } + + private static String prefixSchemeIfMissing(String raw, String scheme) { + if (raw == null) { + return null; + } + String s = raw.trim(); + if (s.isEmpty()) { + return s; + } + + int scIdx = s.indexOf("://"); + if (scIdx > 0) { + // Normalize existing scheme to lowercase while preserving the rest + String existingScheme = s.substring(0, scIdx).toLowerCase(); + String rest = s.substring(scIdx + 3); // skip the "://" delimiter + return existingScheme + "://" + rest; + } + + String defaultScheme = scheme == null ? "" : scheme; + if (!defaultScheme.isEmpty() && !defaultScheme.endsWith("://")) { + defaultScheme = defaultScheme + "://"; + } + return defaultScheme + s; + } } diff --git a/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/event/EventHub.java b/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/event/EventHub.java index b37c67133b..fbdf460a96 100644 --- a/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/event/EventHub.java +++ b/hugegraph-commons/hugegraph-common/src/main/java/org/apache/hugegraph/event/EventHub.java @@ -149,7 +149,27 @@ public int unlisten(String event, EventListener listener) { return count; } + /** + * Notify all registered listeners for {@code event} EXCEPT + * {@code ignoredListener}. ANY_EVENT listeners are notified unless they + * are the ignored one. + * + * @return a Future resolving to the count of listeners actually + * invoked (the ignored listener is NOT counted) + */ + public Future notifyExcept(String event, + EventListener ignoredListener, + @Nullable Object... args) { + return this.notify(event, ignoredListener, args); + } + public Future notify(String event, @Nullable Object... args) { + return this.notify(event, null, args); + } + + private Future notify(String event, + EventListener ignoredListener, + @Nullable Object... args) { @SuppressWarnings("resource") ExtendableIterator all = new ExtendableIterator<>(); @@ -173,8 +193,12 @@ public Future notify(String event, @Nullable Object... args) { int count = 0; // Notify all listeners, and ignore the results while (all.hasNext()) { + EventListener listener = all.next(); + if (listener == ignoredListener) { + continue; + } try { - all.next().event(ev); + listener.event(ev); count++; } catch (Throwable e) { LOG.warn("Failed to handle event: {}", ev, e); diff --git a/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/event/EventHubTest.java b/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/event/EventHubTest.java index dff0227022..69472bc8e3 100644 --- a/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/event/EventHubTest.java +++ b/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/event/EventHubTest.java @@ -388,6 +388,43 @@ public void testEventNotifyWithArg2() { Assert.assertEquals(1, count.get()); } + @Test + public void testNotifyExcept() throws Exception { + final String notify = "event-notify"; + AtomicInteger listenerACount = new AtomicInteger(); + AtomicInteger listenerBCount = new AtomicInteger(); + AtomicInteger listenerCCount = new AtomicInteger(); + + EventListener listenerA = event -> { + event.checkArgs(String.class); + Assert.assertEquals("fake-arg", event.args()[0]); + listenerACount.incrementAndGet(); + return true; + }; + EventListener listenerB = event -> { + listenerBCount.incrementAndGet(); + return true; + }; + EventListener listenerC = event -> { + event.checkArgs(String.class); + Assert.assertEquals("fake-arg", event.args()[0]); + listenerCCount.incrementAndGet(); + return true; + }; + + this.eventHub.listen(notify, listenerA); + this.eventHub.listen(notify, listenerB); + this.eventHub.listen(EventHub.ANY_EVENT, listenerC); + + Assert.assertEquals(2, (int) this.eventHub + .notifyExcept(notify, listenerB, + "fake-arg") + .get()); + Assert.assertEquals(1, listenerACount.get()); + Assert.assertEquals(0, listenerBCount.get()); + Assert.assertEquals(1, listenerCCount.get()); + } + @Test public void testEventNotifyWithMultiThreads() throws InterruptedException { final String notify = "event-notify"; diff --git a/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/rest/RestClientTest.java b/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/rest/RestClientTest.java index 712aea7ab2..93a69dd8ec 100644 --- a/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/rest/RestClientTest.java +++ b/hugegraph-commons/hugegraph-common/src/test/java/org/apache/hugegraph/unit/rest/RestClientTest.java @@ -112,7 +112,7 @@ public void testPostWithTokenAndAllParams() { @Test public void testPostHttpsWithAllParams() { - String url = "https://github.com/apache/incubator-hugegraph-doc/" + + String url = "https://github.com/apache/hugegraph-doc/" + "raw/master/dist/commons/cacerts.jks"; String trustStoreFile = "src/test/resources/cacerts.jks"; BaseUnitTest.downloadFileByUrl(url, trustStoreFile); @@ -129,7 +129,7 @@ public void testPostHttpsWithAllParams() { @Test public void testPostHttpsWithTokenAndAllParams() { - String url = "https://github.com/apache/incubator-hugegraph-doc/" + + String url = "https://github.com/apache/hugegraph-doc/" + "raw/master/dist/commons/cacerts.jks"; String trustStoreFile = "src/test/resources/cacerts.jks"; BaseUnitTest.downloadFileByUrl(url, trustStoreFile); diff --git a/hugegraph-commons/hugegraph-dist/release-docs/LICENSE b/hugegraph-commons/hugegraph-dist/release-docs/LICENSE deleted file mode 100644 index ab02e44829..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/LICENSE +++ /dev/null @@ -1,338 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - - - -============================================================================ - APACHE HUGEGRAPH (Incubating) SUBCOMPONENTS: - - The Apache HugeGraph(Incubating) project contains subcomponents with separate copyright - notices and license terms. Your use of the source code for the these - subcomponents is subject to the terms and conditions of the following - licenses. - - -======================================================================== -Third party Apache 2.0 licenses -======================================================================== - -The following components are provided under the Apache 2.0 License. -See licenses/ for text of these licenses. - - (Apache License, 2.0) Javassist (org.javassist:javassist:3.28.0-GA - http://www.javassist.org/) - (Apache License, Version 2.0) * Apache Commons BeanUtils:- commons-beanutils:commons-beanutils:1.9.4 (https://commons.apache.org/proper/commons-beanutils/) - (Apache License, Version 2.0) * Apache Commons Codec:- commons-codec:commons-codec:1.13 (https://commons.apache.org/proper/commons-codec/) - (Apache License, Version 2.0) * Apache Commons Collections:- commons-collections:commons-collections:3.2.2 (http://commons.apache.org/collections/) - (Apache License, Version 2.0) * Apache Commons Configuration:- commons-configuration:commons-configuration:1.10 (http://commons.apache.org/configuration/)- org.apache.commons:commons-configuration2:2.8.0 (https://commons.apache.org/proper/commons-configuration/) - (Apache License, Version 2.0) * Apache Commons IO:- commons-io:commons-io:2.7 (https://commons.apache.org/proper/commons-io/) - (Apache License, Version 2.0) * Apache Commons Lang:- org.apache.commons:commons-lang3:3.12.0 (https://commons.apache.org/proper/commons-lang/) - (Apache License, Version 2.0) * Apache Commons Text:- org.apache.commons:commons-text:1.9 (https://commons.apache.org/proper/commons-text) - (Apache License, Version 2.0) * Apache HttpClient:- org.apache.httpcomponents:httpclient:4.5.13 (http://hc.apache.org/httpcomponents-client) - (Apache License, Version 2.0) * Apache HttpCore:- org.apache.httpcomponents:httpcore:4.4.13 (http://hc.apache.org/httpcomponents-core-ga) - (Apache License, Version 2.0) * Apache Log4j API:- org.apache.logging.log4j:log4j-api:2.18.0 (https://logging.apache.org/log4j/2.x/log4j-api/) - (Apache License, Version 2.0) * Apache Log4j Core:- org.apache.logging.log4j:log4j-core:2.18.0 (https://logging.apache.org/log4j/2.x/log4j-core/) - (Apache License, Version 2.0) * Apache Log4j SLF4J Binding:- org.apache.logging.log4j:log4j-slf4j-impl:2.18.0 (https://logging.apache.org/log4j/2.x/log4j-slf4j-impl/) - (Apache License, Version 2.0) * Bean Validation API:- javax.validation:validation-api:1.1.0.Final (http://beanvalidation.org) - (Apache License, Version 2.0) * Byte Buddy (without dependencies):- net.bytebuddy:byte-buddy:1.12.1 (https://bytebuddy.net/byte-buddy) - (Apache License, Version 2.0) * Byte Buddy agent:- net.bytebuddy:byte-buddy-agent:1.12.1 (https://bytebuddy.net/byte-buddy-agent) - (Apache License, Version 2.0) * Commons Lang:- commons-lang:commons-lang:2.6 (http://commons.apache.org/lang/) - (Apache License, Version 2.0) * Commons Logging:- commons-logging:commons-logging:1.1.1 (http://commons.apache.org/logging) - (Apache License, Version 2.0) * Disruptor Framework:- com.lmax:disruptor:3.3.7 (http://lmax-exchange.github.com/disruptor) - (Apache License, Version 2.0) * FindBugs-jsr305:- com.google.code.findbugs:jsr305:3.0.1 (http://findbugs.sourceforge.net/) - (Apache License, Version 2.0) * Google Android Annotations Library:- com.google.android:annotations:4.1.1.4 (http://source.android.com/) - (Apache License, Version 2.0) * Gson:- com.google.code.gson:gson:2.8.6 (https://github.com/google/gson/gson) - (Apache License, Version 2.0) * Guava InternalFutureFailureAccess and InternalFutures:- com.google.guava:failureaccess:1.0.1 (https://github.com/google/guava/failureaccess) - (Apache License, Version 2.0) * Guava ListenableFuture only:- com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava (https://github.com/google/guava/listenablefuture) - (Apache License, Version 2.0) * Guava: Google Core Libraries for Java:- com.google.guava:guava:30.0-jre (https://github.com/google/guava/guava) - (Apache License, Version 2.0) * J2ObjC Annotations:- com.google.j2objc:j2objc-annotations:1.3 (https://github.com/google/j2objc/) - (Apache License, Version 2.0) * Jackson module: Old JAXB Annotations (javax.xml.bind):- com.fasterxml.jackson.module:jackson-module-jaxb-annotations:2.14.0-rc1 (https://github.com/FasterXML/jackson-modules-base) - (Apache License, Version 2.0) * Jackson-JAXRS: JSON:- com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider:2.14.0-rc1 (https://github.com/FasterXML/jackson-jaxrs-providers/jackson-jaxrs-json-provider) - (Apache License, Version 2.0) * Jackson-JAXRS: base:- com.fasterxml.jackson.jaxrs:jackson-jaxrs-base:2.14.0-rc1 (https://github.com/FasterXML/jackson-jaxrs-providers/jackson-jaxrs-base) - (Apache License, Version 2.0) * Jackson-annotations:- com.fasterxml.jackson.core:jackson-annotations:2.14.0-rc1 (https://github.com/FasterXML/jackson) - (Apache License, Version 2.0) * Jackson-core:- com.fasterxml.jackson.core:jackson-core:2.14.0-rc1 (https://github.com/FasterXML/jackson-core) - (Apache License, Version 2.0) * Jackson-dataformat-YAML:- com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.9.3 (https://github.com/FasterXML/jackson-dataformats-text) - (Apache License, Version 2.0) * Joda-Time:- joda-time:joda-time:2.10.8 (https://www.joda.org/joda-time/) - (Apache License, Version 2.0) * Netty/All-in-One:- io.netty:netty-all:4.1.42.Final (https://netty.io/netty-all/) - (Apache License, Version 2.0) * Objenesis:- org.objenesis:objenesis:3.2 (http://objenesis.org/objenesis) - (Apache License, Version 2.0) * OpenTracing API:- io.opentracing:opentracing-api:0.22.0 (https://github.com/opentracing/opentracing-java/opentracing-api) - (Apache License, Version 2.0) * OpenTracing-mock:- io.opentracing:opentracing-mock:0.22.0 (https://github.com/opentracing/opentracing-java/opentracing-mock) - (Apache License, Version 2.0) * OpenTracing-noop:- io.opentracing:opentracing-noop:0.22.0 (https://github.com/opentracing/opentracing-java/opentracing-noop) - (Apache License, Version 2.0) * OpenTracing-util:- io.opentracing:opentracing-util:0.22.0 (https://github.com/opentracing/opentracing-java/opentracing-util) - (Apache License, Version 2.0) * SnakeYAML:- org.yaml:snakeyaml:1.18 (http://www.snakeyaml.org) - (Apache License, Version 2.0) * com.alipay.sofa.common:sofa-common-tools:- com.alipay.sofa.common:sofa-common-tools:1.0.12 (https://github.com/sofastack/sofa-common-tools) - (Apache License, Version 2.0) * com.alipay.sofa:bolt:- com.alipay.sofa:bolt:1.6.2 (https://github.com/alipay/sofa-bolt) - (Apache License, Version 2.0) * com.alipay.sofa:hessian:- com.alipay.sofa:hessian:3.3.7 (http://github.com/alipay/sofa-hessian) - (Apache License, Version 2.0) * com.alipay.sofa:sofa-rpc-all:- com.alipay.sofa:sofa-rpc-all:5.7.6 (http://github.com/sofastack/sofa-rpc) - (Apache License, Version 2.0) * error-prone annotations:- com.google.errorprone:error_prone_annotations:2.3.4 (http://nexus.sonatype.org/oss-repository-hosting.html/error_prone_parent/error_prone_annotations) - (Apache License, Version 2.0) * io.grpc:grpc-api:- io.grpc:grpc-api:1.28.0 (https://github.com/grpc/grpc-java) - (Apache License, Version 2.0) * io.grpc:grpc-context:- io.grpc:grpc-context:1.28.0 (https://github.com/grpc/grpc-java) - (Apache License, Version 2.0) * io.grpc:grpc-core:- io.grpc:grpc-core:1.28.0 (https://github.com/grpc/grpc-java) - (Apache License, Version 2.0) * io.grpc:grpc-netty-shaded:- io.grpc:grpc-netty-shaded:1.28.0 (https://github.com/grpc/grpc-java) - (Apache License, Version 2.0) * io.grpc:grpc-protobuf:- io.grpc:grpc-protobuf:1.28.0 (https://github.com/grpc/grpc-java) - (Apache License, Version 2.0) * io.grpc:grpc-protobuf-lite:- io.grpc:grpc-protobuf-lite:1.28.0 (https://github.com/grpc/grpc-java) - (Apache License, Version 2.0) * io.grpc:grpc-stub:- io.grpc:grpc-stub:1.28.0 (https://github.com/grpc/grpc-java) - (Apache License, Version 2.0) * jackson-databind:- com.fasterxml.jackson.core:jackson-databind:2.14.0-rc1 (https://github.com/FasterXML/jackson) - (Apache License, Version 2.0) * lookout-api:- com.alipay.sofa.lookout:lookout-api:1.4.1 (https://github.com/sofastack/sofa-lookout/lookout-api) - (Apache License, Version 2.0) * perfmark:perfmark-api:- io.perfmark:perfmark-api:0.19.0 (https://github.com/perfmark/perfmark) - (Apache License, Version 2.0) * proto-google-common-protos:- com.google.api.grpc:proto-google-common-protos:1.17.0 (https://github.com/googleapis/api-client-staging) - (Apache License, Version 2.0) * swagger-annotations:- io.swagger:swagger-annotations:1.5.18 (https://github.com/swagger-api/swagger-core/modules/swagger-annotations) - (Apache License, Version 2.0) * swagger-core:- io.swagger:swagger-core:1.5.18 (https://github.com/swagger-api/swagger-core/modules/swagger-core) - (Apache License, Version 2.0) * swagger-models:- io.swagger:swagger-models:1.5.18 (https://github.com/swagger-api/swagger-core/modules/swagger-models) - (Apache License, Version 2.0) * tracer-core:- com.alipay.sofa:tracer-core:3.0.8 (https://projects.spring.io/spring-boot/#/spring-boot-starter-parent/sofaboot-dependencies/tracer-all-parent/tracer-core) - (Apache License, Version 2.0) * OkHttp (com.squareup.okhttp3:okhttp:4.10.0 - https://github.com/square/okhttp) - (Apache License, Version 2.0) * OkHttp (com.squareup.okhttp3:logging-interceptor:4.10.0 - https://github.com/square/okhttp) - -======================================================================== -Third party CDDL licenses -======================================================================== - -The following components are provided under the CDDL License. -See licenses/ for text of these licenses. - (CDDL) * JavaBeans Activation Framework API jar:- javax.activation:javax.activation-api:1.2.0 (http://java.net/all/javax.activation-api/) - (CDDL 1.1) * jaxb-api:- javax.xml.bind:jaxb-api:2.3.1 (https://github.com/javaee/jaxb-spec/jaxb-api) - (Dual license consisting of the CDDL v1.1) * Default Provider:- org.glassfish:javax.json:1.0 (http://jsonp.java.net) - - -======================================================================== -Third party EPL licenses -======================================================================== - -The following components are provided under the EPL License. -See licenses/ for text of these licenses. - (Eclipse Public License - v2.0) * HK2 API module:- org.glassfish.hk2:hk2-api:3.0.1 (https://github.com/eclipse-ee4j/glassfish-hk2/hk2-api) - (Eclipse Public License - v2.0) * HK2 Implementation Utilities:- org.glassfish.hk2:hk2-utils:3.0.1 (https://github.com/eclipse-ee4j/glassfish-hk2/hk2-utils) - (Eclipse Public License - v2.0) * OSGi resource locator:- org.glassfish.hk2:osgi-resource-locator:1.0.3 (https://projects.eclipse.org/projects/ee4j/osgi-resource-locator) - (Eclipse Public License - v2.0) * ServiceLocator Default Implementation:- org.glassfish.hk2:hk2-locator:3.0.1 (https://github.com/eclipse-ee4j/glassfish-hk2/hk2-locator) - (Eclipse Public License - v2.0) * aopalliance version 1.0 repackaged as a module:- org.glassfish.hk2.external:aopalliance-repackaged:3.0.1 (https://github.com/eclipse-ee4j/glassfish-hk2/external/aopalliance-repackaged) - (Eclipse Public License - v2.0) * JUnit:- junit:junit:4.13.1 (http://junit.org) - -======================================================================== -Third party EDL licenses -======================================================================== - -The following components are provided under the EDL License. -See licenses/ for text of these licenses. - (Eclipse Distribution License - v1.0) * Jakarta Activation:- com.sun.activation:jakarta.activation:2.0.1 (https://github.com/eclipse-ee4j/jaf/jakarta.activation) - (Eclipse Distribution License - v1.0) * Jakarta Activation API jar:- jakarta.activation:jakarta.activation-api:1.2.2 (https://github.com/eclipse-ee4j/jaf/jakarta.activation-api) - (Eclipse Distribution License - v1.0) * Old JAXB Core:- com.sun.xml.bind:jaxb-core:3.0.2 (https://eclipse-ee4j.github.io/jaxb-ri/) - (Eclipse Distribution License - v1.0) * Old JAXB Runtime:- com.sun.xml.bind:jaxb-impl:3.0.2 (https://eclipse-ee4j.github.io/jaxb-ri/) - - -======================================================================== -Third party BSD licenses -======================================================================== - -The following components are provided under the BSD License. -See licenses/ for text of these licenses. - (The 3-Clause BSD License) * Hamcrest Core:- org.hamcrest:hamcrest-core:1.3 (https://github.com/hamcrest/JavaHamcrest/hamcrest-core) - (The 3-Clause BSD License) * Protocol Buffers [Core]:- com.google.protobuf:protobuf-java:3.11.0 (https://developers.google.com/protocol-buffers/protobuf-java/) - -======================================================================== -Third party MIT licenses -======================================================================== - -The following components are provided under the MIT License. -See licenses/ for text of these licenses. - (The MIT License)* Animal Sniffer Annotations:- org.codehaus.mojo:animal-sniffer-annotations:1.18 (http://www.mojohaus.org/animal-sniffer/animal-sniffer-annotations) - (The MIT License)* Checker Qual:- org.checkerframework:checker-qual:3.5.0 (https://checkerframework.org) - (The MIT License)* SLF4J API Module:- org.slf4j:slf4j-api:1.7.25 (http://www.slf4j.org) - (The MIT License)* mockito-core:- org.mockito:mockito-core:4.1.0 (https://github.com/mockito/mockito) diff --git a/hugegraph-commons/hugegraph-dist/release-docs/NOTICE b/hugegraph-commons/hugegraph-dist/release-docs/NOTICE deleted file mode 100644 index c021594e78..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/NOTICE +++ /dev/null @@ -1,935 +0,0 @@ -Apache HugeGraph(incubating) -Copyright 2022-2024 The Apache Software Foundation - -This product includes software developed at -The Apache Software Foundation (http://www.apache.org/). - -The initial codebase was donated to the ASF by HugeGraph Authors, copyright 2017-2021. - -======================================================================== - -commons-logging NOTICE - -======================================================================== -// ------------------------------------------------------------------ -// NOTICE file corresponding to the section 4d of The Apache License, -// Version 2.0, in this case for Commons Logging -// ------------------------------------------------------------------ - -Commons Logging -Copyright 2001-2007 The Apache Software Foundation - -This product includes/uses software(s) developed by 'an unknown organization' - - Unnamed - avalon-framework:avalon-framework:jar:4.1.3 - - Unnamed - log4j:log4j:jar:1.2.12 - - Unnamed - logkit:logkit:jar:1.0.1 - - -======================================================================== - -httpclient NOTICE - -======================================================================== - -Apache HttpClient -Copyright 1999-2020 The Apache Software Foundation - -This product includes software developed at -The Apache Software Foundation (http://www.apache.org/). - - -======================================================================== - -httpcore NOTICE - -======================================================================== - -Apache HttpCore -Copyright 2005-2020 The Apache Software Foundation - -This product includes software developed at -The Apache Software Foundation (http://www.apache.org/). - - -======================================================================== - -jackson-core-2.14.0 NOTICE - -======================================================================== -# Jackson JSON processor - -Jackson is a high-performance, Free/Open Source JSON processing library. -It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has -been in development since 2007. -It is currently developed by a community of developers. - -## Licensing - -Jackson 2.x core and extension components are licensed under Apache License 2.0 -To find the details that apply to this artifact see the accompanying LICENSE file. - -## Credits - -A list of contributors may be found from CREDITS(-2.x) file, which is included -in some artifacts (usually source distributions); but is always available -from the source code management (SCM) system project uses. -======================================================================== - -jackson-databind-2.14.0 NOTICE - -======================================================================== -# Jackson JSON processor - -Jackson is a high-performance, Free/Open Source JSON processing library. -It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has -been in development since 2007. -It is currently developed by a community of developers. - -## Licensing - -Jackson 2.x core and extension components are licensed under Apache License 2.0 -To find the details that apply to this artifact see the accompanying LICENSE file. - -## Credits - -A list of contributors may be found from CREDITS(-2.x) file, which is included -in some artifacts (usually source distributions); but is always available -from the source code management (SCM) system project uses. -======================================================================== - -jackson-dataformat-yaml NOTICE - -======================================================================== -# Jackson JSON processor - -Jackson is a high-performance, Free/Open Source JSON processing library. -It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has -been in development since 2007. -It is currently developed by a community of developers, as well as supported -commercially by FasterXML.com. - -## Licensing - -Jackson core and extension components may be licensed under different licenses. -To find the details that apply to this artifact see the accompanying LICENSE file. -For more information, including possible other licensing options, contact -FasterXML.com (http://fasterxml.com). - -## Credits - -A list of contributors may be found from CREDITS file, which is included -in some artifacts (usually source distributions); but is always available -from the source code management (SCM) system project uses. -======================================================================== - -jackson-jaxrs-json-provider-2.14.0 NOTICE - -======================================================================== -# Jackson JSON processor - -Jackson is a high-performance, Free/Open Source JSON processing library. -It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has -been in development since 2007. -It is currently developed by a community of developers, as well as supported -commercially by FasterXML.com. - -## Licensing - -Jackson core and extension components may be licensed under different licenses. -To find the details that apply to this artifact see the accompanying LICENSE file. -For more information, including possible other licensing options, contact -FasterXML.com (http://fasterxml.com). - -## Credits - -A list of contributors may be found from CREDITS file, which is included -in some artifacts (usually source distributions); but is always available -from the source code management (SCM) system project uses. -======================================================================== - -jackson-module-jaxb-annotations-2.14.0 NOTICE - -======================================================================== -# Jackson JSON processor - -Jackson is a high-performance, Free/Open Source JSON processing library. -It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has -been in development since 2007. -It is currently developed by a community of developers, as well as supported -commercially by FasterXML.com. - -## Licensing - -Jackson core and extension components may licensed under different licenses. -To find the details that apply to this artifact see the accompanying LICENSE file. -For more information, including possible other licensing options, contact -FasterXML.com (http://fasterxml.com). - -## Credits - -A list of contributors may be found from CREDITS file, which is included -in some artifacts (usually source distributions); but is always available -from the source code management (SCM) system project uses. -======================================================================== - -log4j-api NOTICE - -======================================================================== - -Apache Log4j API -Copyright 1999-2022 The Apache Software Foundation - -This product includes software developed at -The Apache Software Foundation (http://www.apache.org/). - - -======================================================================== - -log4j-core NOTICE - -======================================================================== -Apache Log4j Core -Copyright 1999-2012 Apache Software Foundation - -This product includes software developed at -The Apache Software Foundation (http://www.apache.org/). - -ResolverUtil.java -Copyright 2005-2006 Tim Fennell - -======================================================================== - -log4j-slf4j-impl NOTICE - -======================================================================== - -Apache Log4j SLF4J Binding -Copyright 1999-2022 The Apache Software Foundation - -This product includes software developed at -The Apache Software Foundation (http://www.apache.org/). - - -======================================================================== - -gRPC NOTICE - -======================================================================== - - -Copyright 2014 The gRPC Authors - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. - ------------------------------------------------------------------------ - -This product contains a modified portion of 'OkHttp', an open source -HTTP & SPDY client for Android and Java applications, which can be obtained -at: - - * LICENSE: - * okhttp/third_party/okhttp/LICENSE (Apache License 2.0) - * HOMEPAGE: - * https://github.com/square/okhttp - * LOCATION_IN_GRPC: - * okhttp/third_party/okhttp - -This product contains a modified portion of 'Envoy', an open source -cloud-native high-performance edge/middle/service proxy, which can be -obtained at: - - * LICENSE: - * xds/third_party/envoy/LICENSE (Apache License 2.0) - * NOTICE: - * xds/third_party/envoy/NOTICE - * HOMEPAGE: - * https://www.envoyproxy.io - * LOCATION_IN_GRPC: - * xds/third_party/envoy - -This product contains a modified portion of 'protoc-gen-validate (PGV)', -an open source protoc plugin to generate polyglot message validators, -which can be obtained at: - - * LICENSE: - * xds/third_party/protoc-gen-validate/LICENSE (Apache License 2.0) - * NOTICE: - * xds/third_party/protoc-gen-validate/NOTICE - * HOMEPAGE: - * https://github.com/envoyproxy/protoc-gen-validate - * LOCATION_IN_GRPC: - * xds/third_party/protoc-gen-validate - -This product contains a modified portion of 'udpa', -an open source universal data plane API, which can be obtained at: - - * LICENSE: - * xds/third_party/udpa/LICENSE (Apache License 2.0) - * HOMEPAGE: - * https://github.com/cncf/udpa - * LOCATION_IN_GRPC: - * xds/third_party/udpa - -======================================================================== - -jaxb-ri NOTICE - -======================================================================== -# Notices for Eclipse Implementation of JAXB - -This content is produced and maintained by the Eclipse Implementation of JAXB -project. - -* Project home: https://projects.eclipse.org/projects/ee4j.jaxb-impl - -## Trademarks - -Eclipse Implementation of JAXB is a trademark of the Eclipse Foundation. - -## Copyright - -All content is the property of the respective authors or their employers. For -more information regarding authorship of content, please consult the listed -source code repository logs. - -## Declared Project Licenses - -This program and the accompanying materials are made available under the terms -of the Eclipse Distribution License v. 1.0 which is available at -http://www.eclipse.org/org/documents/edl-v10.php. - -SPDX-License-Identifier: BSD-3-Clause - -## Source Code - -The project maintains the following source code repositories: - -* https://github.com/eclipse-ee4j/jaxb-ri -* https://github.com/eclipse-ee4j/jaxb-istack-commons -* https://github.com/eclipse-ee4j/jaxb-dtd-parser -* https://github.com/eclipse-ee4j/jaxb-fi -* https://github.com/eclipse-ee4j/jaxb-stax-ex -* https://github.com/eclipse-ee4j/jax-rpc-ri - -## Third-party Content - -This project leverages the following third party content. - -Apache Ant (1.10.2) - -* License: Apache-2.0 AND W3C AND LicenseRef-Public-Domain - -Apache Ant (1.10.2) - -* License: Apache-2.0 AND W3C AND LicenseRef-Public-Domain - -Apache Felix (1.2.0) - -* License: Apache License, 2.0 - -args4j (2.33) - -* License: MIT License - -dom4j (1.6.1) - -* License: Custom license based on Apache 1.1 - -file-management (3.0.0) - -* License: Apache-2.0 -* Project: https://maven.apache.org/shared/file-management/ -* Source: - https://svn.apache.org/viewvc/maven/shared/tags/file-management-3.0.0/ - -JUnit (4.12) - -* License: Eclipse Public License - -JUnit (4.12) - -* License: Eclipse Public License - -maven-compat (3.5.2) - -* License: Apache-2.0 -* Project: https://maven.apache.org/ref/3.5.2/maven-compat/ -* Source: - https://mvnrepository.com/artifact/org.apache.maven/maven-compat/3.5.2 - -maven-core (3.5.2) - -* License: Apache-2.0 -* Project: https://maven.apache.org/ref/3.5.2/maven-core/index.html -* Source: https://mvnrepository.com/artifact/org.apache.maven/maven-core/3.5.2 - -maven-plugin-annotations (3.5) - -* License: Apache-2.0 -* Project: https://maven.apache.org/plugin-tools/maven-plugin-annotations/ -* Source: - https://github.com/apache/maven-plugin-tools/tree/master/maven-plugin-annotations - -maven-plugin-api (3.5.2) - -* License: Apache-2.0 - -maven-resolver-api (1.1.1) - -* License: Apache-2.0 - -maven-resolver-api (1.1.1) - -* License: Apache-2.0 - -maven-resolver-connector-basic (1.1.1) - -* License: Apache-2.0 - -maven-resolver-impl (1.1.1) - -* License: Apache-2.0 - -maven-resolver-spi (1.1.1) - -* License: Apache-2.0 - -maven-resolver-transport-file (1.1.1) - -* License: Apache-2.0 -* Project: https://maven.apache.org/resolver/maven-resolver-transport-file/ -* Source: - https://github.com/apache/maven-resolver/tree/master/maven-resolver-transport-file - -maven-resolver-util (1.1.1) - -* License: Apache-2.0 - -maven-settings (3.5.2) - -* License: Apache-2.0 -* Source: - https://mvnrepository.com/artifact/org.apache.maven/maven-settings/3.5.2 - -OSGi Service Platform Core Companion Code (6.0) - -* License: Apache License, 2.0 - -plexus-archiver (3.5) - -* License: Apache-2.0 -* Project: https://codehaus-plexus.github.io/plexus-archiver/ -* Source: https://github.com/codehaus-plexus/plexus-archiver - -plexus-io (3.0.0) - -* License: Apache-2.0 - -plexus-utils (3.1.0) - -* License: Apache- 2.0 or Apache- 1.1 or BSD or Public Domain or Indiana - University Extreme! Lab Software License V1.1.1 (Apache 1.1 style) - -relaxng-datatype (1.0) - -* License: New BSD license - -Sax (0.2) - -* License: SAX-PD -* Project: http://www.megginson.com/downloads/SAX/ -* Source: http://sourceforge.net/project/showfiles.php?group_id=29449 - -testng (6.14.2) - -* License: Apache-2.0 AND (MIT ) -* Project: https://testng.org/doc/index.html -* Source: https://github.com/cbeust/testng - -wagon-http-lightweight (3.0.0) - -* License: Pending -* Project: https://maven.apache.org/wagon/ -* Source: - https://mvnrepository.com/artifact/org.apache.maven.wagon/wagon-http-lightweight/3.0.0 - -xz for java (1.8) - -* License: LicenseRef-Public-Domain - -## Cryptography - -Content may contain encryption software. The country in which you are currently -may have restrictions on the import, possession, and use, and/or re-export to -another country, of encryption software. BEFORE using any encryption software, -please check the country's laws, regulations and policies concerning the import, -possession, or use, and re-export of encryption software, to see if this is -permitted. - - -======================================================================== - -Swagger Core NOTICE - -======================================================================== -Swagger Core - ${pom.name} -Copyright (c) 2015. SmartBear Software Inc. -Swagger Core - ${pom.name} is licensed under Apache 2.0 license. -Copy of the Apache 2.0 license can be found in `LICENSE` file. - - -======================================================================== - -Joda time NOTICE - -======================================================================== - -============================================================================= -= NOTICE file corresponding to section 4d of the Apache License Version 2.0 = -============================================================================= -This product includes software developed by -Joda.org (https://www.joda.org/). - -======================================================================== - -Eclipse GlassFish NOTICE - -======================================================================== - -# Notices for Eclipse GlassFish - -This content is produced and maintained by the Eclipse GlassFish project. - -* Project home: https://projects.eclipse.org/projects/ee4j.glassfish - -## Trademarks - -Eclipse GlassFish, and GlassFish are trademarks of the Eclipse Foundation. - -## Copyright - -All content is the property of the respective authors or their employers. For -more information regarding authorship of content, please consult the listed -source code repository logs. - -## Declared Project Licenses - -This program and the accompanying materials are made available under the terms -of the Eclipse Public License v. 2.0 which is available at -http://www.eclipse.org/legal/epl-2.0. This Source Code may also be made -available under the following Secondary Licenses when the conditions for such -availability set forth in the Eclipse Public License v. 2.0 are satisfied: GNU -General Public License, version 2 with the GNU Classpath Exception which is -available at https://www.gnu.org/software/classpath/license.html. - -SPDX-License-Identifier: EPL-2.0 - -## Source Code - -The project maintains the following source code repositories: - -* https://github.com/eclipse-ee4j/glassfish-ha-api -* https://github.com/eclipse-ee4j/glassfish-logging-annotation-processor -* https://github.com/eclipse-ee4j/glassfish-shoal -* https://github.com/eclipse-ee4j/glassfish-cdi-porting-tck -* https://github.com/eclipse-ee4j/glassfish-jsftemplating -* https://github.com/eclipse-ee4j/glassfish-hk2-extra -* https://github.com/eclipse-ee4j/glassfish-hk2 -* https://github.com/eclipse-ee4j/glassfish-fighterfish - -## Third-party Content - -This project leverages the following third party content. - -None - -## Cryptography - -Content may contain encryption software. The country in which you are currently -may have restrictions on the import, possession, and use, and/or re-export to -another country, of encryption software. BEFORE using any encryption software, -please check the country's laws, regulations and policies concerning the import, -possession, or use, and re-export of encryption software, to see if this is -permitted. - - -======================================================================== - -netty NOTICE - -======================================================================== - - The Netty Project - ================= - -Please visit the Netty web site for more information: - - * https://netty.io/ - -Copyright 2014 The Netty Project - -The Netty Project licenses this file to you under the Apache License, -version 2.0 (the "License"); you may not use this file except in compliance -with the License. You may obtain a copy of the License at: - - https://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -License for the specific language governing permissions and limitations -under the License. - -Also, please refer to each LICENSE..txt file, which is located in -the 'license' directory of the distribution file, for the license terms of the -components that this product depends on. - -------------------------------------------------------------------------------- -This product contains the extensions to Java Collections Framework which has -been derived from the works by JSR-166 EG, Doug Lea, and Jason T. Greene: - - * LICENSE: - * license/LICENSE.jsr166y.txt (Public Domain) - * HOMEPAGE: - * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/ - * http://viewvc.jboss.org/cgi-bin/viewvc.cgi/jbosscache/experimental/jsr166/ - -This product contains a modified version of Robert Harder's Public Domain -Base64 Encoder and Decoder, which can be obtained at: - - * LICENSE: - * license/LICENSE.base64.txt (Public Domain) - * HOMEPAGE: - * http://iharder.sourceforge.net/current/java/base64/ - -This product contains a modified portion of 'Webbit', an event based -WebSocket and HTTP server, which can be obtained at: - - * LICENSE: - * license/LICENSE.webbit.txt (BSD License) - * HOMEPAGE: - * https://github.com/joewalnes/webbit - -This product contains a modified portion of 'SLF4J', a simple logging -facade for Java, which can be obtained at: - - * LICENSE: - * license/LICENSE.slf4j.txt (MIT License) - * HOMEPAGE: - * https://www.slf4j.org/ - -This product contains a modified portion of 'Apache Harmony', an open source -Java SE, which can be obtained at: - - * NOTICE: - * license/NOTICE.harmony.txt - * LICENSE: - * license/LICENSE.harmony.txt (Apache License 2.0) - * HOMEPAGE: - * https://archive.apache.org/dist/harmony/ - -This product contains a modified portion of 'jbzip2', a Java bzip2 compression -and decompression library written by Matthew J. Francis. It can be obtained at: - - * LICENSE: - * license/LICENSE.jbzip2.txt (MIT License) - * HOMEPAGE: - * https://code.google.com/p/jbzip2/ - -This product contains a modified portion of 'libdivsufsort', a C API library to construct -the suffix array and the Burrows-Wheeler transformed string for any input string of -a constant-size alphabet written by Yuta Mori. It can be obtained at: - - * LICENSE: - * license/LICENSE.libdivsufsort.txt (MIT License) - * HOMEPAGE: - * https://github.com/y-256/libdivsufsort - -This product contains a modified portion of Nitsan Wakart's 'JCTools', Java Concurrency Tools for the JVM, - which can be obtained at: - - * LICENSE: - * license/LICENSE.jctools.txt (ASL2 License) - * HOMEPAGE: - * https://github.com/JCTools/JCTools - -This product optionally depends on 'JZlib', a re-implementation of zlib in -pure Java, which can be obtained at: - - * LICENSE: - * license/LICENSE.jzlib.txt (BSD style License) - * HOMEPAGE: - * http://www.jcraft.com/jzlib/ - -This product optionally depends on 'Compress-LZF', a Java library for encoding and -decoding data in LZF format, written by Tatu Saloranta. It can be obtained at: - - * LICENSE: - * license/LICENSE.compress-lzf.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/ning/compress - -This product optionally depends on 'lz4', a LZ4 Java compression -and decompression library written by Adrien Grand. It can be obtained at: - - * LICENSE: - * license/LICENSE.lz4.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/jpountz/lz4-java - -This product optionally depends on 'lzma-java', a LZMA Java compression -and decompression library, which can be obtained at: - - * LICENSE: - * license/LICENSE.lzma-java.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/jponge/lzma-java - -This product optionally depends on 'zstd-jni', a zstd-jni Java compression -and decompression library, which can be obtained at: - - * LICENSE: - * license/LICENSE.zstd-jni.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/luben/zstd-jni - -This product contains a modified portion of 'jfastlz', a Java port of FastLZ compression -and decompression library written by William Kinney. It can be obtained at: - - * LICENSE: - * license/LICENSE.jfastlz.txt (MIT License) - * HOMEPAGE: - * https://code.google.com/p/jfastlz/ - -This product contains a modified portion of and optionally depends on 'Protocol Buffers', Google's data -interchange format, which can be obtained at: - - * LICENSE: - * license/LICENSE.protobuf.txt (New BSD License) - * HOMEPAGE: - * https://github.com/google/protobuf - -This product optionally depends on 'Bouncy Castle Crypto APIs' to generate -a temporary self-signed X.509 certificate when the JVM does not provide the -equivalent functionality. It can be obtained at: - - * LICENSE: - * license/LICENSE.bouncycastle.txt (MIT License) - * HOMEPAGE: - * https://www.bouncycastle.org/ - -This product optionally depends on 'Snappy', a compression library produced -by Google Inc, which can be obtained at: - - * LICENSE: - * license/LICENSE.snappy.txt (New BSD License) - * HOMEPAGE: - * https://github.com/google/snappy - -This product optionally depends on 'JBoss Marshalling', an alternative Java -serialization API, which can be obtained at: - - * LICENSE: - * license/LICENSE.jboss-marshalling.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/jboss-remoting/jboss-marshalling - -This product optionally depends on 'Caliper', Google's micro- -benchmarking framework, which can be obtained at: - - * LICENSE: - * license/LICENSE.caliper.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/google/caliper - -This product optionally depends on 'Apache Commons Logging', a logging -framework, which can be obtained at: - - * LICENSE: - * license/LICENSE.commons-logging.txt (Apache License 2.0) - * HOMEPAGE: - * https://commons.apache.org/logging/ - -This product optionally depends on 'Apache Log4J', a logging framework, which -can be obtained at: - - * LICENSE: - * license/LICENSE.log4j.txt (Apache License 2.0) - * HOMEPAGE: - * https://logging.apache.org/log4j/ - -This product optionally depends on 'Aalto XML', an ultra-high performance -non-blocking XML processor, which can be obtained at: - - * LICENSE: - * license/LICENSE.aalto-xml.txt (Apache License 2.0) - * HOMEPAGE: - * https://wiki.fasterxml.com/AaltoHome - -This product contains a modified version of 'HPACK', a Java implementation of -the HTTP/2 HPACK algorithm written by Twitter. It can be obtained at: - - * LICENSE: - * license/LICENSE.hpack.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/twitter/hpack - -This product contains a modified version of 'HPACK', a Java implementation of -the HTTP/2 HPACK algorithm written by Cory Benfield. It can be obtained at: - - * LICENSE: - * license/LICENSE.hyper-hpack.txt (MIT License) - * HOMEPAGE: - * https://github.com/python-hyper/hpack/ - -This product contains a modified version of 'HPACK', a Java implementation of -the HTTP/2 HPACK algorithm written by Tatsuhiro Tsujikawa. It can be obtained at: - - * LICENSE: - * license/LICENSE.nghttp2-hpack.txt (MIT License) - * HOMEPAGE: - * https://github.com/nghttp2/nghttp2/ - -This product contains a modified portion of 'Apache Commons Lang', a Java library -provides utilities for the java.lang API, which can be obtained at: - - * LICENSE: - * license/LICENSE.commons-lang.txt (Apache License 2.0) - * HOMEPAGE: - * https://commons.apache.org/proper/commons-lang/ - - -This product contains the Maven wrapper scripts from 'Maven Wrapper', that provides an easy way to ensure a user has everything necessary to run the Maven build. - - * LICENSE: - * license/LICENSE.mvn-wrapper.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/takari/maven-wrapper - -This product contains the dnsinfo.h header file, that provides a way to retrieve the system DNS configuration on MacOS. -This private header is also used by Apple's open source - mDNSResponder (https://opensource.apple.com/tarballs/mDNSResponder/). - - * LICENSE: - * license/LICENSE.dnsinfo.txt (Apple Public Source License 2.0) - * HOMEPAGE: - * https://www.opensource.apple.com/source/configd/configd-453.19/dnsinfo/dnsinfo.h - -This product optionally depends on 'Brotli4j', Brotli compression and -decompression for Java., which can be obtained at: - - * LICENSE: - * license/LICENSE.brotli4j.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/hyperxpro/Brotli4j -======================================================================== - -perfmark NOTICE - -======================================================================== - -Copyright 2019 Google LLC - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. - ------------------------------------------------------------------------ - -This product contains a modified portion of 'Catapult', an open source -Trace Event viewer for Chome, Linux, and Android applications, which can -be obtained at: - - * LICENSE: - * traceviewer/src/main/resources/io/perfmark/traceviewer/third_party/catapult/LICENSE (New BSD License) - * HOMEPAGE: - * https://github.com/catapult-project/catapult - -This product contains a modified portion of 'Polymer', a library for Web -Components, which can be obtained at: - * LICENSE: - * traceviewer/src/main/resources/io/perfmark/traceviewer/third_party/polymer/LICENSE (New BSD License) - * HOMEPAGE: - * https://github.com/Polymer/polymer - - -This product contains a modified portion of 'ASM', an open source -Java Bytecode library, which can be obtained at: - - * LICENSE: - * agent/src/main/resources/io/perfmark/agent/third_party/asm/LICENSE (BSD style License) - * HOMEPAGE: - * https://asm.ow2.io/ -======================================================================== - -junit5 NOTICE - -======================================================================== -Open Source Licenses -==================== - -This product may include a number of subcomponents with separate -copyright notices and license terms. Your use of the source code for -these subcomponents is subject to the terms and conditions of the -subcomponent's license, as noted in the LICENSE-.md -files. -======================================================================== - -jaf-api NOTICE - -======================================================================== - -# Notices for Jakarta Activation - -This content is produced and maintained by Jakarta Activation project. - -* Project home: https://projects.eclipse.org/projects/ee4j.jaf - -## Copyright - -All content is the property of the respective authors or their employers. For -more information regarding authorship of content, please consult the listed -source code repository logs. - -## Declared Project Licenses - -This program and the accompanying materials are made available under the terms -of the Eclipse Distribution License v. 1.0, -which is available at http://www.eclipse.org/org/documents/edl-v10.php. - -SPDX-License-Identifier: BSD-3-Clause - -## Source Code - -The project maintains the following source code repositories: - -* https://github.com/eclipse-ee4j/jaf -======================================================================== - -okhttp NOTICE - -======================================================================== - -Note that publicsuffixes.gz is compiled from The Public Suffix List: -https://publicsuffix.org/list/public_suffix_list.dat - -It is subject to the terms of the Mozilla Public License, v. 2.0: -https://mozilla.org/MPL/2.0/ diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-JavaHamcrest.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-JavaHamcrest.txt deleted file mode 100644 index 4933bda5ba..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-JavaHamcrest.txt +++ /dev/null @@ -1,27 +0,0 @@ -BSD License - -Copyright (c) 2000-2015 www.hamcrest.org -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list of -conditions and the following disclaimer. Redistributions in binary form must reproduce -the above copyright notice, this list of conditions and the following disclaimer in -the documentation and/or other materials provided with the distribution. - -Neither the name of Hamcrest nor the names of its contributors may be used to endorse -or promote products derived from this software without specific prior written -permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY -EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES -OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT -SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR -BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY -WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH -DAMAGE. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-animal-sniffer.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-animal-sniffer.txt deleted file mode 100644 index 370fb559bb..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-animal-sniffer.txt +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License - -Copyright (c) 2009 codehaus.org. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-aopalliance-repackaged.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-aopalliance-repackaged.txt deleted file mode 100644 index 4a00ba9482..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-aopalliance-repackaged.txt +++ /dev/null @@ -1,362 +0,0 @@ -COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.1 - -1. Definitions. - - 1.1. "Contributor" means each individual or entity that creates or - contributes to the creation of Modifications. - - 1.2. "Contributor Version" means the combination of the Original - Software, prior Modifications used by a Contributor (if any), and - the Modifications made by that particular Contributor. - - 1.3. "Covered Software" means (a) the Original Software, or (b) - Modifications, or (c) the combination of files containing Original - Software with files containing Modifications, in each case including - portions thereof. - - 1.4. "Executable" means the Covered Software in any form other than - Source Code. - - 1.5. "Initial Developer" means the individual or entity that first - makes Original Software available under this License. - - 1.6. "Larger Work" means a work which combines Covered Software or - portions thereof with code not governed by the terms of this License. - - 1.7. "License" means this document. - - 1.8. "Licensable" means having the right to grant, to the maximum - extent possible, whether at the time of the initial grant or - subsequently acquired, any and all of the rights conveyed herein. - - 1.9. "Modifications" means the Source Code and Executable form of - any of the following: - - A. Any file that results from an addition to, deletion from or - modification of the contents of a file containing Original Software - or previous Modifications; - - B. Any new file that contains any part of the Original Software or - previous Modification; or - - C. Any new file that is contributed or otherwise made available - under the terms of this License. - - 1.10. "Original Software" means the Source Code and Executable form - of computer software code that is originally released under this - License. - - 1.11. "Patent Claims" means any patent claim(s), now owned or - hereafter acquired, including without limitation, method, process, - and apparatus claims, in any patent Licensable by grantor. - - 1.12. "Source Code" means (a) the common form of computer software - code in which modifications are made and (b) associated - documentation included in or with such code. - - 1.13. "You" (or "Your") means an individual or a legal entity - exercising rights under, and complying with all of the terms of, - this License. For legal entities, "You" includes any entity which - controls, is controlled by, or is under common control with You. For - purposes of this definition, "control" means (a) the power, direct - or indirect, to cause the direction or management of such entity, - whether by contract or otherwise, or (b) ownership of more than - fifty percent (50%) of the outstanding shares or beneficial - ownership of such entity. - -2. License Grants. - - 2.1. The Initial Developer Grant. - - Conditioned upon Your compliance with Section 3.1 below and subject - to third party intellectual property claims, the Initial Developer - hereby grants You a world-wide, royalty-free, non-exclusive license: - - (a) under intellectual property rights (other than patent or - trademark) Licensable by Initial Developer, to use, reproduce, - modify, display, perform, sublicense and distribute the Original - Software (or portions thereof), with or without Modifications, - and/or as part of a Larger Work; and - - (b) under Patent Claims infringed by the making, using or selling of - Original Software, to make, have made, use, practice, sell, and - offer for sale, and/or otherwise dispose of the Original Software - (or portions thereof). - - (c) The licenses granted in Sections 2.1(a) and (b) are effective on - the date Initial Developer first distributes or otherwise makes the - Original Software available to a third party under the terms of this - License. - - (d) Notwithstanding Section 2.1(b) above, no patent license is - granted: (1) for code that You delete from the Original Software, or - (2) for infringements caused by: (i) the modification of the - Original Software, or (ii) the combination of the Original Software - with other software or devices. - - 2.2. Contributor Grant. - - Conditioned upon Your compliance with Section 3.1 below and subject - to third party intellectual property claims, each Contributor hereby - grants You a world-wide, royalty-free, non-exclusive license: - - (a) under intellectual property rights (other than patent or - trademark) Licensable by Contributor to use, reproduce, modify, - display, perform, sublicense and distribute the Modifications - created by such Contributor (or portions thereof), either on an - unmodified basis, with other Modifications, as Covered Software - and/or as part of a Larger Work; and - - (b) under Patent Claims infringed by the making, using, or selling - of Modifications made by that Contributor either alone and/or in - combination with its Contributor Version (or portions of such - combination), to make, use, sell, offer for sale, have made, and/or - otherwise dispose of: (1) Modifications made by that Contributor (or - portions thereof); and (2) the combination of Modifications made by - that Contributor with its Contributor Version (or portions of such - combination). - - (c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective - on the date Contributor first distributes or otherwise makes the - Modifications available to a third party. - - (d) Notwithstanding Section 2.2(b) above, no patent license is - granted: (1) for any code that Contributor has deleted from the - Contributor Version; (2) for infringements caused by: (i) third - party modifications of Contributor Version, or (ii) the combination - of Modifications made by that Contributor with other software - (except as part of the Contributor Version) or other devices; or (3) - under Patent Claims infringed by Covered Software in the absence of - Modifications made by that Contributor. - -3. Distribution Obligations. - - 3.1. Availability of Source Code. - - Any Covered Software that You distribute or otherwise make available - in Executable form must also be made available in Source Code form - and that Source Code form must be distributed only under the terms - of this License. You must include a copy of this License with every - copy of the Source Code form of the Covered Software You distribute - or otherwise make available. You must inform recipients of any such - Covered Software in Executable form as to how they can obtain such - Covered Software in Source Code form in a reasonable manner on or - through a medium customarily used for software exchange. - - 3.2. Modifications. - - The Modifications that You create or to which You contribute are - governed by the terms of this License. You represent that You - believe Your Modifications are Your original creation(s) and/or You - have sufficient rights to grant the rights conveyed by this License. - - 3.3. Required Notices. - - You must include a notice in each of Your Modifications that - identifies You as the Contributor of the Modification. You may not - remove or alter any copyright, patent or trademark notices contained - within the Covered Software, or any notices of licensing or any - descriptive text giving attribution to any Contributor or the - Initial Developer. - - 3.4. Application of Additional Terms. - - You may not offer or impose any terms on any Covered Software in - Source Code form that alters or restricts the applicable version of - this License or the recipients' rights hereunder. You may choose to - offer, and to charge a fee for, warranty, support, indemnity or - liability obligations to one or more recipients of Covered Software. - However, you may do so only on Your own behalf, and not on behalf of - the Initial Developer or any Contributor. You must make it - absolutely clear that any such warranty, support, indemnity or - liability obligation is offered by You alone, and You hereby agree - to indemnify the Initial Developer and every Contributor for any - liability incurred by the Initial Developer or such Contributor as a - result of warranty, support, indemnity or liability terms You offer. - - 3.5. Distribution of Executable Versions. - - You may distribute the Executable form of the Covered Software under - the terms of this License or under the terms of a license of Your - choice, which may contain terms different from this License, - provided that You are in compliance with the terms of this License - and that the license for the Executable form does not attempt to - limit or alter the recipient's rights in the Source Code form from - the rights set forth in this License. If You distribute the Covered - Software in Executable form under a different license, You must make - it absolutely clear that any terms which differ from this License - are offered by You alone, not by the Initial Developer or - Contributor. You hereby agree to indemnify the Initial Developer and - every Contributor for any liability incurred by the Initial - Developer or such Contributor as a result of any such terms You offer. - - 3.6. Larger Works. - - You may create a Larger Work by combining Covered Software with - other code not governed by the terms of this License and distribute - the Larger Work as a single product. In such a case, You must make - sure the requirements of this License are fulfilled for the Covered - Software. - -4. Versions of the License. - - 4.1. New Versions. - - Oracle is the initial license steward and may publish revised and/or - new versions of this License from time to time. Each version will be - given a distinguishing version number. Except as provided in Section - 4.3, no one other than the license steward has the right to modify - this License. - - 4.2. Effect of New Versions. - - You may always continue to use, distribute or otherwise make the - Covered Software available under the terms of the version of the - License under which You originally received the Covered Software. If - the Initial Developer includes a notice in the Original Software - prohibiting it from being distributed or otherwise made available - under any subsequent version of the License, You must distribute and - make the Covered Software available under the terms of the version - of the License under which You originally received the Covered - Software. Otherwise, You may also choose to use, distribute or - otherwise make the Covered Software available under the terms of any - subsequent version of the License published by the license steward. - - 4.3. Modified Versions. - - When You are an Initial Developer and You want to create a new - license for Your Original Software, You may create and use a - modified version of this License if You: (a) rename the license and - remove any references to the name of the license steward (except to - note that the license differs from this License); and (b) otherwise - make it clear that the license contains terms which differ from this - License. - -5. DISCLAIMER OF WARRANTY. - - COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, - WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, - INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE - IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR - NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF - THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE - DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY - OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, - REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN - ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS - AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER. - -6. TERMINATION. - - 6.1. This License and the rights granted hereunder will terminate - automatically if You fail to comply with terms herein and fail to - cure such breach within 30 days of becoming aware of the breach. - Provisions which, by their nature, must remain in effect beyond the - termination of this License shall survive. - - 6.2. If You assert a patent infringement claim (excluding - declaratory judgment actions) against Initial Developer or a - Contributor (the Initial Developer or Contributor against whom You - assert such claim is referred to as "Participant") alleging that the - Participant Software (meaning the Contributor Version where the - Participant is a Contributor or the Original Software where the - Participant is the Initial Developer) directly or indirectly - infringes any patent, then any and all rights granted directly or - indirectly to You by such Participant, the Initial Developer (if the - Initial Developer is not the Participant) and all Contributors under - Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice - from Participant terminate prospectively and automatically at the - expiration of such 60 day notice period, unless if within such 60 - day period You withdraw Your claim with respect to the Participant - Software against such Participant either unilaterally or pursuant to - a written agreement with Participant. - - 6.3. If You assert a patent infringement claim against Participant - alleging that the Participant Software directly or indirectly - infringes any patent where such claim is resolved (such as by - license or settlement) prior to the initiation of patent - infringement litigation, then the reasonable value of the licenses - granted by such Participant under Sections 2.1 or 2.2 shall be taken - into account in determining the amount or value of any payment or - license. - - 6.4. In the event of termination under Sections 6.1 or 6.2 above, - all end user licenses that have been validly granted by You or any - distributor hereunder prior to termination (excluding licenses - granted to You by any distributor) shall survive termination. - -7. LIMITATION OF LIABILITY. - - UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT - (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE - INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF - COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE - TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR - CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT - LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER - FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR - LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE - POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT - APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH - PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH - LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR - LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION - AND LIMITATION MAY NOT APPLY TO YOU. - -8. U.S. GOVERNMENT END USERS. - - The Covered Software is a "commercial item," as that term is defined - in 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer - software" (as that term is defined at 48 C.F.R. § - 252.227-7014(a)(1)) and "commercial computer software documentation" - as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent - with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 - (June 1995), all U.S. Government End Users acquire Covered Software - with only those rights set forth herein. This U.S. Government Rights - clause is in lieu of, and supersedes, any other FAR, DFAR, or other - clause or provision that addresses Government rights in computer - software under this License. - -9. MISCELLANEOUS. - - This License represents the complete agreement concerning subject - matter hereof. If any provision of this License is held to be - unenforceable, such provision shall be reformed only to the extent - necessary to make it enforceable. This License shall be governed by - the law of the jurisdiction specified in a notice contained within - the Original Software (except to the extent applicable law, if any, - provides otherwise), excluding such jurisdiction's conflict-of-law - provisions. Any litigation relating to this License shall be subject - to the jurisdiction of the courts located in the jurisdiction and - venue specified in a notice contained within the Original Software, - with the losing party responsible for costs, including, without - limitation, court costs and reasonable attorneys' fees and expenses. - The application of the United Nations Convention on Contracts for - the International Sale of Goods is expressly excluded. Any law or - regulation which provides that the language of a contract shall be - construed against the drafter shall not apply to this License. You - agree that You alone are responsible for compliance with the United - States export administration regulations (and the export control - laws and regulation of any other countries) when You use, distribute - or otherwise make available any Covered Software. - -10. RESPONSIBILITY FOR CLAIMS. - - As between Initial Developer and the Contributors, each party is - responsible for claims and damages arising, directly or indirectly, - out of its utilization of rights under this License and You agree to - work with Initial Developer and Contributors to distribute such - responsibility on an equitable basis. Nothing herein is intended or - shall be deemed to constitute any admission of liability. - ------------------------------------------------------------------------- - -NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION -LICENSE (CDDL) - -The code released under the CDDL shall be governed by the laws of the -State of California (excluding conflict-of-law provisions). Any -litigation relating to this License shall be subject to the jurisdiction -of the Federal Courts of the Northern District of California and the -state courts of the State of California, with venue lying in Santa Clara -County, California. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-api-client-staging.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-api-client-staging.txt deleted file mode 100644 index 97ee06a0a4..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-api-client-staging.txt +++ /dev/null @@ -1,25 +0,0 @@ -Copyright 2016, Google Inc. -All rights reserved. -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-beanutils.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-beanutils.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-beanutils.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-configuration2.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-configuration2.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-configuration2.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-lang.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-lang.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-lang.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-lang3.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-lang3.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-lang3.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-text.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-text.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-text.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-glassfish-hk2.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-glassfish-hk2.txt deleted file mode 100644 index bda7db00c5..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-glassfish-hk2.txt +++ /dev/null @@ -1,277 +0,0 @@ -# Eclipse Public License - v 2.0 - - THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE - PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION - OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. - - 1. DEFINITIONS - - "Contribution" means: - - a) in the case of the initial Contributor, the initial content - Distributed under this Agreement, and - - b) in the case of each subsequent Contributor: - i) changes to the Program, and - ii) additions to the Program; - where such changes and/or additions to the Program originate from - and are Distributed by that particular Contributor. A Contribution - "originates" from a Contributor if it was added to the Program by - such Contributor itself or anyone acting on such Contributor's behalf. - Contributions do not include changes or additions to the Program that - are not Modified Works. - - "Contributor" means any person or entity that Distributes the Program. - - "Licensed Patents" mean patent claims licensable by a Contributor which - are necessarily infringed by the use or sale of its Contribution alone - or when combined with the Program. - - "Program" means the Contributions Distributed in accordance with this - Agreement. - - "Recipient" means anyone who receives the Program under this Agreement - or any Secondary License (as applicable), including Contributors. - - "Derivative Works" shall mean any work, whether in Source Code or other - form, that is based on (or derived from) the Program and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. - - "Modified Works" shall mean any work in Source Code or other form that - results from an addition to, deletion from, or modification of the - contents of the Program, including, for purposes of clarity any new file - in Source Code form that contains any contents of the Program. Modified - Works shall not include works that contain only declarations, - interfaces, types, classes, structures, or files of the Program solely - in each case in order to link to, bind by name, or subclass the Program - or Modified Works thereof. - - "Distribute" means the acts of a) distributing or b) making available - in any manner that enables the transfer of a copy. - - "Source Code" means the form of a Program preferred for making - modifications, including but not limited to software source code, - documentation source, and configuration files. - - "Secondary License" means either the GNU General Public License, - Version 2.0, or any later versions of that license, including any - exceptions or additional permissions as identified by the initial - Contributor. - - 2. GRANT OF RIGHTS - - a) Subject to the terms of this Agreement, each Contributor hereby - grants Recipient a non-exclusive, worldwide, royalty-free copyright - license to reproduce, prepare Derivative Works of, publicly display, - publicly perform, Distribute and sublicense the Contribution of such - Contributor, if any, and such Derivative Works. - - b) Subject to the terms of this Agreement, each Contributor hereby - grants Recipient a non-exclusive, worldwide, royalty-free patent - license under Licensed Patents to make, use, sell, offer to sell, - import and otherwise transfer the Contribution of such Contributor, - if any, in Source Code or other form. This patent license shall - apply to the combination of the Contribution and the Program if, at - the time the Contribution is added by the Contributor, such addition - of the Contribution causes such combination to be covered by the - Licensed Patents. The patent license shall not apply to any other - combinations which include the Contribution. No hardware per se is - licensed hereunder. - - c) Recipient understands that although each Contributor grants the - licenses to its Contributions set forth herein, no assurances are - provided by any Contributor that the Program does not infringe the - patent or other intellectual property rights of any other entity. - Each Contributor disclaims any liability to Recipient for claims - brought by any other entity based on infringement of intellectual - property rights or otherwise. As a condition to exercising the - rights and licenses granted hereunder, each Recipient hereby - assumes sole responsibility to secure any other intellectual - property rights needed, if any. For example, if a third party - patent license is required to allow Recipient to Distribute the - Program, it is Recipient's responsibility to acquire that license - before distributing the Program. - - d) Each Contributor represents that to its knowledge it has - sufficient copyright rights in its Contribution, if any, to grant - the copyright license set forth in this Agreement. - - e) Notwithstanding the terms of any Secondary License, no - Contributor makes additional grants to any Recipient (other than - those set forth in this Agreement) as a result of such Recipient's - receipt of the Program under the terms of a Secondary License - (if permitted under the terms of Section 3). - - 3. REQUIREMENTS - - 3.1 If a Contributor Distributes the Program in any form, then: - - a) the Program must also be made available as Source Code, in - accordance with section 3.2, and the Contributor must accompany - the Program with a statement that the Source Code for the Program - is available under this Agreement, and informs Recipients how to - obtain it in a reasonable manner on or through a medium customarily - used for software exchange; and - - b) the Contributor may Distribute the Program under a license - different than this Agreement, provided that such license: - i) effectively disclaims on behalf of all other Contributors all - warranties and conditions, express and implied, including - warranties or conditions of title and non-infringement, and - implied warranties or conditions of merchantability and fitness - for a particular purpose; - - ii) effectively excludes on behalf of all other Contributors all - liability for damages, including direct, indirect, special, - incidental and consequential damages, such as lost profits; - - iii) does not attempt to limit or alter the recipients' rights - in the Source Code under section 3.2; and - - iv) requires any subsequent distribution of the Program by any - party to be under a license that satisfies the requirements - of this section 3. - - 3.2 When the Program is Distributed as Source Code: - - a) it must be made available under this Agreement, or if the - Program (i) is combined with other material in a separate file or - files made available under a Secondary License, and (ii) the initial - Contributor attached to the Source Code the notice described in - Exhibit A of this Agreement, then the Program may be made available - under the terms of such Secondary Licenses, and - - b) a copy of this Agreement must be included with each copy of - the Program. - - 3.3 Contributors may not remove or alter any copyright, patent, - trademark, attribution notices, disclaimers of warranty, or limitations - of liability ("notices") contained within the Program from any copy of - the Program which they Distribute, provided that Contributors may add - their own appropriate notices. - - 4. COMMERCIAL DISTRIBUTION - - Commercial distributors of software may accept certain responsibilities - with respect to end users, business partners and the like. While this - license is intended to facilitate the commercial use of the Program, - the Contributor who includes the Program in a commercial product - offering should do so in a manner which does not create potential - liability for other Contributors. Therefore, if a Contributor includes - the Program in a commercial product offering, such Contributor - ("Commercial Contributor") hereby agrees to defend and indemnify every - other Contributor ("Indemnified Contributor") against any losses, - damages and costs (collectively "Losses") arising from claims, lawsuits - and other legal actions brought by a third party against the Indemnified - Contributor to the extent caused by the acts or omissions of such - Commercial Contributor in connection with its distribution of the Program - in a commercial product offering. The obligations in this section do not - apply to any claims or Losses relating to any actual or alleged - intellectual property infringement. In order to qualify, an Indemnified - Contributor must: a) promptly notify the Commercial Contributor in - writing of such claim, and b) allow the Commercial Contributor to control, - and cooperate with the Commercial Contributor in, the defense and any - related settlement negotiations. The Indemnified Contributor may - participate in any such claim at its own expense. - - For example, a Contributor might include the Program in a commercial - product offering, Product X. That Contributor is then a Commercial - Contributor. If that Commercial Contributor then makes performance - claims, or offers warranties related to Product X, those performance - claims and warranties are such Commercial Contributor's responsibility - alone. Under this section, the Commercial Contributor would have to - defend claims against the other Contributors related to those performance - claims and warranties, and if a court requires any other Contributor to - pay any damages as a result, the Commercial Contributor must pay - those damages. - - 5. NO WARRANTY - - EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT - PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS" - BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR - IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF - TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR - PURPOSE. Each Recipient is solely responsible for determining the - appropriateness of using and distributing the Program and assumes all - risks associated with its exercise of rights under this Agreement, - including but not limited to the risks and costs of program errors, - compliance with applicable laws, damage to or loss of data, programs - or equipment, and unavailability or interruption of operations. - - 6. DISCLAIMER OF LIABILITY - - EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT - PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS - SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST - PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE - EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGES. - - 7. GENERAL - - If any provision of this Agreement is invalid or unenforceable under - applicable law, it shall not affect the validity or enforceability of - the remainder of the terms of this Agreement, and without further - action by the parties hereto, such provision shall be reformed to the - minimum extent necessary to make such provision valid and enforceable. - - If Recipient institutes patent litigation against any entity - (including a cross-claim or counterclaim in a lawsuit) alleging that the - Program itself (excluding combinations of the Program with other software - or hardware) infringes such Recipient's patent(s), then such Recipient's - rights granted under Section 2(b) shall terminate as of the date such - litigation is filed. - - All Recipient's rights under this Agreement shall terminate if it - fails to comply with any of the material terms or conditions of this - Agreement and does not cure such failure in a reasonable period of - time after becoming aware of such noncompliance. If all Recipient's - rights under this Agreement terminate, Recipient agrees to cease use - and distribution of the Program as soon as reasonably practicable. - However, Recipient's obligations under this Agreement and any licenses - granted by Recipient relating to the Program shall continue and survive. - - Everyone is permitted to copy and distribute copies of this Agreement, - but in order to avoid inconsistency the Agreement is copyrighted and - may only be modified in the following manner. The Agreement Steward - reserves the right to publish new versions (including revisions) of - this Agreement from time to time. No one other than the Agreement - Steward has the right to modify this Agreement. The Eclipse Foundation - is the initial Agreement Steward. The Eclipse Foundation may assign the - responsibility to serve as the Agreement Steward to a suitable separate - entity. Each new version of the Agreement will be given a distinguishing - version number. The Program (including Contributions) may always be - Distributed subject to the version of the Agreement under which it was - received. In addition, after a new version of the Agreement is published, - Contributor may elect to Distribute the Program (including its - Contributions) under the new version. - - Except as expressly stated in Sections 2(a) and 2(b) above, Recipient - receives no rights or licenses to the intellectual property of any - Contributor under this Agreement, whether expressly, by implication, - estoppel or otherwise. All rights in the Program not expressly granted - under this Agreement are reserved. Nothing in this Agreement is intended - to be enforceable by any entity that is not a Contributor or Recipient. - No third-party beneficiary rights are created under this Agreement. - - Exhibit A - Form of Secondary Licenses Notice - - "This Source Code may also be made available under the following - Secondary Licenses when the conditions for such availability set forth - in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), - version(s), and exceptions or additional permissions here}." - - Simply including a copy of this Agreement, including this Exhibit A - is not sufficient to license the Source Code under Secondary Licenses. - - If it is not possible or desirable to put the notice in a particular - file, then You may include the notice in a location (such as a LICENSE - file in a relevant directory) where a recipient would be likely to - look for such a notice. - - You may add additional accurate notices of copyright ownership. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-grpc-java.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-grpc-java.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-grpc-java.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-gson.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-gson.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-gson.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-j2objc.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-j2objc.txt deleted file mode 100644 index 2b004c3eee..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-j2objc.txt +++ /dev/null @@ -1,232 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - --------------------------------------------------------------------------------- -The next section, BSD-3-Clause, applies to the files in: -jre_emul/android/platform/libcore/ojluni/src/main/java/java/time --------------------------------------------------------------------------------- -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -* Neither the name of JSR-310 nor the names of its contributors - may be used to endorse or promote products derived from this software - without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-dataformat-yaml.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-dataformat-yaml.txt deleted file mode 100644 index 8d5775d40c..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-dataformat-yaml.txt +++ /dev/null @@ -1,8 +0,0 @@ -This copy of Jackson JSON processor YAML module is licensed under the -Apache (Software) License, version 2.0 ("the License"). -See the License for details about distribution rights, and the -specific rights regarding derivate works. - -You may obtain a copy of the License at: - -http://www.apache.org/licenses/LICENSE-2.0 diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base-2.14.0.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base-2.14.0.txt deleted file mode 100644 index 6acf75483f..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base-2.14.0.txt +++ /dev/null @@ -1,8 +0,0 @@ -This copy of Jackson JSON processor databind module is licensed under the -Apache (Software) License, version 2.0 ("the License"). -See the License for details about distribution rights, and the -specific rights regarding derivate works. - -You may obtain a copy of the License at: - -http://www.apache.org/licenses/LICENSE-2.0 diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base.txt deleted file mode 100644 index 6acf75483f..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base.txt +++ /dev/null @@ -1,8 +0,0 @@ -This copy of Jackson JSON processor databind module is licensed under the -Apache (Software) License, version 2.0 ("the License"). -See the License for details about distribution rights, and the -specific rights regarding derivate works. - -You may obtain a copy of the License at: - -http://www.apache.org/licenses/LICENSE-2.0 diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider-2.14.0.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider-2.14.0.txt deleted file mode 100644 index 6acf75483f..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider-2.14.0.txt +++ /dev/null @@ -1,8 +0,0 @@ -This copy of Jackson JSON processor databind module is licensed under the -Apache (Software) License, version 2.0 ("the License"). -See the License for details about distribution rights, and the -specific rights regarding derivate works. - -You may obtain a copy of the License at: - -http://www.apache.org/licenses/LICENSE-2.0 diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider.txt deleted file mode 100644 index 6acf75483f..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider.txt +++ /dev/null @@ -1,8 +0,0 @@ -This copy of Jackson JSON processor databind module is licensed under the -Apache (Software) License, version 2.0 ("the License"). -See the License for details about distribution rights, and the -specific rights regarding derivate works. - -You may obtain a copy of the License at: - -http://www.apache.org/licenses/LICENSE-2.0 diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations-2.14.0.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations-2.14.0.txt deleted file mode 100644 index 283587f1b1..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations-2.14.0.txt +++ /dev/null @@ -1,8 +0,0 @@ -This copy of Jackson JSON processor `jackson-module-jaxb-annotations` module is licensed under the -Apache (Software) License, version 2.0 ("the License"). -See the License for details about distribution rights, and the -specific rights regarding derivate works. - -You may obtain a copy of the License at: - -http://www.apache.org/licenses/LICENSE-2.0 diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations.txt deleted file mode 100644 index 283587f1b1..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations.txt +++ /dev/null @@ -1,8 +0,0 @@ -This copy of Jackson JSON processor `jackson-module-jaxb-annotations` module is licensed under the -Apache (Software) License, version 2.0 ("the License"). -See the License for details about distribution rights, and the -specific rights regarding derivate works. - -You may obtain a copy of the License at: - -http://www.apache.org/licenses/LICENSE-2.0 diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jaf-api.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jaf-api.txt deleted file mode 100644 index 05220de312..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jaf-api.txt +++ /dev/null @@ -1,29 +0,0 @@ - - Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - - Neither the name of the Eclipse Foundation, Inc. nor the names of its - contributors may be used to endorse or promote products derived - from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS - IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, - THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jakarta.activation-api.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jakarta.activation-api.txt deleted file mode 100644 index e0358f9721..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jakarta.activation-api.txt +++ /dev/null @@ -1,29 +0,0 @@ - - Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - - Neither the name of the Eclipse Foundation, Inc. nor the names of its - contributors may be used to endorse or promote products derived - from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS - IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, - THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jakarta.activation.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jakarta.activation.txt deleted file mode 100644 index a8ba56ef14..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jakarta.activation.txt +++ /dev/null @@ -1,277 +0,0 @@ -# Eclipse Public License - v 2.0 - - THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE - PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION - OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. - - 1. DEFINITIONS - - "Contribution" means: - - a) in the case of the initial Contributor, the initial content - Distributed under this Agreement, and - - b) in the case of each subsequent Contributor: - i) changes to the Program, and - ii) additions to the Program; - where such changes and/or additions to the Program originate from - and are Distributed by that particular Contributor. A Contribution - "originates" from a Contributor if it was added to the Program by - such Contributor itself or anyone acting on such Contributor's behalf. - Contributions do not include changes or additions to the Program that - are not Modified Works. - - "Contributor" means any person or entity that Distributes the Program. - - "Licensed Patents" mean patent claims licensable by a Contributor which - are necessarily infringed by the use or sale of its Contribution alone - or when combined with the Program. - - "Program" means the Contributions Distributed in accordance with this - Agreement. - - "Recipient" means anyone who receives the Program under this Agreement - or any Secondary License (as applicable), including Contributors. - - "Derivative Works" shall mean any work, whether in Source Code or other - form, that is based on (or derived from) the Program and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. - - "Modified Works" shall mean any work in Source Code or other form that - results from an addition to, deletion from, or modification of the - contents of the Program, including, for purposes of clarity any new file - in Source Code form that contains any contents of the Program. Modified - Works shall not include works that contain only declarations, - interfaces, types, classes, structures, or files of the Program solely - in each case in order to link to, bind by name, or subclass the Program - or Modified Works thereof. - - "Distribute" means the acts of a) distributing or b) making available - in any manner that enables the transfer of a copy. - - "Source Code" means the form of a Program preferred for making - modifications, including but not limited to software source code, - documentation source, and configuration files. - - "Secondary License" means either the GNU General Public License, - Version 2.0, or any later versions of that license, including any - exceptions or additional permissions as identified by the initial - Contributor. - - 2. GRANT OF RIGHTS - - a) Subject to the terms of this Agreement, each Contributor hereby - grants Recipient a non-exclusive, worldwide, royalty-free copyright - license to reproduce, prepare Derivative Works of, publicly display, - publicly perform, Distribute and sublicense the Contribution of such - Contributor, if any, and such Derivative Works. - - b) Subject to the terms of this Agreement, each Contributor hereby - grants Recipient a non-exclusive, worldwide, royalty-free patent - license under Licensed Patents to make, use, sell, offer to sell, - import and otherwise transfer the Contribution of such Contributor, - if any, in Source Code or other form. This patent license shall - apply to the combination of the Contribution and the Program if, at - the time the Contribution is added by the Contributor, such addition - of the Contribution causes such combination to be covered by the - Licensed Patents. The patent license shall not apply to any other - combinations which include the Contribution. No hardware per se is - licensed hereunder. - - c) Recipient understands that although each Contributor grants the - licenses to its Contributions set forth herein, no assurances are - provided by any Contributor that the Program does not infringe the - patent or other intellectual property rights of any other entity. - Each Contributor disclaims any liability to Recipient for claims - brought by any other entity based on infringement of intellectual - property rights or otherwise. As a condition to exercising the - rights and licenses granted hereunder, each Recipient hereby - assumes sole responsibility to secure any other intellectual - property rights needed, if any. For example, if a third party - patent license is required to allow Recipient to Distribute the - Program, it is Recipient's responsibility to acquire that license - before distributing the Program. - - d) Each Contributor represents that to its knowledge it has - sufficient copyright rights in its Contribution, if any, to grant - the copyright license set forth in this Agreement. - - e) Notwithstanding the terms of any Secondary License, no - Contributor makes additional grants to any Recipient (other than - those set forth in this Agreement) as a result of such Recipient's - receipt of the Program under the terms of a Secondary License - (if permitted under the terms of Section 3). - - 3. REQUIREMENTS - - 3.1 If a Contributor Distributes the Program in any form, then: - - a) the Program must also be made available as Source Code, in - accordance with section 3.2, and the Contributor must accompany - the Program with a statement that the Source Code for the Program - is available under this Agreement, and informs Recipients how to - obtain it in a reasonable manner on or through a medium customarily - used for software exchange; and - - b) the Contributor may Distribute the Program under a license - different than this Agreement, provided that such license: - i) effectively disclaims on behalf of all other Contributors all - warranties and conditions, express and implied, including - warranties or conditions of title and non-infringement, and - implied warranties or conditions of merchantability and fitness - for a particular purpose; - - ii) effectively excludes on behalf of all other Contributors all - liability for damages, including direct, indirect, special, - incidental and consequential damages, such as lost profits; - - iii) does not attempt to limit or alter the recipients' rights - in the Source Code under section 3.2; and - - iv) requires any subsequent distribution of the Program by any - party to be under a license that satisfies the requirements - of this section 3. - - 3.2 When the Program is Distributed as Source Code: - - a) it must be made available under this Agreement, or if the - Program (i) is combined with other material in a separate file or - files made available under a Secondary License, and (ii) the initial - Contributor attached to the Source Code the notice described in - Exhibit A of this Agreement, then the Program may be made available - under the terms of such Secondary Licenses, and - - b) a copy of this Agreement must be included with each copy of - the Program. - - 3.3 Contributors may not remove or alter any copyright, patent, - trademark, attribution notices, disclaimers of warranty, or limitations - of liability ("notices") contained within the Program from any copy of - the Program which they Distribute, provided that Contributors may add - their own appropriate notices. - - 4. COMMERCIAL DISTRIBUTION - - Commercial distributors of software may accept certain responsibilities - with respect to end users, business partners and the like. While this - license is intended to facilitate the commercial use of the Program, - the Contributor who includes the Program in a commercial product - offering should do so in a manner which does not create potential - liability for other Contributors. Therefore, if a Contributor includes - the Program in a commercial product offering, such Contributor - ("Commercial Contributor") hereby agrees to defend and indemnify every - other Contributor ("Indemnified Contributor") against any losses, - damages and costs (collectively "Losses") arising from claims, lawsuits - and other legal actions brought by a third party against the Indemnified - Contributor to the extent caused by the acts or omissions of such - Commercial Contributor in connection with its distribution of the Program - in a commercial product offering. The obligations in this section do not - apply to any claims or Losses relating to any actual or alleged - intellectual property infringement. In order to qualify, an Indemnified - Contributor must: a) promptly notify the Commercial Contributor in - writing of such claim, and b) allow the Commercial Contributor to control, - and cooperate with the Commercial Contributor in, the defense and any - related settlement negotiations. The Indemnified Contributor may - participate in any such claim at its own expense. - - For example, a Contributor might include the Program in a commercial - product offering, Product X. That Contributor is then a Commercial - Contributor. If that Commercial Contributor then makes performance - claims, or offers warranties related to Product X, those performance - claims and warranties are such Commercial Contributor's responsibility - alone. Under this section, the Commercial Contributor would have to - defend claims against the other Contributors related to those performance - claims and warranties, and if a court requires any other Contributor to - pay any damages as a result, the Commercial Contributor must pay - those damages. - - 5. NO WARRANTY - - EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT - PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS" - BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR - IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF - TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR - PURPOSE. Each Recipient is solely responsible for determining the - appropriateness of using and distributing the Program and assumes all - risks associated with its exercise of rights under this Agreement, - including but not limited to the risks and costs of program errors, - compliance with applicable laws, damage to or loss of data, programs - or equipment, and unavailability or interruption of operations. - - 6. DISCLAIMER OF LIABILITY - - EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT - PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS - SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST - PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE - EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGES. - - 7. GENERAL - - If any provision of this Agreement is invalid or unenforceable under - applicable law, it shall not affect the validity or enforceability of - the remainder of the terms of this Agreement, and without further - action by the parties hereto, such provision shall be reformed to the - minimum extent necessary to make such provision valid and enforceable. - - If Recipient institutes patent litigation against any entity - (including a cross-claim or counterclaim in a lawsuit) alleging that the - Program itself (excluding combinations of the Program with other software - or hardware) infringes such Recipient's patent(s), then such Recipient's - rights granted under Section 2(b) shall terminate as of the date such - litigation is filed. - - All Recipient's rights under this Agreement shall terminate if it - fails to comply with any of the material terms or conditions of this - Agreement and does not cure such failure in a reasonable period of - time after becoming aware of such noncompliance. If all Recipient's - rights under this Agreement terminate, Recipient agrees to cease use - and distribution of the Program as soon as reasonably practicable. - However, Recipient's obligations under this Agreement and any licenses - granted by Recipient relating to the Program shall continue and survive. - - Everyone is permitted to copy and distribute copies of this Agreement, - but in order to avoid inconsistency the Agreement is copyrighted and - may only be modified in the following manner. The Agreement Steward - reserves the right to publish new versions (including revisions) of - this Agreement from time to time. No one other than the Agreement - Steward has the right to modify this Agreement. The Eclipse Foundation - is the initial Agreement Steward. The Eclipse Foundation may assign the - responsibility to serve as the Agreement Steward to a suitable separate - entity. Each new version of the Agreement will be given a distinguishing - version number. The Program (including Contributions) may always be - Distributed subject to the version of the Agreement under which it was - received. In addition, after a new version of the Agreement is published, - Contributor may elect to Distribute the Program (including its - Contributions) under the new version. - - Except as expressly stated in Sections 2(a) and 2(b) above, Recipient - receives no rights or licenses to the intellectual property of any - Contributor under this Agreement, whether expressly, by implication, - estoppel or otherwise. All rights in the Program not expressly granted - under this Agreement are reserved. Nothing in this Agreement is intended - to be enforceable by any entity that is not a Contributor or Recipient. - No third-party beneficiary rights are created under this Agreement. - - Exhibit A - Form of Secondary Licenses Notice - - "This Source Code may also be made available under the following - Secondary Licenses when the conditions for such availability set forth - in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), - version(s), and exceptions or additional permissions here}." - - Simply including a copy of this Agreement, including this Exhibit A - is not sufficient to license the Source Code under Secondary Licenses. - - If it is not possible or desirable to put the notice in a particular - file, then You may include the notice in a location (such as a LICENSE - file in a relevant directory) where a recipient would be likely to - look for such a notice. - - You may add additional accurate notices of copyright ownership. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-javassist.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-javassist.txt deleted file mode 100644 index f45a423e3f..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-javassist.txt +++ /dev/null @@ -1,357 +0,0 @@ - - -Javassist License - - - - -
MOZILLA PUBLIC LICENSE
Version -1.1 -

-

-
-

1. Definitions. -

    1.0.1. "Commercial Use" means distribution or otherwise making the - Covered Code available to a third party. -

    1.1. ''Contributor'' means each entity that creates or contributes - to the creation of Modifications. -

    1.2. ''Contributor Version'' means the combination of the Original - Code, prior Modifications used by a Contributor, and the Modifications made by - that particular Contributor. -

    1.3. ''Covered Code'' means the Original Code or Modifications or - the combination of the Original Code and Modifications, in each case including - portions thereof. -

    1.4. ''Electronic Distribution Mechanism'' means a mechanism - generally accepted in the software development community for the electronic - transfer of data. -

    1.5. ''Executable'' means Covered Code in any form other than Source - Code. -

    1.6. ''Initial Developer'' means the individual or entity identified - as the Initial Developer in the Source Code notice required by Exhibit - A. -

    1.7. ''Larger Work'' means a work which combines Covered Code or - portions thereof with code not governed by the terms of this License. -

    1.8. ''License'' means this document. -

    1.8.1. "Licensable" means having the right to grant, to the maximum - extent possible, whether at the time of the initial grant or subsequently - acquired, any and all of the rights conveyed herein. -

    1.9. ''Modifications'' means any addition to or deletion from the - substance or structure of either the Original Code or any previous - Modifications. When Covered Code is released as a series of files, a - Modification is: -

      A. Any addition to or deletion from the contents of a file - containing Original Code or previous Modifications. -

      B. Any new file that contains any part of the Original Code or - previous Modifications.
       

    1.10. ''Original Code'' - means Source Code of computer software code which is described in the Source - Code notice required by Exhibit A as Original Code, and which, at the - time of its release under this License is not already Covered Code governed by - this License. -

    1.10.1. "Patent Claims" means any patent claim(s), now owned or - hereafter acquired, including without limitation,  method, process, and - apparatus claims, in any patent Licensable by grantor. -

    1.11. ''Source Code'' means the preferred form of the Covered Code - for making modifications to it, including all modules it contains, plus any - associated interface definition files, scripts used to control compilation and - installation of an Executable, or source code differential comparisons against - either the Original Code or another well known, available Covered Code of the - Contributor's choice. The Source Code can be in a compressed or archival form, - provided the appropriate decompression or de-archiving software is widely - available for no charge. -

    1.12. "You'' (or "Your")  means an individual or a legal entity - exercising rights under, and complying with all of the terms of, this License - or a future version of this License issued under Section 6.1. For legal - entities, "You'' includes any entity which controls, is controlled by, or is - under common control with You. For purposes of this definition, "control'' - means (a) the power, direct or indirect, to cause the direction or management - of such entity, whether by contract or otherwise, or (b) ownership of more - than fifty percent (50%) of the outstanding shares or beneficial ownership of - such entity.

2. Source Code License. -
    2.1. The Initial Developer Grant.
    The Initial Developer hereby - grants You a world-wide, royalty-free, non-exclusive license, subject to third - party intellectual property claims: -
      (a)  under intellectual property rights (other than - patent or trademark) Licensable by Initial Developer to use, reproduce, - modify, display, perform, sublicense and distribute the Original Code (or - portions thereof) with or without Modifications, and/or as part of a Larger - Work; and -

      (b) under Patents Claims infringed by the making, using or selling - of Original Code, to make, have made, use, practice, sell, and offer for - sale, and/or otherwise dispose of the Original Code (or portions thereof). -

        -
        (c) the licenses granted in this Section 2.1(a) and (b) - are effective on the date Initial Developer first distributes Original Code - under the terms of this License. -

        (d) Notwithstanding Section 2.1(b) above, no patent license is - granted: 1) for code that You delete from the Original Code; 2) separate - from the Original Code;  or 3) for infringements caused by: i) the - modification of the Original Code or ii) the combination of the Original - Code with other software or devices.
         

      2.2. Contributor - Grant.
      Subject to third party intellectual property claims, each - Contributor hereby grants You a world-wide, royalty-free, non-exclusive - license -

        (a)  under intellectual property rights (other - than patent or trademark) Licensable by Contributor, to use, reproduce, - modify, display, perform, sublicense and distribute the Modifications - created by such Contributor (or portions thereof) either on an unmodified - basis, with other Modifications, as Covered Code and/or as part of a Larger - Work; and -

        (b) under Patent Claims infringed by the making, using, or selling - of  Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such - combination), to make, use, sell, offer for sale, have made, and/or - otherwise dispose of: 1) Modifications made by that Contributor (or portions - thereof); and 2) the combination of  Modifications made by that - Contributor with its Contributor Version (or portions of such - combination). -

        (c) the licenses granted in Sections 2.2(a) and 2.2(b) are - effective on the date Contributor first makes Commercial Use of the Covered - Code. -

        (d)    Notwithstanding Section 2.2(b) above, no - patent license is granted: 1) for any code that Contributor has deleted from - the Contributor Version; 2)  separate from the Contributor - Version;  3)  for infringements caused by: i) third party - modifications of Contributor Version or ii)  the combination of - Modifications made by that Contributor with other software  (except as - part of the Contributor Version) or other devices; or 4) under Patent Claims - infringed by Covered Code in the absence of Modifications made by that - Contributor.

    -


    3. Distribution Obligations. -

      3.1. Application of License.
      The Modifications which You create - or to which You contribute are governed by the terms of this License, - including without limitation Section 2.2. The Source Code version of - Covered Code may be distributed only under the terms of this License or a - future version of this License released under Section 6.1, and You must - include a copy of this License with every copy of the Source Code You - distribute. You may not offer or impose any terms on any Source Code version - that alters or restricts the applicable version of this License or the - recipients' rights hereunder. However, You may include an additional document - offering the additional rights described in Section 3.5. -

      3.2. Availability of Source Code.
      Any Modification which You - create or to which You contribute must be made available in Source Code form - under the terms of this License either on the same media as an Executable - version or via an accepted Electronic Distribution Mechanism to anyone to whom - you made an Executable version available; and if made available via Electronic - Distribution Mechanism, must remain available for at least twelve (12) months - after the date it initially became available, or at least six (6) months after - a subsequent version of that particular Modification has been made available - to such recipients. You are responsible for ensuring that the Source Code - version remains available even if the Electronic Distribution Mechanism is - maintained by a third party. -

      3.3. Description of Modifications.
      You must cause all Covered - Code to which You contribute to contain a file documenting the changes You - made to create that Covered Code and the date of any change. You must include - a prominent statement that the Modification is derived, directly or - indirectly, from Original Code provided by the Initial Developer and including - the name of the Initial Developer in (a) the Source Code, and (b) in any - notice in an Executable version or related documentation in which You describe - the origin or ownership of the Covered Code. -

      3.4. Intellectual Property Matters -

        (a) Third Party Claims.
        If Contributor has knowledge that a - license under a third party's intellectual property rights is required to - exercise the rights granted by such Contributor under Sections 2.1 or 2.2, - Contributor must include a text file with the Source Code distribution - titled "LEGAL'' which describes the claim and the party making the claim in - sufficient detail that a recipient will know whom to contact. If Contributor - obtains such knowledge after the Modification is made available as described - in Section 3.2, Contributor shall promptly modify the LEGAL file in all - copies Contributor makes available thereafter and shall take other steps - (such as notifying appropriate mailing lists or newsgroups) reasonably - calculated to inform those who received the Covered Code that new knowledge - has been obtained. -

        (b) Contributor APIs.
        If Contributor's Modifications include - an application programming interface and Contributor has knowledge of patent - licenses which are reasonably necessary to implement that API, Contributor - must also include this information in the LEGAL file. -
         

                - (c)    Representations. -
        Contributor represents that, except as disclosed pursuant to Section - 3.4(a) above, Contributor believes that Contributor's Modifications are - Contributor's original creation(s) and/or Contributor has sufficient rights - to grant the rights conveyed by this License.
      -


      3.5. Required Notices.
      You must duplicate the notice in - Exhibit A in each file of the Source Code.  If it is not possible - to put such notice in a particular Source Code file due to its structure, then - You must include such notice in a location (such as a relevant directory) - where a user would be likely to look for such a notice.  If You created - one or more Modification(s) You may add your name as a Contributor to the - notice described in Exhibit A.  You must also duplicate this - License in any documentation for the Source Code where You describe - recipients' rights or ownership rights relating to Covered Code.  You may - choose to offer, and to charge a fee for, warranty, support, indemnity or - liability obligations to one or more recipients of Covered Code. However, You - may do so only on Your own behalf, and not on behalf of the Initial Developer - or any Contributor. You must make it absolutely clear than any such warranty, - support, indemnity or liability obligation is offered by You alone, and You - hereby agree to indemnify the Initial Developer and every Contributor for any - liability incurred by the Initial Developer or such Contributor as a result of - warranty, support, indemnity or liability terms You offer. -

      3.6. Distribution of Executable Versions.
      You may distribute - Covered Code in Executable form only if the requirements of Section - 3.1-3.5 have been met for that Covered Code, and if You include a - notice stating that the Source Code version of the Covered Code is available - under the terms of this License, including a description of how and where You - have fulfilled the obligations of Section 3.2. The notice must be - conspicuously included in any notice in an Executable version, related - documentation or collateral in which You describe recipients' rights relating - to the Covered Code. You may distribute the Executable version of Covered Code - or ownership rights under a license of Your choice, which may contain terms - different from this License, provided that You are in compliance with the - terms of this License and that the license for the Executable version does not - attempt to limit or alter the recipient's rights in the Source Code version - from the rights set forth in this License. If You distribute the Executable - version under a different license You must make it absolutely clear that any - terms which differ from this License are offered by You alone, not by the - Initial Developer or any Contributor. You hereby agree to indemnify the - Initial Developer and every Contributor for any liability incurred by the - Initial Developer or such Contributor as a result of any such terms You offer. - -

      3.7. Larger Works.
      You may create a Larger Work by combining - Covered Code with other code not governed by the terms of this License and - distribute the Larger Work as a single product. In such a case, You must make - sure the requirements of this License are fulfilled for the Covered -Code.

    4. Inability to Comply Due to Statute or Regulation. -
      If it is impossible for You to comply with any of the terms of this - License with respect to some or all of the Covered Code due to statute, - judicial order, or regulation then You must: (a) comply with the terms of this - License to the maximum extent possible; and (b) describe the limitations and - the code they affect. Such description must be included in the LEGAL file - described in Section 3.4 and must be included with all distributions of - the Source Code. Except to the extent prohibited by statute or regulation, - such description must be sufficiently detailed for a recipient of ordinary - skill to be able to understand it.
    5. Application of this License. -
      This License applies to code to which the Initial Developer has attached - the notice in Exhibit A and to related Covered Code.
    6. Versions -of the License. -
      6.1. New Versions.
      Netscape Communications Corporation - (''Netscape'') may publish revised and/or new versions of the License from - time to time. Each version will be given a distinguishing version number. -

      6.2. Effect of New Versions.
      Once Covered Code has been - published under a particular version of the License, You may always continue - to use it under the terms of that version. You may also choose to use such - Covered Code under the terms of any subsequent version of the License - published by Netscape. No one other than Netscape has the right to modify the - terms applicable to Covered Code created under this License. -

      6.3. Derivative Works.
      If You create or use a modified version - of this License (which you may only do in order to apply it to code which is - not already Covered Code governed by this License), You must (a) rename Your - license so that the phrases ''Mozilla'', ''MOZILLAPL'', ''MOZPL'', - ''Netscape'', "MPL", ''NPL'' or any confusingly similar phrase do not appear - in your license (except to note that your license differs from this License) - and (b) otherwise make it clear that Your version of the license contains - terms which differ from the Mozilla Public License and Netscape Public - License. (Filling in the name of the Initial Developer, Original Code or - Contributor in the notice described in Exhibit A shall not of - themselves be deemed to be modifications of this License.)

    7. -DISCLAIMER OF WARRANTY. -
      COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS'' BASIS, WITHOUT - WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT - LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, - FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE - QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED - CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY - OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR - CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS - LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS - DISCLAIMER.
    8. TERMINATION. -
      8.1.  This License and the rights granted hereunder will - terminate automatically if You fail to comply with terms herein and fail to - cure such breach within 30 days of becoming aware of the breach. All - sublicenses to the Covered Code which are properly granted shall survive any - termination of this License. Provisions which, by their nature, must remain in - effect beyond the termination of this License shall survive. -

      8.2.  If You initiate litigation by asserting a patent - infringement claim (excluding declatory judgment actions) against Initial - Developer or a Contributor (the Initial Developer or Contributor against whom - You file such action is referred to as "Participant")  alleging that: -

      (a)  such Participant's Contributor Version directly or - indirectly infringes any patent, then any and all rights granted by such - Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon - 60 days notice from Participant terminate prospectively, unless if within 60 - days after receipt of notice You either: (i)  agree in writing to pay - Participant a mutually agreeable reasonable royalty for Your past and future - use of Modifications made by such Participant, or (ii) withdraw Your - litigation claim with respect to the Contributor Version against such - Participant.  If within 60 days of notice, a reasonable royalty and - payment arrangement are not mutually agreed upon in writing by the parties or - the litigation claim is not withdrawn, the rights granted by Participant to - You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of - the 60 day notice period specified above. -

      (b)  any software, hardware, or device, other than such - Participant's Contributor Version, directly or indirectly infringes any - patent, then any rights granted to You by such Participant under Sections - 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, - sold, distributed, or had made, Modifications made by that Participant. -

      8.3.  If You assert a patent infringement claim against - Participant alleging that such Participant's Contributor Version directly or - indirectly infringes any patent where such claim is resolved (such as by - license or settlement) prior to the initiation of patent infringement - litigation, then the reasonable value of the licenses granted by such - Participant under Sections 2.1 or 2.2 shall be taken into account in - determining the amount or value of any payment or license. -

      8.4.  In the event of termination under Sections 8.1 or 8.2 - above,  all end user license agreements (excluding distributors and - resellers) which have been validly granted by You or any distributor hereunder - prior to termination shall survive termination.

    9. LIMITATION OF -LIABILITY. -
      UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING - NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY - OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY - OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, - INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT - LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR - MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH - PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS - LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL - INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW - PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR - LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND - LIMITATION MAY NOT APPLY TO YOU.
    10. U.S. GOVERNMENT END USERS. -
      The Covered Code is a ''commercial item,'' as that term is defined in 48 - C.F.R. 2.101 (Oct. 1995), consisting of ''commercial computer software'' and - ''commercial computer software documentation,'' as such terms are used in 48 - C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. - 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users - acquire Covered Code with only those rights set forth herein.
    11. -MISCELLANEOUS. -
      This License represents the complete agreement concerning subject matter - hereof. If any provision of this License is held to be unenforceable, such - provision shall be reformed only to the extent necessary to make it - enforceable. This License shall be governed by California law provisions - (except to the extent applicable law, if any, provides otherwise), excluding - its conflict-of-law provisions. With respect to disputes in which at least one - party is a citizen of, or an entity chartered or registered to do business in - the United States of America, any litigation relating to this License shall be - subject to the jurisdiction of the Federal Courts of the Northern District of - California, with venue lying in Santa Clara County, California, with the - losing party responsible for costs, including without limitation, court costs - and reasonable attorneys' fees and expenses. The application of the United - Nations Convention on Contracts for the International Sale of Goods is - expressly excluded. Any law or regulation which provides that the language of - a contract shall be construed against the drafter shall not apply to this - License.
    12. RESPONSIBILITY FOR CLAIMS. -
      As between Initial Developer and the Contributors, each party is - responsible for claims and damages arising, directly or indirectly, out of its - utilization of rights under this License and You agree to work with Initial - Developer and Contributors to distribute such responsibility on an equitable - basis. Nothing herein is intended or shall be deemed to constitute any - admission of liability.
    13. MULTIPLE-LICENSED CODE. -
      Initial Developer may designate portions of the Covered Code as - "Multiple-Licensed".  "Multiple-Licensed" means that the Initial - Developer permits you to utilize portions of the Covered Code under Your - choice of the MPL or the alternative licenses, if any, specified by the - Initial Developer in the file described in Exhibit A.
    -


    EXHIBIT A -Mozilla Public License. -

      The contents of this file are subject to the Mozilla Public License - Version 1.1 (the "License"); you may not use this file except in compliance - with the License. You may obtain a copy of the License at -
      http://www.mozilla.org/MPL/ -

      Software distributed under the License is distributed on an "AS IS" basis, - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License - for the specific language governing rights and limitations under the - License. -

      The Original Code is Javassist. -

      The Initial Developer of the Original Code is Shigeru Chiba. - Portions created by the Initial Developer are
        - Copyright (C) 1999- Shigeru Chiba. All Rights Reserved. -

      Contributor(s): __Bill Burke, Jason T. Greene______________. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-javax.activation-api-1.2.0-sources.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-javax.activation-api-1.2.0-sources.txt deleted file mode 100644 index 596a510633..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-javax.activation-api-1.2.0-sources.txt +++ /dev/null @@ -1,362 +0,0 @@ -COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.1 - -1. Definitions. - - 1.1. "Contributor" means each individual or entity that creates or - contributes to the creation of Modifications. - - 1.2. "Contributor Version" means the combination of the Original - Software, prior Modifications used by a Contributor (if any), and - the Modifications made by that particular Contributor. - - 1.3. "Covered Software" means (a) the Original Software, or (b) - Modifications, or (c) the combination of files containing Original - Software with files containing Modifications, in each case including - portions thereof. - - 1.4. "Executable" means the Covered Software in any form other than - Source Code. - - 1.5. "Initial Developer" means the individual or entity that first - makes Original Software available under this License. - - 1.6. "Larger Work" means a work which combines Covered Software or - portions thereof with code not governed by the terms of this License. - - 1.7. "License" means this document. - - 1.8. "Licensable" means having the right to grant, to the maximum - extent possible, whether at the time of the initial grant or - subsequently acquired, any and all of the rights conveyed herein. - - 1.9. "Modifications" means the Source Code and Executable form of - any of the following: - - A. Any file that results from an addition to, deletion from or - modification of the contents of a file containing Original Software - or previous Modifications; - - B. Any new file that contains any part of the Original Software or - previous Modification; or - - C. Any new file that is contributed or otherwise made available - under the terms of this License. - - 1.10. "Original Software" means the Source Code and Executable form - of computer software code that is originally released under this - License. - - 1.11. "Patent Claims" means any patent claim(s), now owned or - hereafter acquired, including without limitation, method, process, - and apparatus claims, in any patent Licensable by grantor. - - 1.12. "Source Code" means (a) the common form of computer software - code in which modifications are made and (b) associated - documentation included in or with such code. - - 1.13. "You" (or "Your") means an individual or a legal entity - exercising rights under, and complying with all of the terms of, - this License. For legal entities, "You" includes any entity which - controls, is controlled by, or is under common control with You. For - purposes of this definition, "control" means (a) the power, direct - or indirect, to cause the direction or management of such entity, - whether by contract or otherwise, or (b) ownership of more than - fifty percent (50%) of the outstanding shares or beneficial - ownership of such entity. - -2. License Grants. - - 2.1. The Initial Developer Grant. - - Conditioned upon Your compliance with Section 3.1 below and subject - to third party intellectual property claims, the Initial Developer - hereby grants You a world-wide, royalty-free, non-exclusive license: - - (a) under intellectual property rights (other than patent or - trademark) Licensable by Initial Developer, to use, reproduce, - modify, display, perform, sublicense and distribute the Original - Software (or portions thereof), with or without Modifications, - and/or as part of a Larger Work; and - - (b) under Patent Claims infringed by the making, using or selling of - Original Software, to make, have made, use, practice, sell, and - offer for sale, and/or otherwise dispose of the Original Software - (or portions thereof). - - (c) The licenses granted in Sections 2.1(a) and (b) are effective on - the date Initial Developer first distributes or otherwise makes the - Original Software available to a third party under the terms of this - License. - - (d) Notwithstanding Section 2.1(b) above, no patent license is - granted: (1) for code that You delete from the Original Software, or - (2) for infringements caused by: (i) the modification of the - Original Software, or (ii) the combination of the Original Software - with other software or devices. - - 2.2. Contributor Grant. - - Conditioned upon Your compliance with Section 3.1 below and subject - to third party intellectual property claims, each Contributor hereby - grants You a world-wide, royalty-free, non-exclusive license: - - (a) under intellectual property rights (other than patent or - trademark) Licensable by Contributor to use, reproduce, modify, - display, perform, sublicense and distribute the Modifications - created by such Contributor (or portions thereof), either on an - unmodified basis, with other Modifications, as Covered Software - and/or as part of a Larger Work; and - - (b) under Patent Claims infringed by the making, using, or selling - of Modifications made by that Contributor either alone and/or in - combination with its Contributor Version (or portions of such - combination), to make, use, sell, offer for sale, have made, and/or - otherwise dispose of: (1) Modifications made by that Contributor (or - portions thereof); and (2) the combination of Modifications made by - that Contributor with its Contributor Version (or portions of such - combination). - - (c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective - on the date Contributor first distributes or otherwise makes the - Modifications available to a third party. - - (d) Notwithstanding Section 2.2(b) above, no patent license is - granted: (1) for any code that Contributor has deleted from the - Contributor Version; (2) for infringements caused by: (i) third - party modifications of Contributor Version, or (ii) the combination - of Modifications made by that Contributor with other software - (except as part of the Contributor Version) or other devices; or (3) - under Patent Claims infringed by Covered Software in the absence of - Modifications made by that Contributor. - -3. Distribution Obligations. - - 3.1. Availability of Source Code. - - Any Covered Software that You distribute or otherwise make available - in Executable form must also be made available in Source Code form - and that Source Code form must be distributed only under the terms - of this License. You must include a copy of this License with every - copy of the Source Code form of the Covered Software You distribute - or otherwise make available. You must inform recipients of any such - Covered Software in Executable form as to how they can obtain such - Covered Software in Source Code form in a reasonable manner on or - through a medium customarily used for software exchange. - - 3.2. Modifications. - - The Modifications that You create or to which You contribute are - governed by the terms of this License. You represent that You - believe Your Modifications are Your original creation(s) and/or You - have sufficient rights to grant the rights conveyed by this License. - - 3.3. Required Notices. - - You must include a notice in each of Your Modifications that - identifies You as the Contributor of the Modification. You may not - remove or alter any copyright, patent or trademark notices contained - within the Covered Software, or any notices of licensing or any - descriptive text giving attribution to any Contributor or the - Initial Developer. - - 3.4. Application of Additional Terms. - - You may not offer or impose any terms on any Covered Software in - Source Code form that alters or restricts the applicable version of - this License or the recipients' rights hereunder. You may choose to - offer, and to charge a fee for, warranty, support, indemnity or - liability obligations to one or more recipients of Covered Software. - However, you may do so only on Your own behalf, and not on behalf of - the Initial Developer or any Contributor. You must make it - absolutely clear that any such warranty, support, indemnity or - liability obligation is offered by You alone, and You hereby agree - to indemnify the Initial Developer and every Contributor for any - liability incurred by the Initial Developer or such Contributor as a - result of warranty, support, indemnity or liability terms You offer. - - 3.5. Distribution of Executable Versions. - - You may distribute the Executable form of the Covered Software under - the terms of this License or under the terms of a license of Your - choice, which may contain terms different from this License, - provided that You are in compliance with the terms of this License - and that the license for the Executable form does not attempt to - limit or alter the recipient's rights in the Source Code form from - the rights set forth in this License. If You distribute the Covered - Software in Executable form under a different license, You must make - it absolutely clear that any terms which differ from this License - are offered by You alone, not by the Initial Developer or - Contributor. You hereby agree to indemnify the Initial Developer and - every Contributor for any liability incurred by the Initial - Developer or such Contributor as a result of any such terms You offer. - - 3.6. Larger Works. - - You may create a Larger Work by combining Covered Software with - other code not governed by the terms of this License and distribute - the Larger Work as a single product. In such a case, You must make - sure the requirements of this License are fulfilled for the Covered - Software. - -4. Versions of the License. - - 4.1. New Versions. - - Oracle is the initial license steward and may publish revised and/or - new versions of this License from time to time. Each version will be - given a distinguishing version number. Except as provided in Section - 4.3, no one other than the license steward has the right to modify - this License. - - 4.2. Effect of New Versions. - - You may always continue to use, distribute or otherwise make the - Covered Software available under the terms of the version of the - License under which You originally received the Covered Software. If - the Initial Developer includes a notice in the Original Software - prohibiting it from being distributed or otherwise made available - under any subsequent version of the License, You must distribute and - make the Covered Software available under the terms of the version - of the License under which You originally received the Covered - Software. Otherwise, You may also choose to use, distribute or - otherwise make the Covered Software available under the terms of any - subsequent version of the License published by the license steward. - - 4.3. Modified Versions. - - When You are an Initial Developer and You want to create a new - license for Your Original Software, You may create and use a - modified version of this License if You: (a) rename the license and - remove any references to the name of the license steward (except to - note that the license differs from this License); and (b) otherwise - make it clear that the license contains terms which differ from this - License. - -5. DISCLAIMER OF WARRANTY. - - COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, - WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, - INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE - IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR - NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF - THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE - DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY - OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, - REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN - ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS - AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER. - -6. TERMINATION. - - 6.1. This License and the rights granted hereunder will terminate - automatically if You fail to comply with terms herein and fail to - cure such breach within 30 days of becoming aware of the breach. - Provisions which, by their nature, must remain in effect beyond the - termination of this License shall survive. - - 6.2. If You assert a patent infringement claim (excluding - declaratory judgment actions) against Initial Developer or a - Contributor (the Initial Developer or Contributor against whom You - assert such claim is referred to as "Participant") alleging that the - Participant Software (meaning the Contributor Version where the - Participant is a Contributor or the Original Software where the - Participant is the Initial Developer) directly or indirectly - infringes any patent, then any and all rights granted directly or - indirectly to You by such Participant, the Initial Developer (if the - Initial Developer is not the Participant) and all Contributors under - Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice - from Participant terminate prospectively and automatically at the - expiration of such 60 day notice period, unless if within such 60 - day period You withdraw Your claim with respect to the Participant - Software against such Participant either unilaterally or pursuant to - a written agreement with Participant. - - 6.3. If You assert a patent infringement claim against Participant - alleging that the Participant Software directly or indirectly - infringes any patent where such claim is resolved (such as by - license or settlement) prior to the initiation of patent - infringement litigation, then the reasonable value of the licenses - granted by such Participant under Sections 2.1 or 2.2 shall be taken - into account in determining the amount or value of any payment or - license. - - 6.4. In the event of termination under Sections 6.1 or 6.2 above, - all end user licenses that have been validly granted by You or any - distributor hereunder prior to termination (excluding licenses - granted to You by any distributor) shall survive termination. - -7. LIMITATION OF LIABILITY. - - UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT - (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE - INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF - COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE - TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR - CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT - LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER - FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR - LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE - POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT - APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH - PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH - LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR - LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION - AND LIMITATION MAY NOT APPLY TO YOU. - -8. U.S. GOVERNMENT END USERS. - - The Covered Software is a "commercial item," as that term is defined - in 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer - software" (as that term is defined at 48 C.F.R. � - 252.227-7014(a)(1)) and "commercial computer software documentation" - as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent - with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 - (June 1995), all U.S. Government End Users acquire Covered Software - with only those rights set forth herein. This U.S. Government Rights - clause is in lieu of, and supersedes, any other FAR, DFAR, or other - clause or provision that addresses Government rights in computer - software under this License. - -9. MISCELLANEOUS. - - This License represents the complete agreement concerning subject - matter hereof. If any provision of this License is held to be - unenforceable, such provision shall be reformed only to the extent - necessary to make it enforceable. This License shall be governed by - the law of the jurisdiction specified in a notice contained within - the Original Software (except to the extent applicable law, if any, - provides otherwise), excluding such jurisdiction's conflict-of-law - provisions. Any litigation relating to this License shall be subject - to the jurisdiction of the courts located in the jurisdiction and - venue specified in a notice contained within the Original Software, - with the losing party responsible for costs, including, without - limitation, court costs and reasonable attorneys' fees and expenses. - The application of the United Nations Convention on Contracts for - the International Sale of Goods is expressly excluded. Any law or - regulation which provides that the language of a contract shall be - construed against the drafter shall not apply to this License. You - agree that You alone are responsible for compliance with the United - States export administration regulations (and the export control - laws and regulation of any other countries) when You use, distribute - or otherwise make available any Covered Software. - -10. RESPONSIBILITY FOR CLAIMS. - - As between Initial Developer and the Contributors, each party is - responsible for claims and damages arising, directly or indirectly, - out of its utilization of rights under this License and You agree to - work with Initial Developer and Contributors to distribute such - responsibility on an equitable basis. Nothing herein is intended or - shall be deemed to constitute any admission of liability. - ------------------------------------------------------------------------- - -NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION -LICENSE (CDDL) - -The code released under the CDDL shall be governed by the laws of the -State of California (excluding conflict-of-law provisions). Any -litigation relating to this License shall be subject to the jurisdiction -of the Federal Courts of the Northern District of California and the -state courts of the State of California, with venue lying in Santa Clara -County, California. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-joda-time.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-joda-time.txt deleted file mode 100644 index 7a4a3ea242..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-joda-time.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jsonp.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jsonp.txt deleted file mode 100644 index 4a00ba9482..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jsonp.txt +++ /dev/null @@ -1,362 +0,0 @@ -COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.1 - -1. Definitions. - - 1.1. "Contributor" means each individual or entity that creates or - contributes to the creation of Modifications. - - 1.2. "Contributor Version" means the combination of the Original - Software, prior Modifications used by a Contributor (if any), and - the Modifications made by that particular Contributor. - - 1.3. "Covered Software" means (a) the Original Software, or (b) - Modifications, or (c) the combination of files containing Original - Software with files containing Modifications, in each case including - portions thereof. - - 1.4. "Executable" means the Covered Software in any form other than - Source Code. - - 1.5. "Initial Developer" means the individual or entity that first - makes Original Software available under this License. - - 1.6. "Larger Work" means a work which combines Covered Software or - portions thereof with code not governed by the terms of this License. - - 1.7. "License" means this document. - - 1.8. "Licensable" means having the right to grant, to the maximum - extent possible, whether at the time of the initial grant or - subsequently acquired, any and all of the rights conveyed herein. - - 1.9. "Modifications" means the Source Code and Executable form of - any of the following: - - A. Any file that results from an addition to, deletion from or - modification of the contents of a file containing Original Software - or previous Modifications; - - B. Any new file that contains any part of the Original Software or - previous Modification; or - - C. Any new file that is contributed or otherwise made available - under the terms of this License. - - 1.10. "Original Software" means the Source Code and Executable form - of computer software code that is originally released under this - License. - - 1.11. "Patent Claims" means any patent claim(s), now owned or - hereafter acquired, including without limitation, method, process, - and apparatus claims, in any patent Licensable by grantor. - - 1.12. "Source Code" means (a) the common form of computer software - code in which modifications are made and (b) associated - documentation included in or with such code. - - 1.13. "You" (or "Your") means an individual or a legal entity - exercising rights under, and complying with all of the terms of, - this License. For legal entities, "You" includes any entity which - controls, is controlled by, or is under common control with You. For - purposes of this definition, "control" means (a) the power, direct - or indirect, to cause the direction or management of such entity, - whether by contract or otherwise, or (b) ownership of more than - fifty percent (50%) of the outstanding shares or beneficial - ownership of such entity. - -2. License Grants. - - 2.1. The Initial Developer Grant. - - Conditioned upon Your compliance with Section 3.1 below and subject - to third party intellectual property claims, the Initial Developer - hereby grants You a world-wide, royalty-free, non-exclusive license: - - (a) under intellectual property rights (other than patent or - trademark) Licensable by Initial Developer, to use, reproduce, - modify, display, perform, sublicense and distribute the Original - Software (or portions thereof), with or without Modifications, - and/or as part of a Larger Work; and - - (b) under Patent Claims infringed by the making, using or selling of - Original Software, to make, have made, use, practice, sell, and - offer for sale, and/or otherwise dispose of the Original Software - (or portions thereof). - - (c) The licenses granted in Sections 2.1(a) and (b) are effective on - the date Initial Developer first distributes or otherwise makes the - Original Software available to a third party under the terms of this - License. - - (d) Notwithstanding Section 2.1(b) above, no patent license is - granted: (1) for code that You delete from the Original Software, or - (2) for infringements caused by: (i) the modification of the - Original Software, or (ii) the combination of the Original Software - with other software or devices. - - 2.2. Contributor Grant. - - Conditioned upon Your compliance with Section 3.1 below and subject - to third party intellectual property claims, each Contributor hereby - grants You a world-wide, royalty-free, non-exclusive license: - - (a) under intellectual property rights (other than patent or - trademark) Licensable by Contributor to use, reproduce, modify, - display, perform, sublicense and distribute the Modifications - created by such Contributor (or portions thereof), either on an - unmodified basis, with other Modifications, as Covered Software - and/or as part of a Larger Work; and - - (b) under Patent Claims infringed by the making, using, or selling - of Modifications made by that Contributor either alone and/or in - combination with its Contributor Version (or portions of such - combination), to make, use, sell, offer for sale, have made, and/or - otherwise dispose of: (1) Modifications made by that Contributor (or - portions thereof); and (2) the combination of Modifications made by - that Contributor with its Contributor Version (or portions of such - combination). - - (c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective - on the date Contributor first distributes or otherwise makes the - Modifications available to a third party. - - (d) Notwithstanding Section 2.2(b) above, no patent license is - granted: (1) for any code that Contributor has deleted from the - Contributor Version; (2) for infringements caused by: (i) third - party modifications of Contributor Version, or (ii) the combination - of Modifications made by that Contributor with other software - (except as part of the Contributor Version) or other devices; or (3) - under Patent Claims infringed by Covered Software in the absence of - Modifications made by that Contributor. - -3. Distribution Obligations. - - 3.1. Availability of Source Code. - - Any Covered Software that You distribute or otherwise make available - in Executable form must also be made available in Source Code form - and that Source Code form must be distributed only under the terms - of this License. You must include a copy of this License with every - copy of the Source Code form of the Covered Software You distribute - or otherwise make available. You must inform recipients of any such - Covered Software in Executable form as to how they can obtain such - Covered Software in Source Code form in a reasonable manner on or - through a medium customarily used for software exchange. - - 3.2. Modifications. - - The Modifications that You create or to which You contribute are - governed by the terms of this License. You represent that You - believe Your Modifications are Your original creation(s) and/or You - have sufficient rights to grant the rights conveyed by this License. - - 3.3. Required Notices. - - You must include a notice in each of Your Modifications that - identifies You as the Contributor of the Modification. You may not - remove or alter any copyright, patent or trademark notices contained - within the Covered Software, or any notices of licensing or any - descriptive text giving attribution to any Contributor or the - Initial Developer. - - 3.4. Application of Additional Terms. - - You may not offer or impose any terms on any Covered Software in - Source Code form that alters or restricts the applicable version of - this License or the recipients' rights hereunder. You may choose to - offer, and to charge a fee for, warranty, support, indemnity or - liability obligations to one or more recipients of Covered Software. - However, you may do so only on Your own behalf, and not on behalf of - the Initial Developer or any Contributor. You must make it - absolutely clear that any such warranty, support, indemnity or - liability obligation is offered by You alone, and You hereby agree - to indemnify the Initial Developer and every Contributor for any - liability incurred by the Initial Developer or such Contributor as a - result of warranty, support, indemnity or liability terms You offer. - - 3.5. Distribution of Executable Versions. - - You may distribute the Executable form of the Covered Software under - the terms of this License or under the terms of a license of Your - choice, which may contain terms different from this License, - provided that You are in compliance with the terms of this License - and that the license for the Executable form does not attempt to - limit or alter the recipient's rights in the Source Code form from - the rights set forth in this License. If You distribute the Covered - Software in Executable form under a different license, You must make - it absolutely clear that any terms which differ from this License - are offered by You alone, not by the Initial Developer or - Contributor. You hereby agree to indemnify the Initial Developer and - every Contributor for any liability incurred by the Initial - Developer or such Contributor as a result of any such terms You offer. - - 3.6. Larger Works. - - You may create a Larger Work by combining Covered Software with - other code not governed by the terms of this License and distribute - the Larger Work as a single product. In such a case, You must make - sure the requirements of this License are fulfilled for the Covered - Software. - -4. Versions of the License. - - 4.1. New Versions. - - Oracle is the initial license steward and may publish revised and/or - new versions of this License from time to time. Each version will be - given a distinguishing version number. Except as provided in Section - 4.3, no one other than the license steward has the right to modify - this License. - - 4.2. Effect of New Versions. - - You may always continue to use, distribute or otherwise make the - Covered Software available under the terms of the version of the - License under which You originally received the Covered Software. If - the Initial Developer includes a notice in the Original Software - prohibiting it from being distributed or otherwise made available - under any subsequent version of the License, You must distribute and - make the Covered Software available under the terms of the version - of the License under which You originally received the Covered - Software. Otherwise, You may also choose to use, distribute or - otherwise make the Covered Software available under the terms of any - subsequent version of the License published by the license steward. - - 4.3. Modified Versions. - - When You are an Initial Developer and You want to create a new - license for Your Original Software, You may create and use a - modified version of this License if You: (a) rename the license and - remove any references to the name of the license steward (except to - note that the license differs from this License); and (b) otherwise - make it clear that the license contains terms which differ from this - License. - -5. DISCLAIMER OF WARRANTY. - - COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, - WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, - INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE - IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR - NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF - THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE - DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY - OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, - REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN - ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS - AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER. - -6. TERMINATION. - - 6.1. This License and the rights granted hereunder will terminate - automatically if You fail to comply with terms herein and fail to - cure such breach within 30 days of becoming aware of the breach. - Provisions which, by their nature, must remain in effect beyond the - termination of this License shall survive. - - 6.2. If You assert a patent infringement claim (excluding - declaratory judgment actions) against Initial Developer or a - Contributor (the Initial Developer or Contributor against whom You - assert such claim is referred to as "Participant") alleging that the - Participant Software (meaning the Contributor Version where the - Participant is a Contributor or the Original Software where the - Participant is the Initial Developer) directly or indirectly - infringes any patent, then any and all rights granted directly or - indirectly to You by such Participant, the Initial Developer (if the - Initial Developer is not the Participant) and all Contributors under - Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice - from Participant terminate prospectively and automatically at the - expiration of such 60 day notice period, unless if within such 60 - day period You withdraw Your claim with respect to the Participant - Software against such Participant either unilaterally or pursuant to - a written agreement with Participant. - - 6.3. If You assert a patent infringement claim against Participant - alleging that the Participant Software directly or indirectly - infringes any patent where such claim is resolved (such as by - license or settlement) prior to the initiation of patent - infringement litigation, then the reasonable value of the licenses - granted by such Participant under Sections 2.1 or 2.2 shall be taken - into account in determining the amount or value of any payment or - license. - - 6.4. In the event of termination under Sections 6.1 or 6.2 above, - all end user licenses that have been validly granted by You or any - distributor hereunder prior to termination (excluding licenses - granted to You by any distributor) shall survive termination. - -7. LIMITATION OF LIABILITY. - - UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT - (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE - INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF - COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE - TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR - CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT - LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER - FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR - LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE - POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT - APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH - PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH - LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR - LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION - AND LIMITATION MAY NOT APPLY TO YOU. - -8. U.S. GOVERNMENT END USERS. - - The Covered Software is a "commercial item," as that term is defined - in 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer - software" (as that term is defined at 48 C.F.R. § - 252.227-7014(a)(1)) and "commercial computer software documentation" - as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent - with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 - (June 1995), all U.S. Government End Users acquire Covered Software - with only those rights set forth herein. This U.S. Government Rights - clause is in lieu of, and supersedes, any other FAR, DFAR, or other - clause or provision that addresses Government rights in computer - software under this License. - -9. MISCELLANEOUS. - - This License represents the complete agreement concerning subject - matter hereof. If any provision of this License is held to be - unenforceable, such provision shall be reformed only to the extent - necessary to make it enforceable. This License shall be governed by - the law of the jurisdiction specified in a notice contained within - the Original Software (except to the extent applicable law, if any, - provides otherwise), excluding such jurisdiction's conflict-of-law - provisions. Any litigation relating to this License shall be subject - to the jurisdiction of the courts located in the jurisdiction and - venue specified in a notice contained within the Original Software, - with the losing party responsible for costs, including, without - limitation, court costs and reasonable attorneys' fees and expenses. - The application of the United Nations Convention on Contracts for - the International Sale of Goods is expressly excluded. Any law or - regulation which provides that the language of a contract shall be - construed against the drafter shall not apply to this License. You - agree that You alone are responsible for compliance with the United - States export administration regulations (and the export control - laws and regulation of any other countries) when You use, distribute - or otherwise make available any Covered Software. - -10. RESPONSIBILITY FOR CLAIMS. - - As between Initial Developer and the Contributors, each party is - responsible for claims and damages arising, directly or indirectly, - out of its utilization of rights under this License and You agree to - work with Initial Developer and Contributors to distribute such - responsibility on an equitable basis. Nothing herein is intended or - shall be deemed to constitute any admission of liability. - ------------------------------------------------------------------------- - -NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION -LICENSE (CDDL) - -The code released under the CDDL shall be governed by the laws of the -State of California (excluding conflict-of-law provisions). Any -litigation relating to this License shall be subject to the jurisdiction -of the Federal Courts of the Northern District of California and the -state courts of the State of California, with venue lying in Santa Clara -County, California. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-junit5.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-junit5.txt deleted file mode 100644 index 8ebced110a..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-junit5.txt +++ /dev/null @@ -1,98 +0,0 @@ -Eclipse Public License - v 2.0 -============================== - -THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. - -### 1. Definitions - -“Contribution” means: -* **a)** in the case of the initial Contributor, the initial content Distributed under this Agreement, and -* **b)** in the case of each subsequent Contributor: - * **i)** changes to the Program, and - * **ii)** additions to the Program; -where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution “originates” from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. - -“Contributor” means any person or entity that Distributes the Program. - -“Licensed Patents” mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. - -“Program” means the Contributions Distributed in accordance with this Agreement. - -“Recipient” means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. - -“Derivative Works” shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. - -“Modified Works” shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. - -“Distribute” means the acts of **a)** distributing or **b)** making available in any manner that enables the transfer of a copy. - -“Source Code” means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. - -“Secondary License” means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. - -### 2. Grant of Rights - -**a)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. - -**b)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. - -**c)** Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. - -**d)** Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. - -**e)** Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). - -### 3. Requirements - -**3.1** If a Contributor Distributes the Program in any form, then: - -* **a)** the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and - -* **b)** the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: - * **i)** effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; - * **ii)** effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; - * **iii)** does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and - * **iv)** requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. - -**3.2** When the Program is Distributed as Source Code: - -* **a)** it must be made available under this Agreement, or if the Program **(i)** is combined with other material in a separate file or files made available under a Secondary License, and **(ii)** the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and -* **b)** a copy of this Agreement must be included with each copy of the Program. - -**3.3** Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (“notices”) contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. - -### 4. Commercial Distribution - -Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify every other Contributor (“Indemnified Contributor”) against any losses, damages and costs (collectively “Losses”) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: **a)** promptly notify the Commercial Contributor in writing of such claim, and **b)** allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. - -For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. - -### 5. No Warranty - -EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. - -### 6. Disclaimer of Liability - -EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. - -### 7. General - -If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. - -If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. - -All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. - -Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. - -Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. - -#### Exhibit A - Form of Secondary Licenses Notice - -> “This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.” - -Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. - -If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. - -You may add additional accurate notices of copyright ownership. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-log4j-core.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-log4j-core.txt deleted file mode 100644 index 6279e5206d..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-log4j-core.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright 1999-2005 The Apache Software Foundation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-netty.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-netty.txt deleted file mode 100644 index e25e752cf1..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-netty.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - https://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - https://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-opentracing-java.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-opentracing-java.txt deleted file mode 100644 index 8dada3edaf..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-opentracing-java.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-perfmark.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-perfmark.txt deleted file mode 100644 index f49a4e16e6..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-perfmark.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-protobuf.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-protobuf.txt deleted file mode 100644 index 97a6e3d199..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-protobuf.txt +++ /dev/null @@ -1,32 +0,0 @@ -Copyright 2008 Google Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -Code generated by the Protocol Buffer compiler is owned by the owner -of the input file used when generating it. This code is not -standalone and requires a support library to be linked with it. This -support library is itself covered by the above license. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-slf4j.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-slf4j.txt deleted file mode 100644 index a51675a21c..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-slf4j.txt +++ /dev/null @@ -1,23 +0,0 @@ -Copyright (c) 2004-2022 QOS.ch Sarl (Switzerland) -All rights reserved. - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - - diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-bolt.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-bolt.txt deleted file mode 100644 index f49a4e16e6..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-bolt.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-boot.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-boot.txt deleted file mode 100644 index f49a4e16e6..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-boot.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-common-tools.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-common-tools.txt deleted file mode 100644 index f49a4e16e6..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-common-tools.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-hessian.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-hessian.txt deleted file mode 100644 index f49a4e16e6..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-hessian.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-lookout.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-lookout.txt deleted file mode 100644 index f49a4e16e6..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-lookout.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-rpc.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-rpc.txt deleted file mode 100644 index f49a4e16e6..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-sofa-rpc.txt +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-annotations.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-annotations.txt deleted file mode 100644 index e280013182..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-annotations.txt +++ /dev/null @@ -1,11 +0,0 @@ -Copyright 2016 SmartBear Software - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at [apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0) - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-core.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-core.txt deleted file mode 100644 index 3e5194180d..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-core.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright (c) 2015. SmartBear Software Inc. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-models.txt b/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-models.txt deleted file mode 100644 index e280013182..0000000000 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-swagger-models.txt +++ /dev/null @@ -1,11 +0,0 @@ -Copyright 2016 SmartBear Software - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at [apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0) - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. \ No newline at end of file diff --git a/hugegraph-commons/hugegraph-dist/scripts/apache-release.sh b/hugegraph-commons/hugegraph-dist/scripts/apache-release.sh deleted file mode 100755 index 66faae9ce9..0000000000 --- a/hugegraph-commons/hugegraph-dist/scripts/apache-release.sh +++ /dev/null @@ -1,105 +0,0 @@ -#!/usr/bin/env bash -# -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -GROUP="hugegraph" -# current repository name -REPO="${GROUP}-commons" -# release version (input by committer) -RELEASE_VERSION=$1 -USERNAME=$2 -PASSWORD=$3 -# git release branch (check it carefully) -GIT_BRANCH="release-${RELEASE_VERSION}" - -RELEASE_VERSION=${RELEASE_VERSION:?"Please input the release version behind script"} - -WORK_DIR=$( - cd "$(dirname "$0")" || exit - pwd -) -cd "${WORK_DIR}" || exit -echo "In the work dir: $(pwd)" - -# clean old dir then build a new one -rm -rf dist && mkdir -p dist/apache-${REPO} - -# step1: package the source code -cd ../../ || exit -git archive --format=tar.gz \ - --output="${GROUP}-dist/scripts/dist/apache-${REPO}/apache-${REPO}-incubating-${RELEASE_VERSION}-src.tar.gz" \ - --prefix="apache-${REPO}-incubating-${RELEASE_VERSION}-src/" "${GIT_BRANCH}" || exit - -cd - || exit - -# step2: copy the binary file (Optional) -# Note: it's optional for project to generate binary package (skip this step if not need) -#cp -v ../../target/apache-${REPO}-incubating-"${RELEASE_VERSION}".tar.gz \ -# dist/apache-${REPO} || exit - -# step3: sign + hash -##### 3.1 sign in source & binary package -gpg --version 1>/dev/null || exit -cd ./dist/apache-${REPO} || exit -for i in *.tar.gz; do - echo "$i" && gpg --armor --output "$i".asc --detach-sig "$i" -done - -##### 3.2 Generate SHA512 file -shasum --version 1>/dev/null || exit -for i in *.tar.gz; do - shasum -a 512 "$i" | tee "$i".sha512 -done - -#### 3.3 check signature & sha512 -echo "#### start to check signature & hashcode ####" -for i in *.tar.gz; do - echo "$i" - gpg --verify "$i".asc "$i" || exit -done - -for i in *.tar.gz; do - echo "$i" - shasum -a 512 --check "$i".sha512 || exit -done - -# step4: upload to Apache-SVN -SVN_DIR="${GROUP}-svn-dev" -cd ../ -rm -rfv ${SVN_DIR} - -##### 4.1 pull from remote & copy files -svn co "https://dist.apache.org/repos/dist/dev/incubator/${GROUP}" ${SVN_DIR} -mkdir -p ${SVN_DIR}/"${RELEASE_VERSION}" -cp -v apache-${REPO}/*tar.gz* "${SVN_DIR}/${RELEASE_VERSION}" -cd ${SVN_DIR} || exit - -##### 4.2 check status first -svn status -svn add --parents "${RELEASE_VERSION}"/apache-${REPO}-* -# check status again -svn status - -##### 4.3 commit & push files -if [ "$USERNAME" = "" ]; then - svn commit -m "submit files for ${REPO} ${RELEASE_VERSION}" || exit -else - svn commit -m "submit files for ${REPO} ${RELEASE_VERSION}" \ - --username "${USERNAME}" --password "${PASSWORD}" || exit -fi - -echo "Finished all, please check all steps in script manually again!" diff --git a/hugegraph-commons/hugegraph-dist/scripts/dependency/known-dependencies.txt b/hugegraph-commons/hugegraph-dist/scripts/dependency/known-dependencies.txt deleted file mode 100644 index 5db5f373f8..0000000000 --- a/hugegraph-commons/hugegraph-dist/scripts/dependency/known-dependencies.txt +++ /dev/null @@ -1,75 +0,0 @@ -animal-sniffer-annotations-1.18.jar -annotations-13.0.jar -annotations-4.1.1.4.jar -bolt-1.6.2.jar -checker-qual-3.5.0.jar -commons-beanutils-1.9.4.jar -commons-codec-1.13.jar -commons-collections-3.2.2.jar -commons-configuration-1.10.jar -commons-configuration2-2.8.0.jar -commons-io-2.7.jar -commons-lang-2.6.jar -commons-lang3-3.12.0.jar -commons-logging-1.1.1.jar -commons-text-1.9.jar -disruptor-3.3.7.jar -error_prone_annotations-2.3.4.jar -failureaccess-1.0.1.jar -grpc-api-1.28.1.jar -grpc-context-1.28.1.jar -grpc-core-1.28.1.jar -grpc-netty-shaded-1.28.0.jar -grpc-protobuf-1.28.0.jar -grpc-protobuf-lite-1.28.0.jar -grpc-stub-1.28.0.jar -gson-2.8.6.jar -guava-30.0-jre.jar -hamcrest-core-1.3.jar -hessian-3.3.7.jar -j2objc-annotations-1.3.jar -jackson-annotations-2.14.0-rc1.jar -jackson-core-2.14.0-rc1.jar -jackson-databind-2.14.0-rc1.jar -jackson-dataformat-yaml-2.9.3.jar -jackson-jaxrs-base-2.14.0-rc1.jar -jackson-jaxrs-json-provider-2.14.0-rc1.jar -jackson-module-jaxb-annotations-2.14.0-rc1.jar -jakarta.activation-2.0.1.jar -jakarta.activation-api-1.2.2.jar -javassist-3.28.0-GA.jar -javax.json-1.0.jar -jaxb-core-3.0.2.jar -jaxb-impl-3.0.2.jar -joda-time-2.10.8.jar -jsr305-3.0.1.jar -junit-4.13.1.jar -kotlin-stdlib-1.6.20.jar -kotlin-stdlib-common-1.5.31.jar -kotlin-stdlib-jdk7-1.6.10.jar -kotlin-stdlib-jdk8-1.6.10.jar -listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar -log4j-api-2.18.0.jar -log4j-core-2.18.0.jar -log4j-slf4j-impl-2.18.0.jar -logging-interceptor-4.10.0.jar -lookout-api-1.4.1.jar -netty-all-4.1.42.Final.jar -okhttp-4.10.0.jar -okio-jvm-3.0.0.jar -opentracing-api-0.22.0.jar -opentracing-mock-0.22.0.jar -opentracing-noop-0.22.0.jar -opentracing-util-0.22.0.jar -perfmark-api-0.19.0.jar -proto-google-common-protos-1.17.0.jar -protobuf-java-3.11.0.jar -slf4j-api-1.7.25.jar -snakeyaml-1.18.jar -sofa-common-tools-1.0.12.jar -sofa-rpc-all-5.7.6.jar -swagger-annotations-1.5.18.jar -swagger-core-1.5.18.jar -swagger-models-1.5.18.jar -tracer-core-3.0.8.jar -validation-api-1.1.0.Final.jar diff --git a/hugegraph-commons/pom.xml b/hugegraph-commons/pom.xml index 59d12b99ad..b9e780bd32 100644 --- a/hugegraph-commons/pom.xml +++ b/hugegraph-commons/pom.xml @@ -50,7 +50,7 @@ - Apache Hugegraph(Incubating) + Apache HugeGraph dev-subscribe@hugegraph.apache.org https://hugegraph.apache.org/ @@ -61,7 +61,7 @@ Developer List dev-subscribe@hugegraph.apache.org dev-unsubscribe@hugegraph.apache.org - dev@hugegraph.incubator.apache.org + dev@hugegraph.apache.org Commits List diff --git a/hugegraph-pd/AGENTS.md b/hugegraph-pd/AGENTS.md index e1d915491d..aaaa861f39 100644 --- a/hugegraph-pd/AGENTS.md +++ b/hugegraph-pd/AGENTS.md @@ -10,8 +10,6 @@ HugeGraph PD (Placement Driver) is a meta server for distributed HugeGraph deplo - Store node monitoring and scheduling - Metadata coordination using Raft consensus -**Status**: BETA (since HugeGraph 1.5.0) - **Technology Stack**: - Java 11+ (required) - Apache Maven 3.5+ @@ -112,7 +110,7 @@ mvn clean install # Build distribution package only mvn clean package -pl hg-pd-dist -am -DskipTests -# Output: hg-pd-dist/target/apache-hugegraph-pd-incubating-.tar.gz +# Output: hugegraph-pd/apache-hugegraph-pd-.tar.gz ``` ### Running Tests @@ -167,7 +165,7 @@ mvn clean After building, extract the tarball: ``` -apache-hugegraph-pd-incubating-/ +apache-hugegraph-pd-/ ├── bin/ │ ├── start-hugegraph-pd.sh # Start PD server │ ├── stop-hugegraph-pd.sh # Stop PD server @@ -185,7 +183,7 @@ apache-hugegraph-pd-incubating-/ ### Starting PD ```bash -cd apache-hugegraph-pd-incubating-/ +cd apache-hugegraph-pd-/ bin/start-hugegraph-pd.sh # With custom GC options @@ -249,7 +247,7 @@ store: ### Common Configuration Errors 1. **Raft peer discovery failure**: `raft.peers-list` must include all PD nodes' `raft.address` values -2. **Store connection issues**: `grpc.host` must be a reachable IP (not `127.0.0.1`) for distributed deployments +2. **Store connection issues**: `grpc.host` must be a reachable IP (not `127.0.0.1`) for distributed deployments. In Docker bridge networking, use the container hostname (e.g., `pd0`) set via `HG_PD_GRPC_HOST` env var. 3. **Split-brain scenarios**: Always run 3 or 5 PD nodes in production for Raft quorum 4. **Partition imbalance**: Adjust `patrol-interval` for faster/slower rebalancing @@ -333,7 +331,7 @@ docker run -d -p 8620:8620 -p 8686:8686 -p 8610:8610 \ hugegraph-pd:latest # For production clusters, use Docker Compose or Kubernetes -# See: hugegraph-server/hugegraph-dist/docker/example/ +# See: ../docker/docker-compose-3pd-3store-3server.yml and ../docker/README.md ``` Exposed ports: 8620 (REST), 8686 (gRPC), 8610 (Raft) diff --git a/hugegraph-pd/Dockerfile b/hugegraph-pd/Dockerfile index 0303252dbb..41cac1adb6 100644 --- a/hugegraph-pd/Dockerfile +++ b/hugegraph-pd/Dockerfile @@ -1,3 +1,4 @@ +# syntax=docker/dockerfile:1 # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with @@ -19,32 +20,32 @@ # 1st stage: build source code FROM maven:3.9.0-eclipse-temurin-11 AS build -COPY . /pkg WORKDIR /pkg + +COPY . . + ARG MAVEN_ARGS -RUN mvn package $MAVEN_ARGS -e -B -ntp -Dmaven.test.skip=true -Dmaven.javadoc.skip=true && pwd && ls -l && rm \ - ./hugegraph-server/*.tar.gz && rm ./hugegraph-pd/*.tar.gz && rm ./hugegraph-store/*.tar.gz +RUN --mount=type=cache,target=/root/.m2 \ + mvn package $MAVEN_ARGS -e -B -ntp -Dmaven.test.skip=true -Dmaven.javadoc.skip=true \ + && rm ./hugegraph-server/*.tar.gz ./hugegraph-pd/*.tar.gz ./hugegraph-store/*.tar.gz # 2nd stage: runtime env # Note: ZGC (The Z Garbage Collector) is only supported on ARM-Mac with java > 13 -FROM openjdk:11-slim +FROM eclipse-temurin:11-jre-jammy -COPY --from=build /pkg/hugegraph-pd/apache-hugegraph-pd-incubating-*/ /hugegraph-pd/ +COPY --from=build /pkg/hugegraph-pd/apache-hugegraph-pd-*/ /hugegraph-pd/ LABEL maintainer="HugeGraph Docker Maintainers " # TODO: use g1gc or zgc as default ENV JAVA_OPTS="-XX:+UnlockExperimentalVMOptions -XX:+UseContainerSupport -XX:MaxRAMPercentage=50 -XshowSettings:vm" \ - HUGEGRAPH_HOME="hugegraph-pd" + HUGEGRAPH_HOME="hugegraph-pd" \ + STDOUT_MODE="true" -#COPY . /hugegraph/hugegraph-pd WORKDIR /hugegraph-pd/ -# 1. Install environment and init HugeGraph Sever -RUN set -x \ - && rm /var/lib/dpkg/info/libc-bin.* \ - && apt-get -q clean \ - && apt-get -q update \ +# 1. Install runtime dependencies +RUN apt-get -q update \ && apt-get -q install -y --no-install-recommends --no-install-suggests \ dumb-init \ procps \ @@ -53,9 +54,7 @@ RUN set -x \ vim \ cron \ && apt-get clean \ - && rm -rf /var/lib/apt/lists/* \ - && service cron start \ - && pwd && cd /hugegraph-pd/ + && rm -rf /var/lib/apt/lists/* # 2. Init docker script COPY hugegraph-pd/hg-pd-dist/docker/docker-entrypoint.sh . diff --git a/hugegraph-pd/README.md b/hugegraph-pd/README.md index 3ff14b9e2a..b900673ace 100644 --- a/hugegraph-pd/README.md +++ b/hugegraph-pd/README.md @@ -3,8 +3,6 @@ [![License](https://img.shields.io/badge/license-Apache%202-0E78BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html) [![Version](https://img.shields.io/badge/version-1.7.0-blue)](https://github.com/apache/hugegraph) -> **Note**: From revision 1.5.0, the HugeGraph-PD code has been adapted to this location. - ## Overview HugeGraph PD (Placement Driver) is a meta server that provides cluster management and coordination services for HugeGraph distributed deployments. It serves as the central control plane responsible for: @@ -15,7 +13,7 @@ HugeGraph PD (Placement Driver) is a meta server that provides cluster managemen - **Node Scheduling**: Intelligent scheduling and load balancing of graph operations - **Health Monitoring**: Continuous health checks and failure detection via heartbeat mechanism -PD uses [Apache JRaft](https://github.com/sofastack/sofa-jraft) for Raft consensus and RocksDB for persistent metadata storage, ensuring high availability and consistency in distributed environments. +PD uses [SOFA-jraft](https://github.com/sofastack/sofa-jraft) for Raft consensus and RocksDB for persistent metadata storage, ensuring high availability and consistency in distributed environments. ## Architecture @@ -156,6 +154,36 @@ raft: For detailed configuration options and production tuning, see [Configuration Guide](docs/configuration.md). +#### Docker Bridge Network Example + +When running PD in Docker with bridge networking (e.g., `docker/docker-compose-3pd-3store-3server.yml`), configuration is injected via environment variables instead of editing `application.yml` directly. Container hostnames are used instead of IP addresses: + +**pd0** container: +```bash +HG_PD_GRPC_HOST=pd0 +HG_PD_RAFT_ADDRESS=pd0:8610 +HG_PD_RAFT_PEERS_LIST=pd0:8610,pd1:8610,pd2:8610 +HG_PD_INITIAL_STORE_LIST=store0:8500,store1:8500,store2:8500 +``` + +**pd1** container: +```bash +HG_PD_GRPC_HOST=pd1 +HG_PD_RAFT_ADDRESS=pd1:8610 +HG_PD_RAFT_PEERS_LIST=pd0:8610,pd1:8610,pd2:8610 +HG_PD_INITIAL_STORE_LIST=store0:8500,store1:8500,store2:8500 +``` + +**pd2** container: +```bash +HG_PD_GRPC_HOST=pd2 +HG_PD_RAFT_ADDRESS=pd2:8610 +HG_PD_RAFT_PEERS_LIST=pd0:8610,pd1:8610,pd2:8610 +HG_PD_INITIAL_STORE_LIST=store0:8500,store1:8500,store2:8500 +``` + +See [docker/README.md](../docker/README.md) for the full environment variable reference. + ### Verify Deployment Check if PD is running: @@ -205,22 +233,25 @@ Build PD Docker image: ```bash # From project root -docker build -f hugegraph-pd/Dockerfile -t hugegraph-pd:latest . +docker build -f hugegraph-pd/Dockerfile -t hugegraph/pd:latest . # Run container docker run -d \ -p 8620:8620 \ -p 8686:8686 \ -p 8610:8610 \ - -v /path/to/conf:/hugegraph-pd/conf \ + -e HG_PD_GRPC_HOST= \ + -e HG_PD_RAFT_ADDRESS=:8610 \ + -e HG_PD_RAFT_PEERS_LIST=:8610 \ + -e HG_PD_INITIAL_STORE_LIST=:8500 \ -v /path/to/data:/hugegraph-pd/pd_data \ --name hugegraph-pd \ - hugegraph-pd:latest + hugegraph/pd:latest ``` For Docker Compose examples with HugeGraph Store and Server, see: ``` -hugegraph-server/hugegraph-dist/docker/example/ +docker/docker-compose-3pd-3store-3server.yml ``` ## Documentation @@ -256,21 +287,9 @@ PD exposes metrics via REST API at: ## Community -- **Website**: https://hugegraph.apache.org - **Documentation**: https://hugegraph.apache.org/docs/ - **GitHub**: https://github.com/apache/hugegraph -- **Mailing List**: dev@hugegraph.apache.org ## Contributing Contributions are welcome! Please read our [Development Guide](docs/development.md) and follow the Apache HugeGraph contribution guidelines. - -## License - -HugeGraph PD is licensed under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). - ---- - -**Status**: BETA (from v1.5.0+) - -For questions or issues, please contact the HugeGraph community via GitHub issues or mailing list. diff --git a/hugegraph-pd/docs/configuration.md b/hugegraph-pd/docs/configuration.md index f66ddbd043..e3ae4f6f25 100644 --- a/hugegraph-pd/docs/configuration.md +++ b/hugegraph-pd/docs/configuration.md @@ -53,7 +53,7 @@ grpc: | Parameter | Type | Default | Description | |-----------|------|---------|-------------| -| `grpc.host` | String | `127.0.0.1` | **IMPORTANT**: Must be set to actual IP address (not `127.0.0.1`) for distributed deployments. Store and Server nodes connect to this address. | +| `grpc.host` | String | `127.0.0.1` | **IMPORTANT**: Must be set to actual IP address (not `127.0.0.1`) for distributed deployments. Store and Server nodes connect to this address. In Docker bridge networking, set this to the container hostname (e.g., `pd0`) via `HG_PD_GRPC_HOST` env var. | | `grpc.port` | Integer | `8686` | gRPC server port. Ensure this port is accessible from Store and Server nodes. | **Production Notes**: @@ -119,6 +119,31 @@ raft: peers-list: 192.168.1.10:8610,192.168.1.11:8610,192.168.1.12:8610 ``` +### Docker Bridge Network Deployment + +When deploying PD in Docker with bridge networking (e.g., `docker/docker-compose-3pd-3store-3server.yml`), container hostnames are used instead of IP addresses. Configuration is injected via `HG_PD_*` environment variables: + +```yaml +# pd0 — set via HG_PD_RAFT_ADDRESS and HG_PD_RAFT_PEERS_LIST env vars +raft: + address: pd0:8610 + peers-list: pd0:8610,pd1:8610,pd2:8610 + +# pd1 +raft: + address: pd1:8610 + peers-list: pd0:8610,pd1:8610,pd2:8610 + +# pd2 +raft: + address: pd2:8610 + peers-list: pd0:8610,pd1:8610,pd2:8610 +``` + +The `grpc.host` must also use the container hostname (e.g., `pd0`) set via `HG_PD_GRPC_HOST`. Do not use `127.0.0.1` or `0.0.0.0` in bridge networking mode. + +See [docker/README.md](../../docker/README.md) for the full environment variable reference. + ### PD Core Settings Controls PD-specific behavior. @@ -726,7 +751,7 @@ pd_partition_count 36.0 ### Pre-Deployment Checklist -- [ ] `grpc.host` set to actual IP address (not `127.0.0.1`) +- [ ] `grpc.host` set to actual IP address or container hostname (not `127.0.0.1`). For Docker bridge networking use container hostname via `HG_PD_GRPC_HOST` env var. - [ ] `raft.address` unique for each PD node - [ ] `raft.peers-list` identical on all PD nodes - [ ] `raft.peers-list` contains all PD node addresses diff --git a/hugegraph-pd/docs/development.md b/hugegraph-pd/docs/development.md index 691fcd9b7c..3f01b902ea 100644 --- a/hugegraph-pd/docs/development.md +++ b/hugegraph-pd/docs/development.md @@ -63,9 +63,8 @@ cd hugegraph-pd #### Configure Code Style 1. **File → Settings → Editor → Code Style** -2. **Import Scheme → IntelliJ IDEA code style XML** -3. Select `hugegraph-style.xml` from repository root -4. **Apply** and **OK** +2. Ensure **Enable EditorConfig support** is checked +3. **Apply** and **OK** #### Enable Annotation Processing @@ -181,26 +180,26 @@ mvn test jacoco:report ```bash # Core module tests -mvn test -pl hg-pd-test -am -P pd-core-test +mvn test -pl hugegraph-pd/hg-pd-test -am -P pd-core-test # Client module tests -mvn test -pl hg-pd-test -am -P pd-client-test +mvn test -pl hugegraph-pd/hg-pd-test -am -P pd-client-test # Common module tests -mvn test -pl hg-pd-test -am -P pd-common-test +mvn test -pl hugegraph-pd/hg-pd-test -am -P pd-common-test # REST API tests -mvn test -pl hg-pd-test -am -P pd-rest-test +mvn test -pl hugegraph-pd/hg-pd-test -am -P pd-rest-test ``` #### Single Test Class ```bash # Run specific test class -mvn test -pl hg-pd-test -am -Dtest=PartitionServiceTest +mvn -pl hugegraph-pd/hg-pd-test test -Dtest=PartitionServiceTest -DfailIfNoTests=false # Run specific test method -mvn test -pl hg-pd-test -am -Dtest=PartitionServiceTest#testSplitPartition +mvn -pl hugegraph-pd/hg-pd-test test -Dtest=PartitionServiceTest#testSplitPartition -DfailIfNoTests=false ``` #### Test from IDE @@ -227,15 +226,6 @@ open hg-pd-test/target/site/jacoco/index.html - Utility classes: >70% - Generated gRPC code: Excluded from coverage -### Integration Tests - -Integration tests start embedded PD instances and verify end-to-end functionality. - -```bash -# Run integration test suite -mvn test -pl hg-pd-test -am -Dtest=PDCoreSuiteTest -``` - **What Integration Tests Cover**: - Raft cluster formation and leader election - Partition allocation and balancing @@ -243,220 +233,6 @@ mvn test -pl hg-pd-test -am -Dtest=PDCoreSuiteTest - Metadata persistence and recovery - gRPC service interactions -## Development Workflows - -### Adding a New gRPC Service - -#### 1. Define Protocol Buffers - -Create or modify `.proto` file in `hg-pd-grpc/src/main/proto/`: - -```protobuf -// example_service.proto -syntax = "proto3"; - -package org.apache.hugegraph.pd.grpc; - -service ExampleService { - rpc DoSomething(DoSomethingRequest) returns (DoSomethingResponse); -} - -message DoSomethingRequest { - string input = 1; -} - -message DoSomethingResponse { - string output = 1; -} -``` - -#### 2. Generate Java Stubs - -```bash -cd hugegraph-pd -mvn clean compile -pl hg-pd-grpc - -# Generated files location: -# hg-pd-grpc/target/generated-sources/protobuf/java/ -# hg-pd-grpc/target/generated-sources/protobuf/grpc-java/ -``` - -**Note**: Generated files are excluded from source control (`.gitignore`) - -#### 3. Implement Service - -Create service implementation in `hg-pd-service`: - -```java -// ExampleServiceImpl.java -package org.apache.hugegraph.pd.service; - -import io.grpc.stub.StreamObserver; -import org.apache.hugegraph.pd.grpc.ExampleServiceGrpc; - -public class ExampleServiceImpl extends ExampleServiceGrpc.ExampleServiceImplBase { - - @Override - public void doSomething(DoSomethingRequest request, - StreamObserver responseObserver) { - String output = processInput(request.getInput()); - - DoSomethingResponse response = DoSomethingResponse.newBuilder() - .setOutput(output) - .build(); - - responseObserver.onNext(response); - responseObserver.onCompleted(); - } - - private String processInput(String input) { - // Business logic here - return "Processed: " + input; - } -} -``` - -#### 4. Register Service - -Register service in gRPC server (in `hg-pd-service`): - -```java -// In GrpcServerInitializer or similar -ExampleServiceImpl exampleService = new ExampleServiceImpl(); -grpcServer.addService(exampleService); -``` - -#### 5. Add Tests - -Create test class in `hg-pd-test`: - -```java -// ExampleServiceTest.java -package org.apache.hugegraph.pd.service; - -import org.junit.Test; -import static org.junit.Assert.*; - -public class ExampleServiceTest extends BaseTest { - - @Test - public void testDoSomething() { - ExampleServiceImpl service = new ExampleServiceImpl(); - // Test service logic... - } -} -``` - -#### 6. Update Documentation - -Document the new API in `docs/api-reference.md`. - -### Modifying Partition Logic - -Partition logic is in `hg-pd-core/.../PartitionService.java` (2000+ lines). - -**Key Methods**: -- `splitPartition()`: Partition splitting -- `balancePartitions()`: Auto-balancing -- `updatePartitionLeader()`: Leader changes -- `getPartitionByCode()`: Partition routing - -**Development Process**: - -1. **Understand Current Logic**: - ```bash - # Read relevant methods - # File: hg-pd-core/src/main/java/.../PartitionService.java - ``` - -2. **Make Changes**: - - Modify partition allocation algorithm - - Update balancing logic - - Add new partition operations - -3. **Test Changes**: - ```bash - # Run partition service tests - mvn test -pl hg-pd-test -am -Dtest=PartitionServiceTest - - # Run integration tests - mvn test -pl hg-pd-test -am -Dtest=PDCoreSuiteTest - ``` - -4. **Submit Raft Proposals**: - All partition metadata changes must go through Raft: - ```java - // Example: Update partition metadata via Raft - KVOperation operation = KVOperation.put(key, value); - raftTaskHandler.submitTask(operation, closure); - ``` - -### Adding a New Metadata Store - -Metadata stores extend `MetadataRocksDBStore` (in `hg-pd-core/.../meta/`). - -**Example**: Creating `GraphMetaStore`: - -```java -package org.apache.hugegraph.pd.meta; - -public class GraphMetaStore extends MetadataRocksDBStore { - - private static final String GRAPH_PREFIX = "@GRAPH@"; - - public GraphMetaStore(PDConfig config) { - super(config); - } - - public void saveGraph(String graphName, Graph graph) throws PDException { - String key = GRAPH_PREFIX + graphName; - byte[] value = serialize(graph); - put(key.getBytes(), value); - } - - public Graph getGraph(String graphName) throws PDException { - String key = GRAPH_PREFIX + graphName; - byte[] value = get(key.getBytes()); - return deserialize(value, Graph.class); - } - - public List listGraphs() throws PDException { - List graphs = new ArrayList<>(); - String startKey = GRAPH_PREFIX; - String endKey = GRAPH_PREFIX + "\uffff"; - - scan(startKey.getBytes(), endKey.getBytes(), (key, value) -> { - Graph graph = deserialize(value, Graph.class); - graphs.add(graph); - return true; // Continue scanning - }); - - return graphs; - } - - private byte[] serialize(Object obj) { - // Use Hessian2 or Protocol Buffers - } - - private T deserialize(byte[] bytes, Class clazz) { - // Deserialize bytes to object - } -} -``` - -**Testing**: -```java -@Test -public void testGraphMetaStore() { - GraphMetaStore store = new GraphMetaStore(config); - - Graph graph = new Graph("test_graph", 12); - store.saveGraph("test_graph", graph); - - Graph retrieved = store.getGraph("test_graph"); - assertEquals("test_graph", retrieved.getName()); -} -``` ### Debugging Raft Issues @@ -500,9 +276,9 @@ ls -lh pd_data/raft/snapshot/ HugeGraph PD follows Apache HugeGraph code style. -**Import Code Style**: +**IDE Configuration**: 1. IntelliJ IDEA: **File → Settings → Editor → Code Style** -2. **Import Scheme** → Select `hugegraph-style.xml` (in repository root) +2. Ensure **Enable EditorConfig support** is checked **Key Style Rules**: - **Indentation**: 4 spaces (no tabs) diff --git a/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDConfig.java b/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDConfig.java index a14c324251..6ab70192ff 100644 --- a/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDConfig.java +++ b/hugegraph-pd/hg-pd-client/src/main/java/org/apache/hugegraph/pd/client/PDConfig.java @@ -101,9 +101,13 @@ public String toString() { } public PDConfig setAuthority(String userName, String pwd) { + // If userName is null or empty, keep default values for test environment + if (StringUtils.isEmpty(userName)) { + return this; + } this.userName = userName; String auth = userName + ':' + pwd; - this.authority = new String(Base64.getEncoder().encode(auth.getBytes(UTF_8))); + this.authority = Base64.getEncoder().encodeToString(auth.getBytes(UTF_8)); return this; } diff --git a/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftEngine.java b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftEngine.java index 342594ef74..2b08de7d4e 100644 --- a/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftEngine.java +++ b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftEngine.java @@ -23,9 +23,12 @@ import java.util.HashSet; import java.util.List; import java.util.Objects; +import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; @@ -40,7 +43,6 @@ import com.alipay.sofa.jraft.JRaftUtils; import com.alipay.sofa.jraft.Node; import com.alipay.sofa.jraft.RaftGroupService; -import com.alipay.sofa.jraft.ReplicatorGroup; import com.alipay.sofa.jraft.Status; import com.alipay.sofa.jraft.conf.Configuration; import com.alipay.sofa.jraft.core.Replicator; @@ -48,13 +50,11 @@ import com.alipay.sofa.jraft.entity.Task; import com.alipay.sofa.jraft.error.RaftError; import com.alipay.sofa.jraft.option.NodeOptions; -import com.alipay.sofa.jraft.option.RaftOptions; import com.alipay.sofa.jraft.option.RpcOptions; import com.alipay.sofa.jraft.rpc.RaftRpcServerFactory; import com.alipay.sofa.jraft.rpc.RpcServer; import com.alipay.sofa.jraft.rpc.impl.BoltRpcServer; import com.alipay.sofa.jraft.util.Endpoint; -import com.alipay.sofa.jraft.util.ThreadId; import com.alipay.sofa.jraft.util.internal.ThrowUtil; import io.netty.channel.ChannelHandler; @@ -86,8 +86,12 @@ public synchronized boolean init(PDConfig.Raft config) { } this.config = config; + // Wire configured rpc timeout into RaftRpcClient so the Bolt transport + // timeout and the future.get() caller timeout in getLeaderGrpcAddress() are consistent. raftRpcClient = new RaftRpcClient(); - raftRpcClient.init(new RpcOptions()); + RpcOptions rpcOptions = new RpcOptions(); + rpcOptions.setRpcDefaultTimeout(config.getRpcTimeout()); + raftRpcClient.init(rpcOptions); String raftPath = config.getDataPath() + "/" + groupId; new File(raftPath).mkdirs(); @@ -119,10 +123,7 @@ public synchronized boolean init(PDConfig.Raft config) { nodeOptions.setRpcConnectTimeoutMs(config.getRpcTimeout()); nodeOptions.setRpcDefaultTimeout(config.getRpcTimeout()); nodeOptions.setRpcInstallSnapshotTimeout(config.getRpcTimeout()); - // Set the raft configuration - RaftOptions raftOptions = nodeOptions.getRaftOptions(); - - nodeOptions.setEnableMetrics(true); + // TODO: tune RaftOptions for PD (see hugegraph-store PartitionEngine for reference) final PeerId serverId = JRaftUtils.getPeerId(config.getAddress()); @@ -228,7 +229,7 @@ public PeerId getLeader() { } /** - * Send a message to the leader to get the grpc address; + * Send a message to the leader to get the grpc address. */ public String getLeaderGrpcAddress() throws ExecutionException, InterruptedException { if (isLeader()) { @@ -236,11 +237,49 @@ public String getLeaderGrpcAddress() throws ExecutionException, InterruptedExcep } if (raftNode.getLeaderId() == null) { - waitingForLeader(10000); + waitingForLeader(config.getRpcTimeout()); + } + + // Cache leader to avoid repeated getLeaderId() calls and guard against + // waitingForLeader() returning without a leader being elected. + PeerId leader = raftNode.getLeaderId(); + if (leader == null) { + throw new ExecutionException(new IllegalStateException("Leader is not ready")); + } + + RaftRpcProcessor.GetMemberResponse response = null; + try { + // TODO: a more complete fix would need a source of truth for the leader's + // actual grpcAddress rather than deriving it from the local node's port config. + response = raftRpcClient + .getGrpcAddress(leader.getEndpoint().toString()) + .get(config.getRpcTimeout(), TimeUnit.MILLISECONDS); + if (response != null && response.getGrpcAddress() != null) { + return response.getGrpcAddress(); + } + if (response == null) { + log.warn("Leader RPC response is null for {}, falling back to derived address", + leader); + } else { + log.warn("Leader gRPC address field is null in RPC response for {}, " + + "falling back to derived address", leader); + } + } catch (TimeoutException e) { + log.warn("Timed out resolving leader gRPC address for {}, falling back to derived " + + "address", leader); + } catch (ExecutionException e) { + Throwable cause = e.getCause() != null ? e.getCause() : e; + log.warn("Failed to resolve leader gRPC address for {}, falling back to derived " + + "address", leader, cause); } - return raftRpcClient.getGrpcAddress(raftNode.getLeaderId().getEndpoint().toString()).get() - .getGrpcAddress(); + // Best-effort fallback: derive from leader raft endpoint IP + local gRPC port. + // WARNING: this may be incorrect in clusters where PD nodes use different grpc.port + // values, a proper fix requires a cluster-wide source of truth for gRPC addresses. + String derived = leader.getEndpoint().getIp() + ":" + config.getGrpcPort(); + log.info("Using derived leader gRPC address {} - may be incorrect if nodes use different ports", + derived); + return derived; } /** @@ -313,23 +352,55 @@ public List getMembers() throws ExecutionException, InterruptedEx public Status changePeerList(String peerList) { AtomicReference result = new AtomicReference<>(); + Configuration newPeers = new Configuration(); try { String[] peers = peerList.split(",", -1); if ((peers.length & 1) != 1) { throw new PDException(-1, "the number of peer list must be odd."); } - Configuration newPeers = new Configuration(); newPeers.parse(peerList); CountDownLatch latch = new CountDownLatch(1); this.raftNode.changePeers(newPeers, status -> { - result.set(status); + result.compareAndSet(null, status); + if (status != null && status.isOk()) { + IpAuthHandler handler = IpAuthHandler.getInstance(); + if (handler != null) { + Set newIps = newPeers.getPeers() + .stream() + .map(PeerId::getIp) + .collect(Collectors.toSet()); + handler.refresh(newIps); + log.info("IpAuthHandler refreshed after peer list change to: {}", + peerList); + } else { + log.warn("IpAuthHandler not initialized, skipping refresh for " + + "peer list: {}", peerList); + } + } latch.countDown(); }); - latch.await(); + boolean completed = latch.await(3L * config.getRpcTimeout(), TimeUnit.MILLISECONDS); + if (!completed && result.get() == null) { + Status timeoutStatus = new Status(RaftError.EINTERNAL, + "changePeerList timed out after %d ms", + 3L * config.getRpcTimeout()); + if (!result.compareAndSet(null, timeoutStatus)) { + timeoutStatus = null; + } + if (timeoutStatus != null) { + log.error("changePeerList to {} timed out after {} ms", + peerList, 3L * config.getRpcTimeout()); + } + } + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + result.set(new Status(RaftError.EINTERNAL, "changePeerList interrupted")); + log.error("changePeerList to {} was interrupted", peerList, e); } catch (Exception e) { log.error("failed to changePeerList to {},{}", peerList, e); result.set(new Status(-1, e.getMessage())); } + return result.get(); } @@ -344,7 +415,8 @@ public PeerId waitingForLeader(long timeOut) { long start = System.currentTimeMillis(); while ((System.currentTimeMillis() - start < timeOut) && (leader == null)) { try { - this.wait(1000); + long remaining = timeOut - (System.currentTimeMillis() - start); + this.wait(Math.min(1000, Math.max(0, remaining))); } catch (InterruptedException e) { log.error("Raft wait for leader exception", e); } @@ -352,7 +424,6 @@ public PeerId waitingForLeader(long timeOut) { } return leader; } - } public Node getRaftNode() { @@ -366,54 +437,11 @@ private boolean peerEquals(PeerId p1, PeerId p2) { if (p1 == null || p2 == null) { return false; } - return Objects.equals(p1.getIp(), p2.getIp()) && Objects.equals(p1.getPort(), p2.getPort()); + return Objects.equals(p1.getIp(), p2.getIp()) && + Objects.equals(p1.getPort(), p2.getPort()); } private Replicator.State getReplicatorState(PeerId peerId) { - var replicateGroup = getReplicatorGroup(); - if (replicateGroup == null) { - return null; - } - - ThreadId threadId = replicateGroup.getReplicator(peerId); - if (threadId == null) { - return null; - } else { - Replicator r = (Replicator) threadId.lock(); - if (r == null) { - return Replicator.State.Probe; - } - Replicator.State result = getState(r); - threadId.unlock(); - return result; - } - } - - private ReplicatorGroup getReplicatorGroup() { - var clz = this.raftNode.getClass(); - try { - var f = clz.getDeclaredField("replicatorGroup"); - f.setAccessible(true); - var group = (ReplicatorGroup) f.get(this.raftNode); - f.setAccessible(false); - return group; - } catch (NoSuchFieldException | IllegalAccessException e) { - log.info("getReplicatorGroup: error {}", e.getMessage()); - return null; - } - } - - private Replicator.State getState(Replicator r) { - var clz = r.getClass(); - try { - var f = clz.getDeclaredField("state"); - f.setAccessible(true); - var state = (Replicator.State) f.get(this.raftNode); - f.setAccessible(false); - return state; - } catch (NoSuchFieldException | IllegalAccessException e) { - log.info("getReplicatorGroup: error {}", e.getMessage()); - return null; - } + return RaftReflectionUtil.getReplicatorState(this.raftNode, peerId); } } diff --git a/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftReflectionUtil.java b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftReflectionUtil.java new file mode 100644 index 0000000000..16cb5941d6 --- /dev/null +++ b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftReflectionUtil.java @@ -0,0 +1,95 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.pd.raft; + +import com.alipay.sofa.jraft.Node; +import com.alipay.sofa.jraft.ReplicatorGroup; +import com.alipay.sofa.jraft.core.Replicator; +import com.alipay.sofa.jraft.entity.PeerId; +import com.alipay.sofa.jraft.util.ThreadId; + +import lombok.extern.slf4j.Slf4j; + +@Slf4j +public class RaftReflectionUtil { + + public static Replicator.State getReplicatorState(Node node, PeerId peerId) { + if (node == null || peerId == null) { + return null; + } + + // Get ReplicatorGroup from Node + var clz = node.getClass(); + ReplicatorGroup replicateGroup = null; + try { + var f = clz.getDeclaredField("replicatorGroup"); + f.setAccessible(true); + try { + replicateGroup = (ReplicatorGroup)f.get(node); + } + finally { + f.setAccessible(false); + } + } + catch (NoSuchFieldException | IllegalAccessException e) { + log.warn("Failed to get replicator state via reflection: {}", e.getMessage(), e); + return null; + } + + if (replicateGroup == null) { + return null; + } + + ThreadId threadId = replicateGroup.getReplicator(peerId); + if (threadId == null) { + return null; + } + else { + Replicator r = (Replicator)threadId.lock(); + try { + if (r == null) { + return Replicator.State.Probe; + } + Replicator.State result = null; + + // Get state from Replicator + + var replicatorClz = r.getClass(); + try { + var f = replicatorClz.getDeclaredField("state"); + f.setAccessible(true); + try { + result = (Replicator.State)f.get(r); + }catch (Exception e){ + log.warn("Failed to get replicator state for peerId: {}, error: {}", peerId, e.getMessage()); + } + finally { + f.setAccessible(false); + } + } + catch (NoSuchFieldException e) { + log.warn("Failed to get replicator state via reflection: {}", e.getMessage(), e); + result = null; + } + return result; + } finally { + threadId.unlock(); + } + } + } +} diff --git a/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftRpcClient.java b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftRpcClient.java index ad6129236b..8c7398a53a 100644 --- a/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftRpcClient.java +++ b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/RaftRpcClient.java @@ -60,7 +60,7 @@ public synchronized boolean init(final RpcOptions rpcOptions) { private void internalCallAsyncWithRpc(final Endpoint endpoint, final RaftRpcProcessor.BaseRequest request, final FutureClosureAdapter closure) { - final InvokeContext invokeCtx = null; + final InvokeContext invokeCtx = new InvokeContext(); final InvokeCallback invokeCallback = new InvokeCallback() { @Override diff --git a/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/auth/IpAuthHandler.java b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/auth/IpAuthHandler.java index 2ac384541d..bdccb6dd7f 100644 --- a/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/auth/IpAuthHandler.java +++ b/hugegraph-pd/hg-pd-core/src/main/java/org/apache/hugegraph/pd/raft/auth/IpAuthHandler.java @@ -17,8 +17,11 @@ package org.apache.hugegraph.pd.raft.auth; +import java.net.InetAddress; import java.net.InetSocketAddress; +import java.net.UnknownHostException; import java.util.Collections; +import java.util.HashSet; import java.util.Set; import io.netty.channel.ChannelDuplexHandler; @@ -30,11 +33,11 @@ @ChannelHandler.Sharable public class IpAuthHandler extends ChannelDuplexHandler { - private final Set allowedIps; + private volatile Set resolvedIps; private static volatile IpAuthHandler instance; private IpAuthHandler(Set allowedIps) { - this.allowedIps = Collections.unmodifiableSet(allowedIps); + this.resolvedIps = resolveAll(allowedIps); } public static IpAuthHandler getInstance(Set allowedIps) { @@ -48,6 +51,25 @@ public static IpAuthHandler getInstance(Set allowedIps) { return instance; } + /** + * Returns the existing singleton instance, or null if not yet initialized. + * Should only be called after getInstance(Set) has been called during startup. + */ + public static IpAuthHandler getInstance() { + return instance; + } + + /** + * Refreshes the resolved IP allowlist from a new set of hostnames or IPs. + * Should be called when the Raft peer list changes via RaftEngine#changePeerList(). + * Note: DNS-only changes (e.g. container restart with new IP, same hostname) + * are not automatically detected and still require a process restart. + */ + public void refresh(Set newAllowedIps) { + this.resolvedIps = resolveAll(newAllowedIps); + log.info("IpAuthHandler allowlist refreshed, resolved {} entries", resolvedIps.size()); + } + @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { String clientIp = getClientIp(ctx); @@ -65,7 +87,25 @@ private static String getClientIp(ChannelHandlerContext ctx) { } private boolean isIpAllowed(String ip) { - return allowedIps.isEmpty() || allowedIps.contains(ip); + Set resolved = this.resolvedIps; + // Empty allowlist means no restriction is configured — allow all + return resolved.isEmpty() || resolved.contains(ip); + } + + private static Set resolveAll(Set entries) { + Set result = new HashSet<>(entries); + + for (String entry : entries) { + try { + for (InetAddress addr : InetAddress.getAllByName(entry)) { + result.add(addr.getHostAddress()); + } + } catch (UnknownHostException e) { + log.warn("Could not resolve allowlist entry '{}': {}", entry, e.getMessage()); + } + } + + return Collections.unmodifiableSet(result); } @Override diff --git a/hugegraph-pd/hg-pd-dist/docker/docker-entrypoint.sh b/hugegraph-pd/hg-pd-dist/docker/docker-entrypoint.sh old mode 100644 new mode 100755 index fd894d5518..d1ae5c3c3a --- a/hugegraph-pd/hg-pd-dist/docker/docker-entrypoint.sh +++ b/hugegraph-pd/hg-pd-dist/docker/docker-entrypoint.sh @@ -15,8 +15,72 @@ # See the License for the specific language governing permissions and # limitations under the License. # +set -euo pipefail -# start hugegraph pd -./bin/start-hugegraph-pd.sh -j "$JAVA_OPTS" +log() { echo "[hugegraph-pd-entrypoint] $*"; } +require_env() { + local name="$1" + if [[ -z "${!name:-}" ]]; then + echo "ERROR: missing required env '${name}'" >&2; exit 2 + fi +} + +json_escape() { + local s="$1" + s=${s//\\/\\\\}; s=${s//\"/\\\"}; s=${s//$'\n'/} + printf "%s" "$s" +} + +migrate_env() { + local old_name="$1" new_name="$2" + + if [[ -n "${!old_name:-}" && -z "${!new_name:-}" ]]; then + log "WARN: deprecated env '${old_name}' detected; mapping to '${new_name}'" + export "${new_name}=${!old_name}" + fi +} + +migrate_env "GRPC_HOST" "HG_PD_GRPC_HOST" +migrate_env "RAFT_ADDRESS" "HG_PD_RAFT_ADDRESS" +migrate_env "RAFT_PEERS" "HG_PD_RAFT_PEERS_LIST" +migrate_env "PD_INITIAL_STORE_LIST" "HG_PD_INITIAL_STORE_LIST" + +# ── Required vars ───────────────────────────────────────────────────── +require_env "HG_PD_GRPC_HOST" +require_env "HG_PD_RAFT_ADDRESS" +require_env "HG_PD_RAFT_PEERS_LIST" +require_env "HG_PD_INITIAL_STORE_LIST" + +: "${HG_PD_GRPC_PORT:=8686}" +: "${HG_PD_REST_PORT:=8620}" +: "${HG_PD_DATA_PATH:=/hugegraph-pd/pd_data}" +: "${HG_PD_INITIAL_STORE_COUNT:=1}" + +SPRING_APPLICATION_JSON="$(cat <> ${OUTPUT} 2>&1 & - -PID="$!" -# Write pid to file -echo "$PID" > "$PID_FILE" -echo "[+pid] $PID" +if [[ $DAEMON == "true" ]]; then + echo "Starting HugeGraphPDServer in daemon mode..." + if [[ "${STDOUT_MODE:-false}" == "true" ]]; then + exec ${JAVA} -Dname="HugeGraphPD" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml ${LIB}/hg-pd-service-*.jar & + else + exec ${JAVA} -Dname="HugeGraphPD" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml ${LIB}/hg-pd-service-*.jar >> ${OUTPUT} 2>&1 & + fi + PID="$!" + # Write pid to file + echo "$PID" > "$PID_FILE" + echo "[+pid] $PID" +else + echo "Starting HugeGraphPDServer in foreground mode..." + # Write $$ before exec — exec replaces this shell with Java, so $$ becomes Java's PID + echo "$$" > "$PID_FILE" + echo "[+pid] $$" + if [[ "${STDOUT_MODE:-false}" == "true" ]]; then + exec ${JAVA} -Dname="HugeGraphPD" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml ${LIB}/hg-pd-service-*.jar + else + exec ${JAVA} -Dname="HugeGraphPD" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml ${LIB}/hg-pd-service-*.jar >> ${OUTPUT} 2>&1 + fi +fi diff --git a/hugegraph-pd/hg-pd-dist/src/assembly/static/bin/util.sh b/hugegraph-pd/hg-pd-dist/src/assembly/static/bin/util.sh index 5cc0c355be..0b7ad0f0f0 100644 --- a/hugegraph-pd/hg-pd-dist/src/assembly/static/bin/util.sh +++ b/hugegraph-pd/hg-pd-dist/src/assembly/static/bin/util.sh @@ -83,7 +83,7 @@ function process_id() { # check the port of rest server is occupied function check_port() { - local port=`echo $1 | awk -F':' '{print $3}'` + local port=$(echo "$1" | sed 's|.*:||' | sed 's|/.*||') if ! command_available "lsof"; then echo "Required lsof but it is unavailable" exit 1 diff --git a/hugegraph-pd/hg-pd-dist/src/assembly/static/conf/log4j2.xml b/hugegraph-pd/hg-pd-dist/src/assembly/static/conf/log4j2.xml index a804948703..e0b5d9dc98 100644 --- a/hugegraph-pd/hg-pd-dist/src/assembly/static/conf/log4j2.xml +++ b/hugegraph-pd/hg-pd-dist/src/assembly/static/conf/log4j2.xml @@ -115,6 +115,7 @@ + diff --git a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/IndexAPI.java b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/IndexAPI.java index a0448965f1..bee39f23ed 100644 --- a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/IndexAPI.java +++ b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/IndexAPI.java @@ -66,9 +66,35 @@ public BriefStatistics index() throws PDException, ExecutionException, Interrupt BriefStatistics statistics = new BriefStatistics(); statistics.leader = RaftEngine.getInstance().getLeaderGrpcAddress(); statistics.state = pdService.getStoreNodeService().getClusterStats().getState().toString(); + + // Use pdService (consistent with cluster()) rather than RaftEngine directly + CallStreamObserverWrap membersResp = + new CallStreamObserverWrap<>(); + pdService.getMembers(Pdpb.GetMembersRequest.newBuilder().build(), membersResp); + statistics.memberSize = membersResp.get().get(0).getMembersList().size(); + statistics.storeSize = pdService.getStoreNodeService().getActiveStores().size(); - statistics.graphSize = pdService.getPartitionService().getGraphs().size(); + // Filter to user-facing graphs only (consistent with cluster()) + List graphs = pdRestService.getGraphs(); + statistics.graphSize = (int) graphs.stream() + .filter(g -> g.getGraphName() != null && + g.getGraphName().endsWith("/g")) + .count(); statistics.partitionSize = pdService.getStoreNodeService().getShardGroups().size(); + + // Derive worst partition health state across all graphs + Metapb.PartitionState dataState = Metapb.PartitionState.PState_Normal; + for (Metapb.Graph graph : graphs) { + if (graph.getState() == Metapb.PartitionState.UNRECOGNIZED) { + continue; + } + if (graph.getState() != null && + graph.getState().getNumber() > dataState.getNumber()) { + dataState = graph.getState(); + } + } + statistics.dataState = dataState.name(); + return statistics; } @@ -157,9 +183,13 @@ public RestApiResponse cluster() throws InterruptedException, ExecutionException class BriefStatistics { String state; + /** Worst partition health state across all graphs (mirrors cluster().dataState) */ + String dataState; String leader; int memberSize; + /** Active (online) store count only */ int storeSize; + /** User-facing graphs count (graphName ending with /g) */ int graphSize; int partitionSize; } diff --git a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/MemberAPI.java b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/MemberAPI.java index 4a796c37ce..525b899c96 100644 --- a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/MemberAPI.java +++ b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/rest/MemberAPI.java @@ -113,6 +113,9 @@ public RestApiResponse getMembers() throws InterruptedException, ExecutionExcept * @return Returns a JSON string containing the modification results * @throws Exception If an exception occurs during request processing, service invocation, or Peer list modification, it is captured and returned as the JSON representation of the exception */ + // TODO: this endpoint has no authentication check — any caller with network + // access to the management port can trigger a peer list change. + // Wire authentication here as part of the planned auth refactor. @PostMapping(value = "/members/change", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody diff --git a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/PDService.java b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/PDService.java index 98bc2ee803..94d136a844 100644 --- a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/PDService.java +++ b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/PDService.java @@ -25,6 +25,7 @@ import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; @@ -85,6 +86,7 @@ import org.apache.hugegraph.pd.raft.PeerUtil; import org.apache.hugegraph.pd.raft.RaftEngine; import org.apache.hugegraph.pd.raft.RaftStateListener; +import org.apache.hugegraph.pd.raft.auth.IpAuthHandler; import org.apache.hugegraph.pd.util.grpc.StreamObserverUtil; import org.apache.hugegraph.pd.watch.PDWatchSubject; import org.lognet.springboot.grpc.GRpcService; @@ -1735,6 +1737,17 @@ public void updatePdRaft(Pdpb.UpdatePdRaftRequest request, node.changePeers(config, status -> { if (status.isOk()) { log.info("updatePdRaft, change peers success"); + // Refresh IpAuthHandler so newly added peers are not blocked + IpAuthHandler handler = IpAuthHandler.getInstance(); + if (handler != null) { + Set newIps = new HashSet<>(); + config.getPeers().forEach(p -> newIps.add(p.getIp())); + config.getLearners().forEach(p -> newIps.add(p.getIp())); + handler.refresh(newIps); + log.info("IpAuthHandler refreshed after updatePdRaft peer change"); + } else { + log.warn("IpAuthHandler not initialized, skipping refresh"); + } } else { log.error("changePeers status: {}, msg:{}, code: {}, raft error:{}", status, status.getErrorMsg(), status.getCode(), diff --git a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/interceptor/Authentication.java b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/interceptor/Authentication.java index 83901bca1a..48bcf38683 100644 --- a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/interceptor/Authentication.java +++ b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/service/interceptor/Authentication.java @@ -77,6 +77,8 @@ protected T authenticate(String authority, String token, Function } String name = info.substring(0, delim); + // TODO: password validation is skipped — only service name is checked against + // innerModules. Full credential validation should be added as part of the auth refactor. //String pwd = info.substring(delim + 1); if (innerModules.contains(name)) { return call.get(); diff --git a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/util/grpc/GRpcServerConfig.java b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/util/grpc/GRpcServerConfig.java index fce6d2379d..2b1103739b 100644 --- a/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/util/grpc/GRpcServerConfig.java +++ b/hugegraph-pd/hg-pd-service/src/main/java/org/apache/hugegraph/pd/util/grpc/GRpcServerConfig.java @@ -40,6 +40,8 @@ public void configure(ServerBuilder serverBuilder) { HgExecutorUtil.createExecutor(EXECUTOR_NAME, poolGrpc.getCore(), poolGrpc.getMax(), poolGrpc.getQueue())); serverBuilder.maxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE); + // TODO: GrpcAuthentication is instantiated as a Spring bean but never registered + // here — add serverBuilder.intercept(grpcAuthentication) once auth is refactored. } } diff --git a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/core/PDCoreSuiteTest.java b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/core/PDCoreSuiteTest.java index 5098645128..87d1500bcb 100644 --- a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/core/PDCoreSuiteTest.java +++ b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/core/PDCoreSuiteTest.java @@ -19,6 +19,9 @@ import org.apache.hugegraph.pd.core.meta.MetadataKeyHelperTest; import org.apache.hugegraph.pd.core.store.HgKVStoreImplTest; +import org.apache.hugegraph.pd.raft.IpAuthHandlerTest; +import org.apache.hugegraph.pd.raft.RaftEngineIpAuthIntegrationTest; +import org.apache.hugegraph.pd.raft.RaftEngineLeaderAddressTest; import org.junit.runner.RunWith; import org.junit.runners.Suite; @@ -36,6 +39,9 @@ StoreMonitorDataServiceTest.class, StoreServiceTest.class, TaskScheduleServiceTest.class, + IpAuthHandlerTest.class, + RaftEngineIpAuthIntegrationTest.class, + RaftEngineLeaderAddressTest.class, // StoreNodeServiceTest.class, }) @Slf4j diff --git a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/IpAuthHandlerTest.java b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/IpAuthHandlerTest.java new file mode 100644 index 0000000000..31647b6d39 --- /dev/null +++ b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/IpAuthHandlerTest.java @@ -0,0 +1,133 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.pd.raft; + +import java.net.InetAddress; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +import org.apache.hugegraph.pd.raft.auth.IpAuthHandler; +import org.apache.hugegraph.testutil.Whitebox; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +public class IpAuthHandlerTest { + + @Before + public void setUp() { + // Must reset BEFORE each test — earlier suite classes (e.g. ConfigServiceTest) + // initialize RaftEngine which creates the IpAuthHandler singleton with their + // own peer IPs. Without this reset, our getInstance() calls return the stale + // singleton and ignore the allowlist passed by the test. + Whitebox.setInternalState(IpAuthHandler.class, "instance", null); + } + + @After + public void tearDown() { + // Must reset AFTER each test — prevents our test singleton from leaking + // into later suite classes that also depend on IpAuthHandler state. + Whitebox.setInternalState(IpAuthHandler.class, "instance", null); + } + + private boolean isIpAllowed(IpAuthHandler handler, String ip) { + return Whitebox.invoke(IpAuthHandler.class, + new Class[]{String.class}, + "isIpAllowed", handler, ip); + } + + @Test + public void testHostnameResolvesToIp() throws Exception { + // "localhost" should resolve to one or more IPs via InetAddress.getAllByName() + // This verifies the core fix: hostname allowlists match numeric remote addresses + // Using dynamic resolution avoids hardcoding "127.0.0.1" which may not be + // returned on IPv6-only or custom resolver environments + IpAuthHandler handler = IpAuthHandler.getInstance( + Collections.singleton("localhost")); + InetAddress[] addresses = InetAddress.getAllByName("localhost"); + // All resolved addresses should be allowed — resolveAll() adds every address + // returned by getAllByName() so none should be blocked + Assert.assertTrue("Expected at least one resolved address", + addresses.length > 0); + for (InetAddress address : addresses) { + Assert.assertTrue( + "Expected " + address.getHostAddress() + " to be allowed", + isIpAllowed(handler, address.getHostAddress())); + } + } + + @Test + public void testUnresolvableHostnameDoesNotCrash() { + // Should log a warning and skip — no exception thrown during construction + // Uses .invalid TLD which is RFC-2606 reserved and guaranteed to never resolve + IpAuthHandler handler = IpAuthHandler.getInstance( + Collections.singleton("nonexistent.invalid")); + // Handler was still created successfully despite bad hostname + Assert.assertNotNull(handler); + // Unresolvable entry is skipped so no IPs should be allowed + Assert.assertFalse(isIpAllowed(handler, "127.0.0.1")); + Assert.assertFalse(isIpAllowed(handler, "192.168.0.1")); + } + + @Test + public void testRefreshUpdatesResolvedIps() { + // Start with 127.0.0.1 + IpAuthHandler handler = IpAuthHandler.getInstance( + Collections.singleton("127.0.0.1")); + Assert.assertTrue(isIpAllowed(handler, "127.0.0.1")); + + // Refresh with a different IP — verifies refresh() swaps the set correctly + Set newIps = new HashSet<>(); + newIps.add("192.168.0.1"); + handler.refresh(newIps); + + // Old IP should no longer be allowed + Assert.assertFalse(isIpAllowed(handler, "127.0.0.1")); + // New IP should now be allowed + Assert.assertTrue(isIpAllowed(handler, "192.168.0.1")); + } + + @Test + public void testEmptyAllowlistAllowsAll() { + // Empty allowlist = no restriction configured = allow all connections + // This is intentional fallback behavior and must be explicitly tested + // because it is a security-relevant boundary + IpAuthHandler handler = IpAuthHandler.getInstance( + Collections.emptySet()); + Assert.assertTrue(isIpAllowed(handler, "1.2.3.4")); + Assert.assertTrue(isIpAllowed(handler, "192.168.99.99")); + } + + @Test + public void testGetInstanceReturnsSingletonIgnoresNewAllowlist() { + // First call creates the singleton with 127.0.0.1 + IpAuthHandler first = IpAuthHandler.getInstance( + Collections.singleton("127.0.0.1")); + // Second call with a different set must return the same instance + // and must NOT reinitialize or override the existing allowlist + IpAuthHandler second = IpAuthHandler.getInstance( + Collections.singleton("192.168.0.1")); + Assert.assertSame(first, second); + // Original allowlist still in effect + Assert.assertTrue(isIpAllowed(second, "127.0.0.1")); + // New set was ignored — 192.168.0.1 should not be allowed + Assert.assertFalse(isIpAllowed(second, "192.168.0.1")); + } +} diff --git a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftEngineIpAuthIntegrationTest.java b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftEngineIpAuthIntegrationTest.java new file mode 100644 index 0000000000..1f9857df0f --- /dev/null +++ b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftEngineIpAuthIntegrationTest.java @@ -0,0 +1,124 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.pd.raft; + +import java.util.Collections; + +import org.apache.hugegraph.pd.raft.auth.IpAuthHandler; +import org.apache.hugegraph.testutil.Whitebox; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import com.alipay.sofa.jraft.Closure; +import com.alipay.sofa.jraft.Node; +import com.alipay.sofa.jraft.Status; +import com.alipay.sofa.jraft.conf.Configuration; +import com.alipay.sofa.jraft.error.RaftError; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; + +public class RaftEngineIpAuthIntegrationTest { + + private Node originalRaftNode; + + @Before + public void setUp() { + // Save original raftNode so we can restore it after the test + originalRaftNode = RaftEngine.getInstance().getRaftNode(); + // Reset IpAuthHandler singleton for a clean state + Whitebox.setInternalState(IpAuthHandler.class, "instance", null); + } + + @After + public void tearDown() { + // Restore original raftNode + Whitebox.setInternalState(RaftEngine.getInstance(), "raftNode", originalRaftNode); + // Reset IpAuthHandler singleton + Whitebox.setInternalState(IpAuthHandler.class, "instance", null); + } + + @Test + public void testChangePeerListRefreshesIpAuthHandler() throws Exception { + // Initialize IpAuthHandler with an old IP + IpAuthHandler handler = IpAuthHandler.getInstance( + Collections.singleton("10.0.0.1")); + Assert.assertTrue(invokeIsIpAllowed(handler, "10.0.0.1")); + Assert.assertFalse(invokeIsIpAllowed(handler, "127.0.0.1")); + + // Mock Node to fire the changePeers callback synchronously with Status.OK() + // This simulates a successful peer change without a real Raft cluster + + // Important: fire the closure synchronously or changePeerList() will + // block on latch.await(...) until the configured timeout elapses + Node mockNode = mock(Node.class); + doAnswer(invocation -> { + Closure closure = invocation.getArgument(1); + closure.run(Status.OK()); + return null; + }).when(mockNode).changePeers(any(Configuration.class), any(Closure.class)); + + // Inject mock node into RaftEngine + Whitebox.setInternalState(RaftEngine.getInstance(), "raftNode", mockNode); + + // Call changePeerList with new peer — must be odd count + RaftEngine.getInstance().changePeerList("127.0.0.1:8610"); + + // Verify IpAuthHandler was refreshed with the new peer IP + Assert.assertTrue(invokeIsIpAllowed(handler, "127.0.0.1")); + // Old IP should no longer be allowed + Assert.assertFalse(invokeIsIpAllowed(handler, "10.0.0.1")); + } + + @Test + public void testChangePeerListDoesNotRefreshOnFailure() throws Exception { + // Initialize IpAuthHandler with original IP + IpAuthHandler handler = IpAuthHandler.getInstance( + Collections.singleton("10.0.0.1")); + Assert.assertTrue(invokeIsIpAllowed(handler, "10.0.0.1")); + + // Mock Node to fire callback with a failed status + // Simulates a failed peer change — handler should NOT be refreshed + + // Important: fire the closure synchronously or changePeerList() will + // block on latch.await(...) until the configured timeout elapses + Node mockNode = mock(Node.class); + doAnswer(invocation -> { + Closure closure = invocation.getArgument(1); + closure.run(new Status(RaftError.EINTERNAL, "simulated failure")); + return null; + }).when(mockNode).changePeers(any(Configuration.class), any(Closure.class)); + + Whitebox.setInternalState(RaftEngine.getInstance(), "raftNode", mockNode); + + RaftEngine.getInstance().changePeerList("127.0.0.1:8610"); + + // Handler should NOT be refreshed — old IP still allowed + Assert.assertTrue(invokeIsIpAllowed(handler, "10.0.0.1")); + Assert.assertFalse(invokeIsIpAllowed(handler, "127.0.0.1")); + } + + private boolean invokeIsIpAllowed(IpAuthHandler handler, String ip) { + return Whitebox.invoke(IpAuthHandler.class, + new Class[]{String.class}, + "isIpAllowed", handler, ip); + } +} diff --git a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftEngineLeaderAddressTest.java b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftEngineLeaderAddressTest.java new file mode 100644 index 0000000000..420b106a27 --- /dev/null +++ b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftEngineLeaderAddressTest.java @@ -0,0 +1,183 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.pd.raft; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import org.apache.hugegraph.pd.config.PDConfig; +import org.apache.hugegraph.testutil.Whitebox; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import com.alipay.sofa.jraft.Node; +import com.alipay.sofa.jraft.entity.PeerId; +import com.alipay.sofa.jraft.util.Endpoint; + +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class RaftEngineLeaderAddressTest { + + private static final String LEADER_IP = "10.0.0.1"; + private static final int GRPC_PORT = 8686; + private static final String LEADER_GRPC_ADDRESS = "10.0.0.1:8686"; + + private Node originalRaftNode; + private RaftRpcClient originalRaftRpcClient; + private PDConfig.Raft originalConfig; + + private Node mockNode; + private RaftRpcClient mockRpcClient; + private PDConfig.Raft mockConfig; + private PeerId mockLeader; + + @Before + public void setUp() { + RaftEngine engine = RaftEngine.getInstance(); + + // Save originals + originalRaftNode = engine.getRaftNode(); + originalRaftRpcClient = Whitebox.getInternalState(engine, "raftRpcClient"); + originalConfig = Whitebox.getInternalState(engine, "config"); + + // Build mock leader PeerId with real Endpoint + mockLeader = mock(PeerId.class); + Endpoint endpoint = new Endpoint(LEADER_IP, 8610); + when(mockLeader.getEndpoint()).thenReturn(endpoint); + + // Build mock Node that reports itself as follower with a known leader + mockNode = mock(Node.class); + when(mockNode.isLeader(true)).thenReturn(false); + when(mockNode.getLeaderId()).thenReturn(mockLeader); + + // Build mock config + // Use a short default timeout (100ms); specific tests may override getRpcTimeout() + mockConfig = mock(PDConfig.Raft.class); + when(mockConfig.getGrpcAddress()).thenReturn("127.0.0.1:" + GRPC_PORT); + when(mockConfig.getGrpcPort()).thenReturn(GRPC_PORT); + when(mockConfig.getRpcTimeout()).thenReturn(100); + + // Build mock RpcClient + mockRpcClient = mock(RaftRpcClient.class); + + // Inject mocks + Whitebox.setInternalState(engine, "raftNode", mockNode); + Whitebox.setInternalState(engine, "raftRpcClient", mockRpcClient); + Whitebox.setInternalState(engine, "config", mockConfig); + } + + @After + public void tearDown() { + RaftEngine engine = RaftEngine.getInstance(); + Whitebox.setInternalState(engine, "raftNode", originalRaftNode); + Whitebox.setInternalState(engine, "raftRpcClient", originalRaftRpcClient); + Whitebox.setInternalState(engine, "config", originalConfig); + } + + @Test + public void testSuccessReturnsGrpcAddress() throws Exception { + // RPC succeeds and returns a valid gRPC address + RaftRpcProcessor.GetMemberResponse response = + mock(RaftRpcProcessor.GetMemberResponse.class); + when(response.getGrpcAddress()).thenReturn(LEADER_GRPC_ADDRESS); + + CompletableFuture future = + CompletableFuture.completedFuture(response); + when(mockRpcClient.getGrpcAddress(anyString())).thenReturn(future); + + String result = RaftEngine.getInstance().getLeaderGrpcAddress(); + Assert.assertEquals(LEADER_GRPC_ADDRESS, result); + } + + @Test + public void testTimeoutFallsBackToDerivedAddress() throws Exception { + // RPC times out — should fall back to leaderIp:grpcPort + CompletableFuture future = + mock(CompletableFuture.class); + when(future.get(anyLong(), eq(TimeUnit.MILLISECONDS))) + .thenThrow(new TimeoutException("simulated timeout")); + when(mockRpcClient.getGrpcAddress(anyString())).thenReturn(future); + + String result = RaftEngine.getInstance().getLeaderGrpcAddress(); + Assert.assertEquals(LEADER_IP + ":" + GRPC_PORT, result); + } + + @Test + public void testRpcExceptionFallsBackToDerivedAddress() throws Exception { + // RPC throws ExecutionException — should fall back to leaderIp:grpcPort + CompletableFuture future = + mock(CompletableFuture.class); + when(future.get(anyLong(), eq(TimeUnit.MILLISECONDS))) + .thenThrow(new ExecutionException("simulated rpc failure", + new RuntimeException("bolt error"))); + when(mockRpcClient.getGrpcAddress(anyString())).thenReturn(future); + + String result = RaftEngine.getInstance().getLeaderGrpcAddress(); + Assert.assertEquals(LEADER_IP + ":" + GRPC_PORT, result); + } + + @Test + public void testNullResponseFallsBackToDerivedAddress() throws Exception { + // RPC returns null response — should fall back to leaderIp:grpcPort + CompletableFuture future = + CompletableFuture.completedFuture(null); + when(mockRpcClient.getGrpcAddress(anyString())).thenReturn(future); + + String result = RaftEngine.getInstance().getLeaderGrpcAddress(); + Assert.assertEquals(LEADER_IP + ":" + GRPC_PORT, result); + } + + @Test + public void testNullGrpcAddressInResponseFallsBackToDerivedAddress() throws Exception { + // RPC returns a response but grpcAddress field is null — should fall back + RaftRpcProcessor.GetMemberResponse response = + mock(RaftRpcProcessor.GetMemberResponse.class); + when(response.getGrpcAddress()).thenReturn(null); + + CompletableFuture future = + CompletableFuture.completedFuture(response); + when(mockRpcClient.getGrpcAddress(anyString())).thenReturn(future); + + String result = RaftEngine.getInstance().getLeaderGrpcAddress(); + Assert.assertEquals(LEADER_IP + ":" + GRPC_PORT, result); + } + + @Test + public void testNullLeaderAfterWaitThrowsExecutionException() throws Exception { + // Use 0ms timeout so waitingForLeader(0) skips the wait loop and returns immediately + when(mockConfig.getRpcTimeout()).thenReturn(0); + // Leader is still null after waitingForLeader() — should throw ExecutionException + when(mockNode.getLeaderId()).thenReturn(null); + + try { + RaftEngine.getInstance().getLeaderGrpcAddress(); + Assert.fail("Expected ExecutionException"); + } catch (ExecutionException e) { + Assert.assertTrue(e.getCause() instanceof IllegalStateException); + Assert.assertEquals("Leader is not ready", e.getCause().getMessage()); + } + } +} diff --git a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftReflectionUtilTest.java b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftReflectionUtilTest.java new file mode 100644 index 0000000000..c29e2a95a6 --- /dev/null +++ b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/raft/RaftReflectionUtilTest.java @@ -0,0 +1,63 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.pd.raft; + +import com.alipay.sofa.jraft.Node; +import com.alipay.sofa.jraft.core.Replicator; +import com.alipay.sofa.jraft.entity.PeerId; + +import org.junit.Assert; +import org.junit.Test; + +import static org.mockito.Mockito.mock; + +public class RaftReflectionUtilTest { + + @Test + public void testGetReplicatorStateWithNullNode() { + // Setup + PeerId peerId = mock(PeerId.class); + + // Run the test + Replicator.State result = RaftReflectionUtil.getReplicatorState(null, peerId); + + // Verify the results + Assert.assertNull(result); + } + + @Test + public void testGetReplicatorStateWithNullPeerId() { + // Setup + Node node = mock(Node.class); + + // Run the test + Replicator.State result = RaftReflectionUtil.getReplicatorState(node, null); + + // Verify the results + Assert.assertNull(result); + } + + @Test + public void testGetReplicatorStateWithBothNull() { + // Run the test + Replicator.State result = RaftReflectionUtil.getReplicatorState(null, null); + + // Verify the results + Assert.assertNull(result); + } +} diff --git a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/rest/RestApiTest.java b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/rest/RestApiTest.java index 2d6f4f054b..fb2b71d480 100644 --- a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/rest/RestApiTest.java +++ b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/rest/RestApiTest.java @@ -29,6 +29,25 @@ public class RestApiTest extends BaseServerTest { + @Test + public void testQueryIndexInfo() throws URISyntaxException, IOException, InterruptedException, + JSONException { + String url = pdRestAddr + "/"; + HttpRequest request = HttpRequest.newBuilder() + .uri(new URI(url)) + .header("Authorization", "Basic c3RvcmU6MTIz") + .GET() + .build(); + HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); + assert response.statusCode() == 200; + JSONObject obj = new JSONObject(response.body()); + assert obj.getString("state") != null; + assert obj.getString("leader") != null; + assert obj.getInt("memberSize") > 0 : "memberSize should be > 0 for a running cluster"; + // storeSize can be 0 in PD-only test environments with no store nodes registered + assert obj.getInt("storeSize") >= 0; + } + @Test public void testQueryClusterInfo() throws URISyntaxException, IOException, InterruptedException, JSONException { diff --git a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/service/RestApiTest.java b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/service/RestApiTest.java index d4c9cd121e..b899c09194 100644 --- a/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/service/RestApiTest.java +++ b/hugegraph-pd/hg-pd-test/src/main/java/org/apache/hugegraph/pd/service/RestApiTest.java @@ -29,6 +29,24 @@ public class RestApiTest extends BaseServerTest { + @Test + public void testQueryIndexInfo() throws URISyntaxException, IOException, InterruptedException, + JSONException { + String url = pdRestAddr + "/"; + HttpRequest request = HttpRequest.newBuilder() + .uri(new URI(url)).header(key, value) + .GET() + .build(); + HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); + assert response.statusCode() == 200; + JSONObject obj = new JSONObject(response.body()); + assert obj.getString("state") != null; + assert obj.getString("leader") != null; + assert obj.getInt("memberSize") > 0 : "memberSize should be > 0 for a running cluster"; + // storeSize can be 0 in PD-only test environments with no store nodes registered + assert obj.getInt("storeSize") >= 0; + } + @Test public void testQueryClusterInfo() throws URISyntaxException, IOException, InterruptedException, JSONException { diff --git a/hugegraph-pd/pom.xml b/hugegraph-pd/pom.xml index 4af7896bb2..ceb8af33b2 100644 --- a/hugegraph-pd/pom.xml +++ b/hugegraph-pd/pom.xml @@ -44,7 +44,7 @@ 2.17.0 - apache-${release.name}-pd-incubating-${project.version} + apache-${release.name}-pd-${project.version} 3.12.0 4.13.2 diff --git a/hugegraph-server/Dockerfile b/hugegraph-server/Dockerfile index 65644d75b3..4b06bdad6c 100644 --- a/hugegraph-server/Dockerfile +++ b/hugegraph-server/Dockerfile @@ -1,3 +1,4 @@ +# syntax=docker/dockerfile:1 # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with @@ -19,32 +20,33 @@ # 1st stage: build source code FROM maven:3.9.0-eclipse-temurin-11 AS build -COPY . /pkg WORKDIR /pkg + +COPY . . + ARG MAVEN_ARGS -RUN mvn package $MAVEN_ARGS -e -B -ntp -Dmaven.test.skip=true -Dmaven.javadoc.skip=true && pwd && ls -l && rm \ - ./hugegraph-server/*.tar.gz && rm ./hugegraph-pd/*.tar.gz && rm ./hugegraph-store/*.tar.gz +RUN --mount=type=cache,target=/root/.m2 \ + mvn package $MAVEN_ARGS -e -B -ntp -Dmaven.test.skip=true -Dmaven.javadoc.skip=true \ + && rm ./hugegraph-server/*.tar.gz ./hugegraph-pd/*.tar.gz ./hugegraph-store/*.tar.gz # 2nd stage: runtime env -# Note: ZGC (The Z Garbage Collector) is only supported on ARM-Mac with java > 13 -FROM openjdk:11-slim +# Note: ZGC (The Z Garbage Collector) is only supported on ARM-Mac with java > 13 +FROM eclipse-temurin:11-jre-jammy -COPY --from=build /pkg/hugegraph-server/apache-hugegraph-server-incubating-*/ /hugegraph-server/ +COPY --from=build /pkg/hugegraph-server/apache-hugegraph-server-*/ /hugegraph-server/ LABEL maintainer="HugeGraph Docker Maintainers " # TODO: use g1gc or zgc as default -ENV JAVA_OPTS="-XX:+UnlockExperimentalVMOptions -XX:+UseContainerSupport -XX:MaxRAMPercentage=50 -XshowSettings:vm" \ - HUGEGRAPH_HOME="hugegraph-server" +# Note: --add-exports is required for Java 11+ to access jdk.internal.reflect for auth proxy +ENV JAVA_OPTS="-XX:+UnlockExperimentalVMOptions -XX:+UseContainerSupport -XX:MaxRAMPercentage=50 -XshowSettings:vm --add-exports=java.base/jdk.internal.reflect=ALL-UNNAMED" \ + HUGEGRAPH_HOME="hugegraph-server" \ + STDOUT_MODE="true" -#COPY . /hugegraph/hugegraph-server WORKDIR /hugegraph-server/ -# 1. Install environment and init HugeGraph Sever -RUN set -x \ - && rm /var/lib/dpkg/info/libc-bin.* \ - && apt-get -q clean \ - && apt-get -q update \ +# 1. Install runtime dependencies and configure server +RUN apt-get -q update \ && apt-get -q install -y --no-install-recommends --no-install-suggests \ dumb-init \ procps \ @@ -54,8 +56,6 @@ RUN set -x \ cron \ && apt-get clean \ && rm -rf /var/lib/apt/lists/* \ - && service cron start \ - && pwd && cd /hugegraph-server/ \ && sed -i "s/^restserver.url.*$/restserver.url=http:\/\/0.0.0.0:8080/g" ./conf/rest-server.properties # 2. Init docker script diff --git a/hugegraph-server/Dockerfile-hstore b/hugegraph-server/Dockerfile-hstore index 47f758b0d5..54494dbad2 100644 --- a/hugegraph-server/Dockerfile-hstore +++ b/hugegraph-server/Dockerfile-hstore @@ -1,3 +1,4 @@ +# syntax=docker/dockerfile:1 # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with @@ -15,22 +16,25 @@ # limitations under the License. # -# Dockerfile for HugeGraph Server +# Dockerfile for HugeGraph Server (hstore backend) # 1st stage: build source code FROM maven:3.9.0-eclipse-temurin-11 AS build -COPY . /pkg WORKDIR /pkg + +COPY . . + ARG MAVEN_ARGS -RUN mvn package $MAVEN_ARGS -e -B -ntp -DskipTests -Dmaven.javadoc.skip=true && pwd && ls -l && rm \ - ./hugegraph-server/*.tar.gz && rm ./hugegraph-pd/*.tar.gz && rm ./hugegraph-store/*.tar.gz +RUN --mount=type=cache,target=/root/.m2 \ + mvn package $MAVEN_ARGS -e -B -ntp -DskipTests -Dmaven.javadoc.skip=true \ + && rm ./hugegraph-server/*.tar.gz ./hugegraph-pd/*.tar.gz ./hugegraph-store/*.tar.gz # 2nd stage: runtime env -# Note: ZGC (The Z Garbage Collector) is only supported on ARM-Mac with java > 13 -FROM openjdk:11-slim +# Note: ZGC (The Z Garbage Collector) is only supported on ARM-Mac with java > 13 +FROM eclipse-temurin:11-jre-jammy -COPY --from=build /pkg/hugegraph-server/apache-hugegraph-server-incubating-*/ /hugegraph-server/ +COPY --from=build /pkg/hugegraph-server/apache-hugegraph-server-*/ /hugegraph-server/ # remove hugegraph.properties and rename hstore.properties.template for default hstore backend RUN cd /hugegraph-server/conf/graphs \ && rm hugegraph.properties && mv hstore.properties.template hugegraph.properties @@ -41,12 +45,10 @@ LABEL maintainer="HugeGraph Docker Maintainers " ENV JAVA_OPTS="-XX:+UnlockExperimentalVMOptions -XX:+UseContainerSupport -XX:MaxRAMPercentage=50 -XshowSettings:vm" \ HUGEGRAPH_HOME="hugegraph-server" -#COPY . /hugegraph/hugegraph-server WORKDIR /hugegraph-server/ -# 1. Install environment and init HugeGraph Sever -RUN set -x \ - && apt-get -q update \ +# 1. Install runtime dependencies and configure server +RUN apt-get -q update \ && apt-get -q install -y --no-install-recommends --no-install-suggests \ dumb-init \ procps \ @@ -56,13 +58,11 @@ RUN set -x \ cron \ && apt-get clean \ && rm -rf /var/lib/apt/lists/* \ - && service cron start \ - && pwd && cd /hugegraph-server/ \ && sed -i "s/^restserver.url.*$/restserver.url=http:\/\/0.0.0.0:8080/g" ./conf/rest-server.properties # 2. Init docker script COPY hugegraph-server/hugegraph-dist/docker/scripts/remote-connect.groovy ./scripts -COPY hugegraph-server/hugegraph-dist/docker/scripts/detect-storage.groovy ./scripts +#COPY hugegraph-server/hugegraph-dist/docker/scripts/detect-storage.groovy ./scripts COPY hugegraph-server/hugegraph-dist/docker/docker-entrypoint.sh . RUN chmod 755 ./docker-entrypoint.sh diff --git a/hugegraph-server/README.md b/hugegraph-server/README.md index 597d412940..c145190bf0 100644 --- a/hugegraph-server/README.md +++ b/hugegraph-server/README.md @@ -9,3 +9,24 @@ HugeGraph Server consists of two layers of functionality: the graph engine layer - Storage Layer: - Storage Backend: Supports multiple built-in storage backends (RocksDB/Memory/HStore/HBase/...) and allows users to extend custom backends without modifying the existing source code. + +## Docker + +### Standalone Mode + +```bash +docker run -itd --name=hugegraph -p 8080:8080 hugegraph/hugegraph:1.7.0 +``` + +> Use release tags (e.g., `1.7.0`) for stable deployments. The `latest` tag is intended for testing or development only. + +### Distributed Mode (PD + Store + Server) + +For a full distributed deployment, use the compose file in the `docker/` directory at the repository root: + +```bash +cd docker +HUGEGRAPH_VERSION=1.7.0 docker compose -f docker-compose-3pd-3store-3server.yml up -d +``` + +See [docker/README.md](../docker/README.md) for the full setup guide. diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/API.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/API.java index c476864711..3220cf6b02 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/API.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/API.java @@ -86,6 +86,8 @@ public class API { MetricsUtil.registerMeter(API.class, "expected-error"); private static final Meter unknownErrorMeter = MetricsUtil.registerMeter(API.class, "unknown-error"); + private static final String STANDALONE_ERROR = + "GraphSpace management is not supported in standalone mode"; public static HugeGraph graph(GraphManager manager, String graphSpace, String graph) { @@ -241,6 +243,20 @@ public static boolean checkAndParseAction(String action) { } } + /** + * Ensures the graph manager is available and PD mode is enabled. + * + * @param manager the graph manager of current request + * @throws IllegalArgumentException if the graph manager is null + * @throws HugeException if PD mode is disabled + */ + protected static void ensurePdModeEnabled(GraphManager manager) { + E.checkArgumentNotNull(manager, "Graph manager can't be null"); + if (!manager.isPDEnabled()) { + throw new HugeException(STANDALONE_ERROR); + } + } + public static boolean hasAdminPerm(GraphManager manager, String user) { return manager.authManager().isAdminManager(user); } diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/AccessAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/AccessAPI.java index 8813f2017a..35b05eedb1 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/AccessAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/AccessAPI.java @@ -19,7 +19,6 @@ import java.util.List; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter.Status; import org.apache.hugegraph.auth.HugeAccess; @@ -36,6 +35,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -50,7 +51,7 @@ import jakarta.ws.rs.QueryParam; import jakarta.ws.rs.core.Context; -@Path("graphspaces/{graphspace}/graphs/{graph}/auth/accesses") +@Path("graphspaces/{graphspace}/auth/accesses") @Singleton @Tag(name = "AccessAPI") public class AccessAPI extends API { @@ -63,16 +64,15 @@ public class AccessAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, JsonAccess jsonAccess) { - LOG.debug("Graph [{}] create access: {}", graph, jsonAccess); + LOG.debug("GraphSpace [{}] create access: {}", graphSpace, jsonAccess); checkCreatingBody(jsonAccess); - HugeGraph g = graph(manager, graphSpace, graph); HugeAccess access = jsonAccess.build(); access.id(manager.authManager().createAccess(access)); - return manager.serializer(g).writeAuthElement(access); + return manager.serializer().writeAuthElement(access); } @PUT @@ -81,14 +81,14 @@ public String create(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The access id") @PathParam("id") String id, JsonAccess jsonAccess) { - LOG.debug("Graph [{}] update access: {}", graph, jsonAccess); + LOG.debug("GraphSpace [{}] update access: {}", graphSpace, jsonAccess); checkUpdatingBody(jsonAccess); - HugeGraph g = graph(manager, graphSpace, graph); HugeAccess access; try { access = manager.authManager().getAccess(UserAPI.parseId(id)); @@ -97,24 +97,26 @@ public String update(@Context GraphManager manager, } access = jsonAccess.build(access); manager.authManager().updateAccess(access); - return manager.serializer(g).writeAuthElement(access); + return manager.serializer().writeAuthElement(access); } @GET @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The group id to filter by") @QueryParam("group") String group, + @Parameter(description = "The target id to filter by") @QueryParam("target") String target, + @Parameter(description = "The limit of results to return") @QueryParam("limit") @DefaultValue("100") long limit) { - LOG.debug("Graph [{}] list belongs by group {} or target {}", - graph, group, target); + LOG.debug("GraphSpace [{}] list accesses by group {} or target {}", + graphSpace, group, target); E.checkArgument(group == null || target == null, "Can't pass both group and target at the same time"); - HugeGraph g = graph(manager, graphSpace, graph); List belongs; if (group != null) { Id id = UserAPI.parseId(group); @@ -125,7 +127,7 @@ public String list(@Context GraphManager manager, } else { belongs = manager.authManager().listAllAccess(limit); } - return manager.serializer(g).writeAuthElements("accesses", belongs); + return manager.serializer().writeAuthElements("accesses", belongs); } @GET @@ -133,14 +135,14 @@ public String list(@Context GraphManager manager, @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The access id") @PathParam("id") String id) { - LOG.debug("Graph [{}] get access: {}", graph, id); + LOG.debug("GraphSpace [{}] get access: {}", graphSpace, id); - HugeGraph g = graph(manager, graphSpace, graph); HugeAccess access = manager.authManager().getAccess(UserAPI.parseId(id)); - return manager.serializer(g).writeAuthElement(access); + return manager.serializer().writeAuthElement(access); } @DELETE @@ -148,13 +150,12 @@ public String get(@Context GraphManager manager, @Path("{id}") @Consumes(APPLICATION_JSON) public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The access id") @PathParam("id") String id) { - LOG.debug("Graph [{}] delete access: {}", graph, id); + LOG.debug("GraphSpace [{}] delete access: {}", graphSpace, id); - @SuppressWarnings("unused") // just check if the graph exists - HugeGraph g = graph(manager, graphSpace, graph); try { manager.authManager().deleteAccess(UserAPI.parseId(id)); } catch (NotFoundException e) { @@ -167,12 +168,16 @@ public void delete(@Context GraphManager manager, private static class JsonAccess implements Checkable { @JsonProperty("group") + @Schema(description = "The group id", required = true) private String group; @JsonProperty("target") + @Schema(description = "The target id", required = true) private String target; @JsonProperty("access_permission") + @Schema(description = "The access permission", required = true) private HugePermission permission; @JsonProperty("access_description") + @Schema(description = "The access description") private String description; public HugeAccess build(HugeAccess access) { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/BelongAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/BelongAPI.java index df3b3a11dd..09af7f51c9 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/BelongAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/BelongAPI.java @@ -19,7 +19,6 @@ import java.util.List; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter.Status; import org.apache.hugegraph.auth.HugeBelong; @@ -35,6 +34,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -49,7 +50,7 @@ import jakarta.ws.rs.QueryParam; import jakarta.ws.rs.core.Context; -@Path("graphspaces/{graphspace}/graphs/{graph}/auth/belongs") +@Path("graphspaces/{graphspace}/auth/belongs") @Singleton @Tag(name = "BelongAPI") public class BelongAPI extends API { @@ -62,16 +63,15 @@ public class BelongAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, JsonBelong jsonBelong) { - LOG.debug("Graph [{}] create belong: {}", graph, jsonBelong); + LOG.debug("GraphSpace [{}] create belong: {}", graphSpace, jsonBelong); checkCreatingBody(jsonBelong); - HugeGraph g = graph(manager, graphSpace, graph); HugeBelong belong = jsonBelong.build(); belong.id(manager.authManager().createBelong(belong)); - return manager.serializer(g).writeAuthElement(belong); + return manager.serializer().writeAuthElement(belong); } @PUT @@ -80,14 +80,14 @@ public String create(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The belong id") @PathParam("id") String id, JsonBelong jsonBelong) { - LOG.debug("Graph [{}] update belong: {}", graph, jsonBelong); + LOG.debug("GraphSpace [{}] update belong: {}", graphSpace, jsonBelong); checkUpdatingBody(jsonBelong); - HugeGraph g = graph(manager, graphSpace, graph); HugeBelong belong; try { belong = manager.authManager().getBelong(UserAPI.parseId(id)); @@ -96,24 +96,26 @@ public String update(@Context GraphManager manager, } belong = jsonBelong.build(belong); manager.authManager().updateBelong(belong); - return manager.serializer(g).writeAuthElement(belong); + return manager.serializer().writeAuthElement(belong); } @GET @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The user id to filter by") @QueryParam("user") String user, + @Parameter(description = "The group id to filter by") @QueryParam("group") String group, + @Parameter(description = "The limit of results to return") @QueryParam("limit") @DefaultValue("100") long limit) { - LOG.debug("Graph [{}] list belongs by user {} or group {}", - graph, user, group); + LOG.debug("GraphSpace [{}] list belongs by user {} or group {}", + graphSpace, user, group); E.checkArgument(user == null || group == null, "Can't pass both user and group at the same time"); - HugeGraph g = graph(manager, graphSpace, graph); List belongs; if (user != null) { Id id = UserAPI.parseId(user); @@ -124,7 +126,7 @@ public String list(@Context GraphManager manager, } else { belongs = manager.authManager().listAllBelong(limit); } - return manager.serializer(g).writeAuthElements("belongs", belongs); + return manager.serializer().writeAuthElements("belongs", belongs); } @GET @@ -132,14 +134,14 @@ public String list(@Context GraphManager manager, @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The belong id") @PathParam("id") String id) { - LOG.debug("Graph [{}] get belong: {}", graph, id); + LOG.debug("GraphSpace [{}] get belong: {}", graphSpace, id); - HugeGraph g = graph(manager, graphSpace, graph); HugeBelong belong = manager.authManager().getBelong(UserAPI.parseId(id)); - return manager.serializer(g).writeAuthElement(belong); + return manager.serializer().writeAuthElement(belong); } @DELETE @@ -147,13 +149,12 @@ public String get(@Context GraphManager manager, @Path("{id}") @Consumes(APPLICATION_JSON) public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The belong id") @PathParam("id") String id) { - LOG.debug("Graph [{}] delete belong: {}", graph, id); + LOG.debug("GraphSpace [{}] delete belong: {}", graphSpace, id); - @SuppressWarnings("unused") // just check if the graph exists - HugeGraph g = graph(manager, graphSpace, graph); try { manager.authManager().deleteBelong(UserAPI.parseId(id)); } catch (NotFoundException e) { @@ -166,10 +167,13 @@ public void delete(@Context GraphManager manager, private static class JsonBelong implements Checkable { @JsonProperty("user") + @Schema(description = "The user id", required = true) private String user; @JsonProperty("group") + @Schema(description = "The group id", required = true) private String group; @JsonProperty("belong_description") + @Schema(description = "The belong description") private String description; public HugeBelong build(HugeBelong belong) { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/GroupAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/GroupAPI.java index 2c84a0310f..ae13beb4a6 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/GroupAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/GroupAPI.java @@ -19,7 +19,6 @@ import java.util.List; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter.Status; import org.apache.hugegraph.auth.HugeGroup; @@ -35,7 +34,10 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; import jakarta.ws.rs.DELETE; @@ -49,7 +51,7 @@ import jakarta.ws.rs.QueryParam; import jakarta.ws.rs.core.Context; -@Path("graphspaces/{graphspace}/graphs/{graph}/auth/groups") +@Path("/auth/groups") @Singleton @Tag(name = "GroupAPI") public class GroupAPI extends API { @@ -61,17 +63,15 @@ public class GroupAPI extends API { @Status(Status.CREATED) @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) + @RolesAllowed({"admin"}) public String create(@Context GraphManager manager, - @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, JsonGroup jsonGroup) { - LOG.debug("Graph [{}] create group: {}", graph, jsonGroup); + LOG.debug("create group: {}", jsonGroup); checkCreatingBody(jsonGroup); - HugeGraph g = graph(manager, graphSpace, graph); HugeGroup group = jsonGroup.build(); group.id(manager.authManager().createGroup(group)); - return manager.serializer(g).writeAuthElement(group); + return manager.serializer().writeAuthElement(group); } @PUT @@ -79,15 +79,14 @@ public String create(@Context GraphManager manager, @Path("{id}") @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) + @RolesAllowed({"admin"}) public String update(@Context GraphManager manager, - @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The group id") @PathParam("id") String id, JsonGroup jsonGroup) { - LOG.debug("Graph [{}] update group: {}", graph, jsonGroup); + LOG.debug("update group: {}", jsonGroup); checkUpdatingBody(jsonGroup); - HugeGraph g = graph(manager, graphSpace, graph); HugeGroup group; try { group = manager.authManager().getGroup(UserAPI.parseId(id)); @@ -96,50 +95,46 @@ public String update(@Context GraphManager manager, } group = jsonGroup.build(group); manager.authManager().updateGroup(group); - return manager.serializer(g).writeAuthElement(group); + return manager.serializer().writeAuthElement(group); } @GET @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) + @RolesAllowed({"admin"}) public String list(@Context GraphManager manager, - @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The limit of results to return") @QueryParam("limit") @DefaultValue("100") long limit) { - LOG.debug("Graph [{}] list groups", graph); + LOG.debug("list groups"); - HugeGraph g = graph(manager, graphSpace, graph); List groups = manager.authManager().listAllGroups(limit); - return manager.serializer(g).writeAuthElements("groups", groups); + return manager.serializer().writeAuthElements("groups", groups); } @GET @Timed @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) + @RolesAllowed({"admin"}) public String get(@Context GraphManager manager, - @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The group id") @PathParam("id") String id) { - LOG.debug("Graph [{}] get group: {}", graph, id); + LOG.debug("get group: {}", id); - HugeGraph g = graph(manager, graphSpace, graph); HugeGroup group = manager.authManager().getGroup(IdGenerator.of(id)); - return manager.serializer(g).writeAuthElement(group); + return manager.serializer().writeAuthElement(group); } @DELETE @Timed @Path("{id}") @Consumes(APPLICATION_JSON) + @RolesAllowed({"admin"}) public void delete(@Context GraphManager manager, - @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The group id") @PathParam("id") String id) { - LOG.debug("Graph [{}] delete group: {}", graph, id); + LOG.debug("delete group: {}", id); - @SuppressWarnings("unused") // just check if the graph exists - HugeGraph g = graph(manager, graphSpace, graph); try { manager.authManager().deleteGroup(IdGenerator.of(id)); } catch (NotFoundException e) { @@ -152,8 +147,10 @@ public void delete(@Context GraphManager manager, private static class JsonGroup implements Checkable { @JsonProperty("group_name") + @Schema(description = "The group name", required = true) private String name; @JsonProperty("group_description") + @Schema(description = "The group description") private String description; public HugeGroup build(HugeGroup group) { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/LoginAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/LoginAPI.java index faf09a312a..faf62c4064 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/LoginAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/LoginAPI.java @@ -20,7 +20,6 @@ import javax.security.sasl.AuthenticationException; import org.apache.commons.lang3.StringUtils; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.AuthenticationFilter; import org.apache.hugegraph.api.filter.StatusFilter.Status; @@ -36,6 +35,7 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.BadRequestException; @@ -46,12 +46,11 @@ import jakarta.ws.rs.NotAuthorizedException; import jakarta.ws.rs.POST; import jakarta.ws.rs.Path; -import jakarta.ws.rs.PathParam; import jakarta.ws.rs.Produces; import jakarta.ws.rs.core.Context; import jakarta.ws.rs.core.HttpHeaders; -@Path("graphspaces/{graphspace}/graphs/{graph}/auth") +@Path("/auth") @Singleton @Tag(name = "LoginAPI") public class LoginAPI extends API { @@ -65,17 +64,14 @@ public class LoginAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String login(@Context GraphManager manager, - @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, JsonLogin jsonLogin) { - LOG.debug("Graph [{}] user login: {}", graph, jsonLogin); + LOG.debug("user login: {}", jsonLogin); checkCreatingBody(jsonLogin); try { String token = manager.authManager() .loginUser(jsonLogin.name, jsonLogin.password, jsonLogin.expire); - HugeGraph g = graph(manager, graphSpace, graph); - return manager.serializer(g).writeMap(ImmutableMap.of("token", token)); + return manager.serializer().writeMap(ImmutableMap.of("token", token)); } catch (AuthenticationException e) { throw new NotAuthorizedException(e.getMessage(), e); } @@ -87,11 +83,11 @@ public String login(@Context GraphManager manager, @Status(Status.OK) @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) - public void logout(@Context GraphManager manager, @PathParam("graph") String graph, + public void logout(@Context GraphManager manager, @HeaderParam(HttpHeaders.AUTHORIZATION) String auth) { E.checkArgument(StringUtils.isNotEmpty(auth), "Request header Authorization must not be null"); - LOG.debug("Graph [{}] user logout: {}", graph, auth); + LOG.debug("user logout: {}", auth); if (!auth.startsWith(AuthenticationFilter.BEARER_TOKEN_PREFIX)) { throw new BadRequestException("Only HTTP Bearer authentication is supported"); @@ -108,12 +104,10 @@ public void logout(@Context GraphManager manager, @PathParam("graph") String gra @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String verifyToken(@Context GraphManager manager, - @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, @HeaderParam(HttpHeaders.AUTHORIZATION) String token) { E.checkArgument(StringUtils.isNotEmpty(token), "Request header Authorization must not be null"); - LOG.debug("Graph [{}] get user: {}", graph, token); + LOG.debug("get user: {}", token); if (!token.startsWith(AuthenticationFilter.BEARER_TOKEN_PREFIX)) { throw new BadRequestException("Only HTTP Bearer authentication is supported"); @@ -122,8 +116,7 @@ public String verifyToken(@Context GraphManager manager, token = token.substring(AuthenticationFilter.BEARER_TOKEN_PREFIX.length()); UserWithRole userWithRole = manager.authManager().validateUser(token); - HugeGraph g = graph(manager, graphSpace, graph); - return manager.serializer(g) + return manager.serializer() .writeMap(ImmutableMap.of(AuthConstant.TOKEN_USER_NAME, userWithRole.username(), AuthConstant.TOKEN_USER_ID, @@ -133,10 +126,13 @@ public String verifyToken(@Context GraphManager manager, private static class JsonLogin implements Checkable { @JsonProperty("user_name") + @Schema(description = "The user name") private String name; @JsonProperty("user_password") + @Schema(description = "The user password") private String password; @JsonProperty("token_expire") + @Schema(description = "Token expiration time in seconds") private long expire; @Override diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/ManagerAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/ManagerAPI.java new file mode 100644 index 0000000000..071e4b8a66 --- /dev/null +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/ManagerAPI.java @@ -0,0 +1,297 @@ +/* + * Copyright 2017 HugeGraph Authors + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with this + * work for additional information regarding copyright ownership. The ASF + * licenses this file to You under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hugegraph.api.auth; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.hugegraph.api.API; +import org.apache.hugegraph.api.filter.StatusFilter; +import org.apache.hugegraph.auth.AuthManager; +import org.apache.hugegraph.auth.HugeGraphAuthProxy; +import org.apache.hugegraph.auth.HugePermission; +import org.apache.hugegraph.core.GraphManager; +import org.apache.hugegraph.define.Checkable; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; + +import com.codahale.metrics.annotation.Timed; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.google.common.collect.ImmutableMap; + +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.inject.Singleton; +import jakarta.ws.rs.Consumes; +import jakarta.ws.rs.DELETE; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.POST; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.PathParam; +import jakarta.ws.rs.Produces; +import jakarta.ws.rs.QueryParam; +import jakarta.ws.rs.core.Context; + +@Path("graphspaces/{graphspace}/auth/managers") +@Singleton +@Tag(name = "ManagerAPI") +public class ManagerAPI extends API { + + private static final Logger LOG = Log.logger(ManagerAPI.class); + + @POST + @Timed + @StatusFilter.Status(StatusFilter.Status.CREATED) + @Consumes(APPLICATION_JSON) + @Produces(APPLICATION_JSON_WITH_CHARSET) + public String createManager(@Context GraphManager manager, + @Parameter(description = "The graph space name") + @PathParam("graphspace") String graphSpace, + JsonManager jsonManager) { + LOG.debug("Create manager: {}", jsonManager); + ensurePdModeEnabled(manager); + String user = jsonManager.user; + HugePermission type = jsonManager.type; + // graphSpace now comes from @PathParam instead of JsonManager + + validType(type); + AuthManager authManager = manager.authManager(); + validUser(authManager, user); + + String creator = HugeGraphAuthProxy.username(); + switch (type) { + case SPACE: + validGraphSpace(manager, graphSpace); + validPermission( + hasAdminOrSpaceManagerPerm(manager, graphSpace, creator), + creator, "manager.create"); + if (authManager.isSpaceMember(graphSpace, user)) { + authManager.deleteSpaceMember(graphSpace, user); + } + authManager.createSpaceManager(graphSpace, user); + break; + case SPACE_MEMBER: + validGraphSpace(manager, graphSpace); + validPermission( + hasAdminOrSpaceManagerPerm(manager, graphSpace, creator), + creator, "manager.create"); + if (authManager.isSpaceManager(graphSpace, user)) { + authManager.deleteSpaceManager(graphSpace, user); + } + authManager.createSpaceMember(graphSpace, user); + break; + case ADMIN: + validPermission(hasAdminPerm(manager, creator), + creator, "manager.create"); + authManager.createAdminManager(user); + break; + default: + throw new IllegalArgumentException("Invalid type"); + } + + return manager.serializer() + .writeMap(ImmutableMap.of("user", user, "type", type, + "graphspace", graphSpace)); + } + + @DELETE + @Timed + @Consumes(APPLICATION_JSON) + public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") + @PathParam("graphspace") String graphSpace, + @Parameter(description = "The user name") + @QueryParam("user") String user, + @Parameter(description = "The manager type: SPACE, SPACE_MEMBER, or ADMIN") + @QueryParam("type") HugePermission type) { + LOG.debug("Delete graph manager: {} {} {}", user, type, graphSpace); + ensurePdModeEnabled(manager); + E.checkArgument(!"admin".equals(user) || + type != HugePermission.ADMIN, + "User 'admin' can't be removed from ADMIN"); + + AuthManager authManager = manager.authManager(); + validType(type); + validUser(authManager, user); + String actionUser = HugeGraphAuthProxy.username(); + + switch (type) { + case SPACE: + // only space manager and admin can delete user permission + validGraphSpace(manager, graphSpace); + validPermission( + hasAdminOrSpaceManagerPerm(manager, graphSpace, actionUser), + actionUser, "manager.delete"); + authManager.deleteSpaceManager(graphSpace, user); + break; + case SPACE_MEMBER: + validGraphSpace(manager, graphSpace); + validPermission( + hasAdminOrSpaceManagerPerm(manager, graphSpace, actionUser), + actionUser, "manager.delete"); + authManager.deleteSpaceMember(graphSpace, user); + break; + case ADMIN: + validPermission( + hasAdminPerm(manager, actionUser), + actionUser, "manager.delete"); + authManager.deleteAdminManager(user); + break; + default: + throw new IllegalArgumentException("Invalid type"); + } + } + + @GET + @Timed + @Consumes(APPLICATION_JSON) + public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") + @PathParam("graphspace") String graphSpace, + @Parameter(description = "The manager type: SPACE, SPACE_MEMBER or ADMIN") + @QueryParam("type") HugePermission type) { + LOG.debug("list graph manager: {} {}", type, graphSpace); + ensurePdModeEnabled(manager); + AuthManager authManager = manager.authManager(); + validType(type); + List adminManagers; + switch (type) { + case SPACE: + validGraphSpace(manager, graphSpace); + adminManagers = authManager.listSpaceManager(graphSpace); + break; + case SPACE_MEMBER: + validGraphSpace(manager, graphSpace); + adminManagers = authManager.listSpaceMember(graphSpace); + break; + case ADMIN: + adminManagers = authManager.listAdminManager(); + break; + default: + throw new IllegalArgumentException("Invalid type"); + } + return manager.serializer().writeList("admins", adminManagers); + } + + @GET + @Timed + @Path("check") + @Consumes(APPLICATION_JSON) + public String checkRole(@Context GraphManager manager, + @Parameter(description = "The graph space name") + @PathParam("graphspace") String graphSpace, + @Parameter(description = "The manager type: " + + "SPACE, SPACE_MEMBER, or ADMIN") + @QueryParam("type") HugePermission type) { + LOG.debug("check if current user is graph manager: {} {}", type, graphSpace); + ensurePdModeEnabled(manager); + validType(type); + AuthManager authManager = manager.authManager(); + String user = HugeGraphAuthProxy.username(); + + boolean result; + switch (type) { + case SPACE: + validGraphSpace(manager, graphSpace); + result = authManager.isSpaceManager(graphSpace, user); + break; + case SPACE_MEMBER: + validGraphSpace(manager, graphSpace); + result = authManager.isSpaceMember(graphSpace, user); + break; + case ADMIN: + result = authManager.isAdminManager(user); + break; + default: + throw new IllegalArgumentException("Invalid type"); + } + return manager.serializer().writeMap(ImmutableMap.of("check", result)); + } + + @GET + @Timed + @Path("role") + @Consumes(APPLICATION_JSON) + public String getRolesInGs(@Context GraphManager manager, + @Parameter(description = "The graph space name") + @PathParam("graphspace") String graphSpace, + @Parameter(description = "The user name") @QueryParam("user") + String user) { + LOG.debug("get user [{}]'s role in graph space [{}]", user, graphSpace); + ensurePdModeEnabled(manager); + AuthManager authManager = manager.authManager(); + List result = new ArrayList<>(); + validGraphSpace(manager, graphSpace); + + if (authManager.isAdminManager(user)) { + result.add(HugePermission.ADMIN); + } + if (authManager.isSpaceManager(graphSpace, user)) { + result.add(HugePermission.SPACE); + } + if (authManager.isSpaceMember(graphSpace, user)) { + result.add(HugePermission.SPACE_MEMBER); + } + if (result.isEmpty()) { + result.add(HugePermission.NONE); + } + return manager.serializer().writeMap( + ImmutableMap.of("user", user, "graphspace", graphSpace, "roles", + result)); + } + + private void validUser(AuthManager authManager, String user) { + E.checkArgument(authManager.findUser(user) != null || + authManager.findGroup(user) != null, + "The user or group is not exist"); + } + + private void validType(HugePermission type) { + E.checkArgument(type == HugePermission.SPACE || + type == HugePermission.SPACE_MEMBER || + type == HugePermission.ADMIN, + "The type must be in [SPACE, SPACE_MEMBER, ADMIN]"); + } + + private void validGraphSpace(GraphManager manager, String graphSpace) { + E.checkArgument(manager.graphSpace(graphSpace) != null, + "The graph space is not exist"); + } + + private static class JsonManager implements Checkable { + + @JsonProperty("user") + @Schema(description = "The user or group name", required = true) + private String user; + @JsonProperty("type") + @Schema(description = "The manager type: SPACE, SPACE_MEMBER, or ADMIN", required = true) + private HugePermission type; + + @Override + public void checkCreate(boolean isBatch) { + } + + @Override + public void checkUpdate() { + } + } +} diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/ProjectAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/ProjectAPI.java index 97bf81e58c..4380093ba0 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/ProjectAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/ProjectAPI.java @@ -23,7 +23,6 @@ import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang.StringUtils; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter.Status; import org.apache.hugegraph.auth.AuthManager; @@ -40,6 +39,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -54,7 +55,7 @@ import jakarta.ws.rs.QueryParam; import jakarta.ws.rs.core.Context; -@Path("graphspaces/{graphspace}/graphs/{graph}/auth/projects") +@Path("graphspaces/{graphspace}/auth/projects") @Singleton @Tag(name = "ProjectAPI") public class ProjectAPI extends API { @@ -69,13 +70,12 @@ public class ProjectAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, JsonProject jsonProject) { - LOG.debug("Graph [{}] create project: {}", graph, jsonProject); + LOG.debug("GraphSpace [{}] create project: {}", graphSpace, jsonProject); checkCreatingBody(jsonProject); - HugeGraph g = graph(manager, graphSpace, graph); HugeProject project = jsonProject.build(); Id projectId = manager.authManager().createProject(project); /* @@ -83,7 +83,7 @@ public String create(@Context GraphManager manager, * created */ project = manager.authManager().getProject(projectId); - return manager.serializer(g).writeAuthElement(project); + return manager.serializer().writeAuthElement(project); } @PUT @@ -92,16 +92,21 @@ public String create(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The project id") @PathParam("id") String id, + @Parameter( + description = "The action to perform: " + + "add_graph, remove_graph, " + + "or empty for description " + + "update") @QueryParam("action") String action, JsonProject jsonProject) { - LOG.debug("Graph [{}] update {} project: {}", graph, action, + LOG.debug("GraphSpace [{}] update {} project: {}", graphSpace, action, jsonProject); checkUpdatingBody(jsonProject); - HugeGraph g = graph(manager, graphSpace, graph); HugeProject project; Id projectId = UserAPI.parseId(id); AuthManager authManager = manager.authManager(); @@ -124,22 +129,22 @@ public String update(@Context GraphManager manager, project = jsonProject.buildUpdateDescription(project); } authManager.updateProject(project); - return manager.serializer(g).writeAuthElement(project); + return manager.serializer().writeAuthElement(project); } @GET @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The limit of results to return") @QueryParam("limit") @DefaultValue("100") long limit) { - LOG.debug("Graph [{}] list project", graph); + LOG.debug("GraphSpace [{}] list project", graphSpace); - HugeGraph g = graph(manager, graphSpace, graph); List projects = manager.authManager() .listAllProject(limit); - return manager.serializer(g).writeAuthElements("projects", projects); + return manager.serializer().writeAuthElements("projects", projects); } @GET @@ -147,19 +152,19 @@ public String list(@Context GraphManager manager, @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The project id") @PathParam("id") String id) { - LOG.debug("Graph [{}] get project: {}", graph, id); + LOG.debug("GraphSpace [{}] get project: {}", graphSpace, id); - HugeGraph g = graph(manager, graphSpace, graph); HugeProject project; try { project = manager.authManager().getProject(UserAPI.parseId(id)); } catch (NotFoundException e) { throw new IllegalArgumentException("Invalid project id: " + id); } - return manager.serializer(g).writeAuthElement(project); + return manager.serializer().writeAuthElement(project); } @DELETE @@ -167,13 +172,12 @@ public String get(@Context GraphManager manager, @Path("{id}") @Consumes(APPLICATION_JSON) public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The project id") @PathParam("id") String id) { - LOG.debug("Graph [{}] delete project: {}", graph, id); + LOG.debug("GraphSpace [{}] delete project: {}", graphSpace, id); - @SuppressWarnings("unused") // just check if the graph exists - HugeGraph g = graph(manager, graphSpace, graph); try { manager.authManager().deleteProject(UserAPI.parseId(id)); } catch (NotFoundException e) { @@ -196,10 +200,13 @@ public static boolean isRemoveGraph(String action) { private static class JsonProject implements Checkable { @JsonProperty("project_name") + @Schema(description = "The project name", required = true) private String name; @JsonProperty("project_graphs") + @Schema(description = "Set of graph names associated with the project") private Set graphs; @JsonProperty("project_description") + @Schema(description = "The project description") private String description; public HugeProject build() { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/TargetAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/TargetAPI.java index 8dfae357f8..7f673048dc 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/TargetAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/TargetAPI.java @@ -20,7 +20,6 @@ import java.util.List; import java.util.Map; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter.Status; import org.apache.hugegraph.auth.HugeTarget; @@ -36,6 +35,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -50,7 +51,7 @@ import jakarta.ws.rs.QueryParam; import jakarta.ws.rs.core.Context; -@Path("graphspaces/{graphspace}/graphs/{graph}/auth/targets") +@Path("graphspaces/{graphspace}/auth/targets") @Singleton @Tag(name = "TargetAPI") public class TargetAPI extends API { @@ -63,16 +64,15 @@ public class TargetAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, JsonTarget jsonTarget) { - LOG.debug("Graph [{}] create target: {}", graph, jsonTarget); + LOG.debug("GraphSpace [{}] create target: {}", graphSpace, jsonTarget); checkCreatingBody(jsonTarget); - HugeGraph g = graph(manager, graphSpace, graph); HugeTarget target = jsonTarget.build(); target.id(manager.authManager().createTarget(target)); - return manager.serializer(g).writeAuthElement(target); + return manager.serializer().writeAuthElement(target); } @PUT @@ -81,14 +81,14 @@ public String create(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The target id") @PathParam("id") String id, JsonTarget jsonTarget) { - LOG.debug("Graph [{}] update target: {}", graph, jsonTarget); + LOG.debug("GraphSpace [{}] update target: {}", graphSpace, jsonTarget); checkUpdatingBody(jsonTarget); - HugeGraph g = graph(manager, graphSpace, graph); HugeTarget target; try { target = manager.authManager().getTarget(UserAPI.parseId(id)); @@ -97,21 +97,21 @@ public String update(@Context GraphManager manager, } target = jsonTarget.build(target); manager.authManager().updateTarget(target); - return manager.serializer(g).writeAuthElement(target); + return manager.serializer().writeAuthElement(target); } @GET @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The limit of results to return") @QueryParam("limit") @DefaultValue("100") long limit) { - LOG.debug("Graph [{}] list targets", graph); + LOG.debug("GraphSpace [{}] list targets", graphSpace); - HugeGraph g = graph(manager, graphSpace, graph); List targets = manager.authManager().listAllTargets(limit); - return manager.serializer(g).writeAuthElements("targets", targets); + return manager.serializer().writeAuthElements("targets", targets); } @GET @@ -119,14 +119,14 @@ public String list(@Context GraphManager manager, @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The target id") @PathParam("id") String id) { - LOG.debug("Graph [{}] get target: {}", graph, id); + LOG.debug("GraphSpace [{}] get target: {}", graphSpace, id); - HugeGraph g = graph(manager, graphSpace, graph); HugeTarget target = manager.authManager().getTarget(UserAPI.parseId(id)); - return manager.serializer(g).writeAuthElement(target); + return manager.serializer().writeAuthElement(target); } @DELETE @@ -134,13 +134,12 @@ public String get(@Context GraphManager manager, @Path("{id}") @Consumes(APPLICATION_JSON) public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The target id") @PathParam("id") String id) { - LOG.debug("Graph [{}] delete target: {}", graph, id); + LOG.debug("GraphSpace [{}] delete target: {}", graphSpace, id); - @SuppressWarnings("unused") // just check if the graph exists - HugeGraph g = graph(manager, graphSpace, graph); try { manager.authManager().deleteTarget(UserAPI.parseId(id)); } catch (NotFoundException e) { @@ -153,12 +152,16 @@ public void delete(@Context GraphManager manager, private static class JsonTarget implements Checkable { @JsonProperty("target_name") + @Schema(description = "The target name", required = true) private String name; @JsonProperty("target_graph") + @Schema(description = "The target graph name", required = true) private String graph; @JsonProperty("target_url") + @Schema(description = "The target URL", required = true) private String url; @JsonProperty("target_resources") // error when List + @Schema(description = "The target resources") private List> resources; public HugeTarget build(HugeTarget target) { @@ -185,6 +188,16 @@ public HugeTarget build() { return target; } + @Override + public String toString() { + return "JsonTarget{" + + "name='" + name + '\'' + + ", graph='" + graph + '\'' + + ", url='" + url + '\'' + + ", resources=" + resources + + '}'; + } + @Override public void checkCreate(boolean isBatch) { E.checkArgumentNotNull(this.name, diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/UserAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/UserAPI.java index f098508da4..de51e6955d 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/UserAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/auth/UserAPI.java @@ -20,7 +20,6 @@ import java.util.List; import org.apache.commons.lang3.StringUtils; -import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter.Status; import org.apache.hugegraph.auth.HugeUser; @@ -38,6 +37,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -52,7 +53,7 @@ import jakarta.ws.rs.QueryParam; import jakarta.ws.rs.core.Context; -@Path("graphspaces/{graphspace}/graphs/{graph}/auth/users") +@Path("graphspaces/{graphspace}/auth/users") @Singleton @Tag(name = "UserAPI") public class UserAPI extends API { @@ -65,16 +66,15 @@ public class UserAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, JsonUser jsonUser) { - LOG.debug("Graph [{}] create user: {}", graph, jsonUser); + LOG.debug("GraphSpace [{}] create user: {}", graphSpace, jsonUser); checkCreatingBody(jsonUser); - HugeGraph g = graph(manager, graphSpace, graph); HugeUser user = jsonUser.build(); user.id(manager.authManager().createUser(user)); - return manager.serializer(g).writeAuthElement(user); + return manager.serializer().writeAuthElement(user); } @PUT @@ -83,14 +83,14 @@ public String create(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The user id") @PathParam("id") String id, JsonUser jsonUser) { - LOG.debug("Graph [{}] update user: {}", graph, jsonUser); + LOG.debug("GraphSpace [{}] update user: {}", graphSpace, jsonUser); checkUpdatingBody(jsonUser); - HugeGraph g = graph(manager, graphSpace, graph); HugeUser user; try { user = manager.authManager().getUser(UserAPI.parseId(id)); @@ -99,21 +99,21 @@ public String update(@Context GraphManager manager, } user = jsonUser.build(user); manager.authManager().updateUser(user); - return manager.serializer(g).writeAuthElement(user); + return manager.serializer().writeAuthElement(user); } @GET @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The limit of results to return") @QueryParam("limit") @DefaultValue("100") long limit) { - LOG.debug("Graph [{}] list users", graph); + LOG.debug("GraphSpace [{}] list users", graphSpace); - HugeGraph g = graph(manager, graphSpace, graph); List users = manager.authManager().listAllUsers(limit); - return manager.serializer(g).writeAuthElements("users", users); + return manager.serializer().writeAuthElements("users", users); } @GET @@ -121,14 +121,14 @@ public String list(@Context GraphManager manager, @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The user id") @PathParam("id") String id) { - LOG.debug("Graph [{}] get user: {}", graph, id); + LOG.debug("GraphSpace [{}] get user: {}", graphSpace, id); - HugeGraph g = graph(manager, graphSpace, graph); HugeUser user = manager.authManager().getUser(IdGenerator.of(id)); - return manager.serializer(g).writeAuthElement(user); + return manager.serializer().writeAuthElement(user); } @GET @@ -136,13 +136,12 @@ public String get(@Context GraphManager manager, @Path("{id}/role") @Produces(APPLICATION_JSON_WITH_CHARSET) public String role(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The user id") @PathParam("id") String id) { - LOG.debug("Graph [{}] get user role: {}", graph, id); + LOG.debug("GraphSpace [{}] get user role: {}", graphSpace, id); - @SuppressWarnings("unused") // just check if the graph exists - HugeGraph g = graph(manager, graphSpace, graph); HugeUser user = manager.authManager().getUser(IdGenerator.of(id)); return manager.authManager().rolePermission(user).toJson(); } @@ -152,13 +151,12 @@ public String role(@Context GraphManager manager, @Path("{id}") @Consumes(APPLICATION_JSON) public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, - @PathParam("graph") String graph, + @Parameter(description = "The user id") @PathParam("id") String id) { - LOG.debug("Graph [{}] delete user: {}", graph, id); + LOG.debug("GraphSpace [{}] delete user: {}", graphSpace, id); - @SuppressWarnings("unused") // just check if the graph exists - HugeGraph g = graph(manager, graphSpace, graph); try { manager.authManager().deleteUser(IdGenerator.of(id)); } catch (NotFoundException e) { @@ -175,16 +173,22 @@ protected static Id parseId(String id) { private static class JsonUser implements Checkable { @JsonProperty("user_name") + @Schema(description = "The user name", required = true) private String name; @JsonProperty("user_password") + @Schema(description = "The user password", required = true) private String password; @JsonProperty("user_phone") + @Schema(description = "The user phone number") private String phone; @JsonProperty("user_email") + @Schema(description = "The user email address") private String email; @JsonProperty("user_avatar") + @Schema(description = "The user avatar URL") private String avatar; @JsonProperty("user_description") + @Schema(description = "The user description") private String description; public HugeUser build(HugeUser user) { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherAPI.java index e8f760140a..a30bff73b8 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherAPI.java @@ -33,6 +33,7 @@ import com.codahale.metrics.annotation.Timed; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -72,8 +73,11 @@ private CypherManager cypherManager() { @CompressInterceptor.Compress(buffer = (1024 * 40)) @Produces(APPLICATION_JSON_WITH_CHARSET) public CypherModel query(@Context HttpHeaders headers, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphspace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The cypher query string") @QueryParam("cypher") String cypher) { return this.queryByCypher(headers, graphspace, graph, cypher); @@ -86,8 +90,11 @@ public CypherModel query(@Context HttpHeaders headers, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public CypherModel post(@Context HttpHeaders headers, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphspace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The cypher query string") String cypher) { return this.queryByCypher(headers, graphspace, graph, cypher); diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherModel.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherModel.java index cd5a769237..e7c3900605 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherModel.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/cypher/CypherModel.java @@ -21,13 +21,20 @@ import java.util.List; import java.util.Map; +import io.swagger.v3.oas.annotations.media.Schema; + /** * As same as response of GremlinAPI */ public class CypherModel { + @Schema(description = "The request ID") public String requestId; + + @Schema(description = "The response status") public Status status = new Status(); + + @Schema(description = "The query result") public Result result = new Result(); public static CypherModel dataOf(String requestId, List data) { @@ -51,14 +58,22 @@ private CypherModel() { public static class Status { + @Schema(description = "The status message") public String message = ""; + + @Schema(description = "The status code") public int code; + + @Schema(description = "Additional status attributes") public Map attributes = Collections.EMPTY_MAP; } private static class Result { + @Schema(description = "The result data list") public List data; + + @Schema(description = "The result metadata") public Map meta = Collections.EMPTY_MAP; } diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/LoadDetectFilter.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/LoadDetectFilter.java index 7ee5e7c0f7..1df19f5e5c 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/LoadDetectFilter.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/LoadDetectFilter.java @@ -19,12 +19,16 @@ import java.util.List; import java.util.Set; +import java.util.function.BooleanSupplier; +import java.util.function.LongSupplier; import org.apache.hugegraph.config.HugeConfig; import org.apache.hugegraph.config.ServerOptions; import org.apache.hugegraph.define.WorkLoad; import org.apache.hugegraph.util.Bytes; import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; import com.google.common.collect.ImmutableSet; import com.google.common.util.concurrent.RateLimiter; @@ -43,6 +47,8 @@ @PreMatching public class LoadDetectFilter implements ContainerRequestFilter { + private static final Logger LOG = Log.logger(LoadDetectFilter.class); + private static final Set WHITE_API_LIST = ImmutableSet.of( "", "apis", @@ -54,10 +60,44 @@ public class LoadDetectFilter implements ContainerRequestFilter { private static final RateLimiter GC_RATE_LIMITER = RateLimiter.create(1.0 / 30); + // Log at most 1 request per second to avoid too many logs when server is under heavy load + private static final RateLimiter BUSY_REJECT_LOG_RATE_LIMITER = + RateLimiter.create(1.0); + private static final RateLimiter MEMORY_REJECT_LOG_RATE_LIMITER = + RateLimiter.create(1.0); + @Context private jakarta.inject.Provider configProvider; @Context private jakarta.inject.Provider loadProvider; + private BooleanSupplier gcTrigger = LoadDetectFilter::triggerGcIfNeeded; + private BooleanSupplier busyRejectLogPermit = + BUSY_REJECT_LOG_RATE_LIMITER::tryAcquire; + private BooleanSupplier memoryRejectLogPermit = + MEMORY_REJECT_LOG_RATE_LIMITER::tryAcquire; + private LongSupplier freeMemorySupplier = LoadDetectFilter::currentFreeMemoryInMB; + + public static boolean isWhiteAPI(ContainerRequestContext context) { + List segments = context.getUriInfo().getPathSegments(); + E.checkArgument(!segments.isEmpty(), "Invalid request uri '%s'", + context.getUriInfo().getPath()); + String rootPath = segments.get(0).getPath(); + return WHITE_API_LIST.contains(rootPath); + } + + private static boolean triggerGcIfNeeded() { + if (GC_RATE_LIMITER.tryAcquire(1)) { + System.gc(); + return true; + } + return false; + } + + private static long currentFreeMemoryInMB() { + long allocatedMem = Runtime.getRuntime().totalMemory() - + Runtime.getRuntime().freeMemory(); + return (Runtime.getRuntime().maxMemory() - allocatedMem) / Bytes.MB; + } @Override public void filter(ContainerRequestContext context) { @@ -70,7 +110,14 @@ public void filter(ContainerRequestContext context) { int maxWorkerThreads = config.get(ServerOptions.MAX_WORKER_THREADS); WorkLoad load = this.loadProvider.get(); // There will be a thread doesn't work, dedicated to statistics - if (load.incrementAndGet() >= maxWorkerThreads) { + int currentLoad = load.incrementAndGet(); + if (currentLoad >= maxWorkerThreads) { + if (this.busyRejectLogPermit.getAsBoolean()) { + LOG.warn("Rejected request due to high worker load, method={}, path={}, " + + "currentLoad={}, maxWorkerThreads={}", + context.getMethod(), context.getUriInfo().getPath(), + currentLoad, maxWorkerThreads); + } throw new ServiceUnavailableException(String.format( "The server is too busy to process the request, " + "you can config %s to adjust it or try again later", @@ -78,12 +125,35 @@ public void filter(ContainerRequestContext context) { } long minFreeMemory = config.get(ServerOptions.MIN_FREE_MEMORY); - long allocatedMem = Runtime.getRuntime().totalMemory() - - Runtime.getRuntime().freeMemory(); - long presumableFreeMem = (Runtime.getRuntime().maxMemory() - - allocatedMem) / Bytes.MB; + long presumableFreeMem = this.freeMemorySupplier.getAsLong(); if (presumableFreeMem < minFreeMemory) { - gcIfNeeded(); + boolean gcTriggered = this.gcTrigger.getAsBoolean(); + if (gcTriggered) { + long recheckedFreeMem = this.freeMemorySupplier.getAsLong(); + if (recheckedFreeMem >= minFreeMemory) { + if (this.memoryRejectLogPermit.getAsBoolean()) { + LOG.warn("Low free memory recovered after GC, method={}, path={}, " + + "presumableFreeMemMB={}, recheckedFreeMemMB={}, " + + "minFreeMemoryMB={}", + context.getMethod(), context.getUriInfo().getPath(), + presumableFreeMem, recheckedFreeMem, minFreeMemory); + } + return; + } + if (this.memoryRejectLogPermit.getAsBoolean()) { + LOG.warn("Rejected request due to low free memory after GC, " + + "method={}, path={}, presumableFreeMemMB={}, " + + "recheckedFreeMemMB={}, minFreeMemoryMB={}", + context.getMethod(), context.getUriInfo().getPath(), + presumableFreeMem, recheckedFreeMem, minFreeMemory); + } + presumableFreeMem = recheckedFreeMem; + } else if (this.memoryRejectLogPermit.getAsBoolean()) { + LOG.warn("Rejected request due to low free memory, method={}, path={}, " + + "presumableFreeMemMB={}, minFreeMemoryMB={}", + context.getMethod(), context.getUriInfo().getPath(), + presumableFreeMem, minFreeMemory); + } throw new ServiceUnavailableException(String.format( "The server available memory %s(MB) is below than " + "threshold %s(MB) and can't process the request, " + @@ -92,18 +162,4 @@ public void filter(ContainerRequestContext context) { ServerOptions.MIN_FREE_MEMORY.name())); } } - - public static boolean isWhiteAPI(ContainerRequestContext context) { - List segments = context.getUriInfo().getPathSegments(); - E.checkArgument(!segments.isEmpty(), "Invalid request uri '%s'", - context.getUriInfo().getPath()); - String rootPath = segments.get(0).getPath(); - return WHITE_API_LIST.contains(rootPath); - } - - private static void gcIfNeeded() { - if (GC_RATE_LIMITER.tryAcquire(1)) { - System.gc(); - } - } } diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/PathFilter.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/PathFilter.java index dda43b3fba..b69ff59596 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/PathFilter.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/PathFilter.java @@ -18,11 +18,25 @@ package org.apache.hugegraph.api.filter; import java.io.IOException; +import java.net.URI; +import java.util.List; +import java.util.Set; + +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.config.ServerOptions; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; + +import com.google.common.collect.ImmutableSet; import jakarta.inject.Singleton; import jakarta.ws.rs.container.ContainerRequestContext; import jakarta.ws.rs.container.ContainerRequestFilter; import jakarta.ws.rs.container.PreMatching; +import jakarta.ws.rs.core.Context; +import jakarta.ws.rs.core.PathSegment; +import jakarta.ws.rs.core.UriInfo; import jakarta.ws.rs.ext.Provider; @Provider @@ -30,29 +44,75 @@ @PreMatching public class PathFilter implements ContainerRequestFilter { + private static final Logger LOG = Log.logger(PathFilter.class); + + private static final String GRAPH_SPACE = "graphspaces"; + private static final String ARTHAS_START = "arthas"; + public static final String REQUEST_TIME = "request_time"; public static final String REQUEST_PARAMS_JSON = "request_params_json"; + private static final String DELIMITER = "/"; + private static final Set WHITE_API_LIST = ImmutableSet.of( + "", + "apis", + "metrics", + "versions", + "health", + "gremlin", + "graphs/auth", + "graphs/auth/users", + "auth/users", + "auth/managers", + "auth", + "hstore", + "pd", + "kafka", + "whiteiplist", + "vermeer", + "store", + "expiredclear", + "department", + "saas", + "trade", + "kvstore", + "openapi.json" + ); + + @Context + private jakarta.inject.Provider configProvider; + + public static boolean isWhiteAPI(String rootPath) { + + return WHITE_API_LIST.contains(rootPath); + } + @Override - public void filter(ContainerRequestContext context) throws IOException { + public void filter(ContainerRequestContext context) + throws IOException { context.setProperty(REQUEST_TIME, System.currentTimeMillis()); - // TODO: temporarily comment it to fix loader bug, handle it later - /*// record the request json - String method = context.getMethod(); - String requestParamsJson = ""; - if (method.equals(HttpMethod.POST)) { - requestParamsJson = IOUtils.toString(context.getEntityStream(), - Charsets.toCharset(CHARSET)); - // replace input stream because we have already read it - InputStream in = IOUtils.toInputStream(requestParamsJson, Charsets.toCharset(CHARSET)); - context.setEntityStream(in); - } else if (method.equals(HttpMethod.GET)) { - MultivaluedMap pathParameters = context.getUriInfo() - .getPathParameters(); - requestParamsJson = pathParameters.toString(); + List segments = context.getUriInfo().getPathSegments(); + E.checkArgument(segments.size() > 0, "Invalid request uri '%s'", + context.getUriInfo().getPath()); + String rootPath = segments.get(0).getPath(); + + if (isWhiteAPI(rootPath) || GRAPH_SPACE.equals(rootPath) || + ARTHAS_START.equals(rootPath)) { + return; } - context.setProperty(REQUEST_PARAMS_JSON, requestParamsJson);*/ + UriInfo uriInfo = context.getUriInfo(); + String defaultPathSpace = + this.configProvider.get().get(ServerOptions.PATH_GRAPH_SPACE); + String path = uriInfo.getBaseUri().getPath() + + String.join(DELIMITER, GRAPH_SPACE, defaultPathSpace); + for (PathSegment segment : segments) { + path = String.join(DELIMITER, path, segment.getPath()); + } + LOG.debug("Redirect request uri from {} to {}", + uriInfo.getRequestUri().getPath(), path); + URI requestUri = uriInfo.getRequestUriBuilder().uri(path).build(); + context.setRequestUri(uriInfo.getBaseUri(), requestUri); } } diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/BatchAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/BatchAPI.java index 2ba95e5bc9..85beb142db 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/BatchAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/BatchAPI.java @@ -40,6 +40,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + public class BatchAPI extends API { private static final Logger LOG = Log.logger(BatchAPI.class); @@ -78,14 +80,20 @@ public R commit(HugeConfig config, HugeGraph g, int size, } @JsonIgnoreProperties(value = {"type"}) + @Schema(description = "Base class for vertex/edge in batch operations") protected abstract static class JsonElement implements Checkable { + @Schema(description = "The vertex/edge ID. If not specified, " + + "it will be automatically generated based on ID strategy") @JsonProperty("id") public Object id; + @Schema(description = "The vertex/edge label") @JsonProperty("label") public String label; + @Schema(description = "The properties of the vertex/edge in key-value format") @JsonProperty("properties") public Map properties; + @Schema(description = "The type of element (vertex or edge)", hidden = true) @JsonProperty("type") public String type; diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/EdgeAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/EdgeAPI.java index 279c9c0e98..1f229cd6b1 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/EdgeAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/EdgeAPI.java @@ -57,6 +57,8 @@ import com.codahale.metrics.annotation.Timed; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -85,9 +87,11 @@ public class EdgeAPI extends BatchAPI { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=edge_write"}) + "$action=edge_write"}) public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, JsonEdge jsonEdge) { LOG.debug("Graph [{}] create edge: {}", graph, jsonEdge); @@ -114,7 +118,7 @@ public String create(@Context GraphManager manager, jsonEdge.properties()); }); - return manager.serializer(g).writeEdge(edge); + return manager.serializer().writeEdge(edge); } @POST @@ -125,11 +129,14 @@ public String create(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=edge_write"}) + "$action=edge_write"}) public String create(@Context HugeConfig config, @Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "Whether to check if target vertices exist") @QueryParam("check_vertex") @DefaultValue("true") boolean checkVertex, List jsonEdges) { @@ -155,7 +162,7 @@ public String create(@Context HugeConfig config, Edge edge = srcVertex.addEdge(jsonEdge.label, tgtVertex, jsonEdge.properties()); ids.add((Id) edge.id()); } - return manager.serializer(g).writeIds(ids); + return manager.serializer().writeIds(ids); }); } @@ -169,10 +176,12 @@ public String create(@Context HugeConfig config, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=edge_write"}) + "$action=edge_write"}) public String update(@Context HugeConfig config, @Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, BatchEdgeRequest req) { BatchEdgeRequest.checkUpdate(req); @@ -213,7 +222,7 @@ public String update(@Context HugeConfig config, }); // If return ids, the ids.size() maybe different with the origins' - return manager.serializer(g).writeEdges(edges.iterator(), false); + return manager.serializer().writeEdges(edges.iterator(), false); }); } @@ -223,11 +232,15 @@ public String update(@Context HugeConfig config, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=edge_write"}) + "$action=edge_write"}) public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The edge ID") @PathParam("id") String id, + @Parameter(description = "Action to perform: 'append' or 'remove'") @QueryParam("action") String action, JsonEdge jsonEdge) { LOG.debug("Graph [{}] update edge: {}", graph, jsonEdge); @@ -255,7 +268,7 @@ public String update(@Context GraphManager manager, } commit(g, () -> updateProperties(edge, jsonEdge, append)); - return manager.serializer(g).writeEdge(edge); + return manager.serializer().writeEdge(edge); } @GET @@ -263,18 +276,29 @@ public String update(@Context GraphManager manager, @Compress @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=edge_read"}) + "$action=edge_read"}) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex ID to query edges. " + + "If not specified, query all edges") @QueryParam("vertex_id") String vertexId, + @Parameter(description = "The direction of edges: BOTH, IN, or OUT") @QueryParam("direction") String direction, + @Parameter(description = "Filter by edge label") @QueryParam("label") String label, + @Parameter(description = "Filter by edge properties in JSON format") @QueryParam("properties") String properties, + @Parameter(description = "Keep the starting predicate P in property query") @QueryParam("keep_start_p") @DefaultValue("false") boolean keepStartP, + @Parameter(description = "Offset for pagination") @QueryParam("offset") @DefaultValue("0") long offset, + @Parameter(description = "Page number for pagination") @QueryParam("page") String page, + @Parameter(description = "Limit the number of edges returned") @QueryParam("limit") @DefaultValue("100") long limit) { LOG.debug("Graph [{}] query edges by vertex: {}, direction: {}, " + "label: {}, properties: {}, offset: {}, page: {}, limit: {}", @@ -329,7 +353,7 @@ public String list(@Context GraphManager manager, } try { - return manager.serializer(g).writeEdges(traversal, page != null); + return manager.serializer().writeEdges(traversal, page != null); } finally { if (g.tx().isOpen()) { g.tx().close(); @@ -342,17 +366,20 @@ public String list(@Context GraphManager manager, @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=edge_read"}) + "$action=edge_read"}) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The edge ID") @PathParam("id") String id) { LOG.debug("Graph [{}] get edge by id '{}'", graph, id); HugeGraph g = graph(manager, graphSpace, graph); try { Edge edge = g.edge(id); - return manager.serializer(g).writeEdge(edge); + return manager.serializer().writeEdge(edge); } finally { if (g.tx().isOpen()) { g.tx().close(); @@ -365,11 +392,15 @@ public String get(@Context GraphManager manager, @Path("{id}") @Consumes(APPLICATION_JSON) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=edge_delete"}) + "$action=edge_delete"}) public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The edge ID") @PathParam("id") String id, + @Parameter(description = "The edge label (used to verify edge identity)") @QueryParam("label") String label) { LOG.debug("Graph [{}] remove vertex by id '{}'", graph, id); @@ -485,12 +516,16 @@ private Id getEdgeId(HugeGraph g, JsonEdge newEdge) { protected static class BatchEdgeRequest { + @Schema(description = "List of edges to be created or updated", required = true) @JsonProperty("edges") public List jsonEdges; + @Schema(description = "Update strategies for each property key", required = true) @JsonProperty("update_strategies") public Map updateStrategies; + @Schema(description = "Whether to check if source/target vertices exist") @JsonProperty("check_vertex") public boolean checkVertex = false; + @Schema(description = "Whether to create edge if it does not exist") @JsonProperty("create_if_not_exist") public boolean createIfNotExist = true; @@ -515,12 +550,16 @@ public String toString() { private static class JsonEdge extends JsonElement { + @Schema(description = "The source vertex ID", required = true) @JsonProperty("outV") public Object source; + @Schema(description = "The source vertex label", required = true) @JsonProperty("outVLabel") public String sourceLabel; + @Schema(description = "The target vertex ID", required = true) @JsonProperty("inV") public Object target; + @Schema(description = "The target vertex label", required = true) @JsonProperty("inVLabel") public String targetLabel; diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/VertexAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/VertexAPI.java index 5adb33d65d..340f17de62 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/VertexAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/graph/VertexAPI.java @@ -58,6 +58,8 @@ import com.codahale.metrics.annotation.Timed; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -87,7 +89,9 @@ public class VertexAPI extends BatchAPI { @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$owner=$graph $action=vertex_write"}) public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, JsonVertex jsonVertex) { LOG.debug("Graph [{}] create vertex: {}", graph, jsonVertex); @@ -96,7 +100,7 @@ public String create(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); Vertex vertex = commit(g, () -> g.addVertex(jsonVertex.properties())); - return manager.serializer(g).writeVertex(vertex); + return manager.serializer().writeVertex(vertex); } @POST @@ -109,7 +113,9 @@ public String create(@Context GraphManager manager, @RolesAllowed({"space_member", "$owner=$graph $action=vertex_write"}) public String create(@Context HugeConfig config, @Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, List jsonVertices) { LOG.debug("Graph [{}] create vertices: {}", graph, jsonVertices); @@ -123,7 +129,7 @@ public String create(@Context HugeConfig config, for (JsonVertex vertex : jsonVertices) { ids.add((Id) g.addVertex(vertex.properties()).id()); } - return manager.serializer(g).writeIds(ids); + return manager.serializer().writeIds(ids); }); } @@ -142,7 +148,9 @@ public String create(@Context HugeConfig config, @RolesAllowed({"space_member", "$owner=$graph $action=vertex_write"}) public String update(@Context HugeConfig config, @Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, BatchVertexRequest req) { BatchVertexRequest.checkUpdate(req); @@ -180,7 +188,7 @@ public String update(@Context HugeConfig config, }); // If return ids, the ids.size() maybe different with the origins' - return manager.serializer(g).writeVertices(vertices.iterator(), false); + return manager.serializer().writeVertices(vertices.iterator(), false); }); } @@ -191,9 +199,15 @@ public String update(@Context HugeConfig config, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$owner=$graph $action=vertex_write"}) public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex ID") @PathParam("id") String idValue, + @Parameter(description = + "Action to perform: 'append' to add new properties, " + + "'remove' to delete existing properties") @QueryParam("action") String action, JsonVertex jsonVertex) { LOG.debug("Graph [{}] update vertex: {}", graph, jsonVertex); @@ -217,7 +231,85 @@ public String update(@Context GraphManager manager, commit(g, () -> updateProperties(vertex, jsonVertex, append)); - return manager.serializer(g).writeVertex(vertex); + return manager.serializer().writeVertex(vertex); + } + + @POST + @Timed(name = "ann-search") + @Path("annsearch") + @Consumes(APPLICATION_JSON) + @Produces(APPLICATION_JSON_WITH_CHARSET) + @RolesAllowed({"admin", "$owner=$graph $action=vertex_read"}) + public String annSearch(@Context GraphManager manager, + @PathParam("graphspace") String graphSpace, + @PathParam("graph") String graph, + AnnSearchRequest searchRequest) { + LOG.debug("Graph [{}] ANN search with request: {}", graph, searchRequest); + + AnnSearchRequest.checkRequest(searchRequest); + + HugeGraph g = graph(manager, graphSpace, graph); + + // Check if vertex label exists + VertexLabel vertexLabel = g.vertexLabel(searchRequest.vertex_label); + if (vertexLabel == null) { + throw new IllegalArgumentException( + "Vertex label not found: " + searchRequest.vertex_label); + } + + // Check if the property exists in the vertex label + PropertyKey propertyKey = g.propertyKey(searchRequest.properties); + if (propertyKey == null) { + throw new IllegalArgumentException( + "Property key not found: " + searchRequest.properties); + } + + // Check if the property is defined in the vertex label + if (!vertexLabel.properties().contains(propertyKey.id())) { + throw new IllegalArgumentException("Property '" + searchRequest.properties + + "' is not defined in vertex label '" + + searchRequest.vertex_label + "'"); + } + + // Check if vector index exists for the property + boolean hasVectorIndex = g.indexLabels().stream().anyMatch(indexLabel -> + indexLabel.indexType() == IndexType.VECTOR && + indexLabel.baseType() == HugeType.VERTEX_LABEL && + indexLabel.baseValue() + .equals(vertexLabel.id()) && + indexLabel.indexFields() + .contains(propertyKey.id())); + + if (!hasVectorIndex) { + throw new IllegalArgumentException( + "No vector index found for property '" + searchRequest.properties + + "' in vertex label '" + searchRequest.vertex_label + "'"); + } + + // Log query information + LOG.debug( + "ANN query: vertex_label={}, property={}, vector_length={}, metric={}, " + + "dimension={}, hasVectorIndex={}", + searchRequest.vertex_label, searchRequest.properties, + searchRequest.user_vector.length, + searchRequest.metric, searchRequest.dimension, hasVectorIndex); + + try { + // TODO: Here should call the actual ANN query from backend + LOG.debug("ANN query not yet implemented, returning empty result"); + + // Temporary: return empty result + return manager.serializer(g).writeVertices(g.traversal().V().limit(0), false); + + // Future implementation: + // 1. Call JVector engine for similarity query + // 2. Return topk most similar vertices + + } finally { + if (g.tx().isOpen()) { + g.tx().close(); + } + } } @POST @@ -304,14 +396,25 @@ public String annSearch(@Context GraphManager manager, @RolesAllowed({"space", "$graphspace=$graphspace $owner=$graph " + "$action=vertex_read"}) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "Filter by vertex label") @QueryParam("label") String label, + @Parameter(description = "Filter by vertex properties in JSON format, " + + "e.g., {\"key\":\"value\"}") @QueryParam("properties") String properties, + @Parameter(description = + "Keep the starting predicate P (like P.gt(), P.lt()) " + + "in property query or parse it to relational operators") @QueryParam("keep_start_p") @DefaultValue("false") boolean keepStartP, + @Parameter(description = "Offset for pagination") @QueryParam("offset") @DefaultValue("0") long offset, + @Parameter(description = "Page number for pagination") @QueryParam("page") String page, + @Parameter(description = "Limit the number of vertices returned") @QueryParam("limit") @DefaultValue("100") long limit) { LOG.debug("Graph [{}] query vertices by label: {}, properties: {}, " + "offset: {}, page: {}, limit: {}", @@ -351,7 +454,7 @@ public String list(@Context GraphManager manager, } try { - return manager.serializer(g).writeVertices(traversal, page != null); + return manager.serializer().writeVertices(traversal, page != null); } finally { if (g.tx().isOpen()) { g.tx().close(); @@ -365,8 +468,11 @@ public String list(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$owner=$graph $action=vertex_read"}) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex ID") @PathParam("id") String idValue) { LOG.debug("Graph [{}] get vertex by id '{}'", graph, idValue); @@ -374,7 +480,7 @@ public String get(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); try { Vertex vertex = g.vertex(id); - return manager.serializer(g).writeVertex(vertex); + return manager.serializer().writeVertex(vertex); } finally { if (g.tx().isOpen()) { g.tx().close(); @@ -388,9 +494,13 @@ public String get(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @RolesAllowed({"space_member", "$owner=$graph $action=vertex_delete"}) public void delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex ID") @PathParam("id") String idValue, + @Parameter(description = "The vertex label (used to verify vertex identity)") @QueryParam("label") String label) { LOG.debug("Graph [{}] remove vertex by id '{}'", graph, idValue); @@ -469,10 +579,13 @@ private static Id getVertexId(HugeGraph g, JsonVertex vertex) { private static class BatchVertexRequest { + @Schema(description = "List of vertices to be created or updated", required = true) @JsonProperty("vertices") public List jsonVertices; + @Schema(description = "Update strategies for each property key", required = true) @JsonProperty("update_strategies") public Map updateStrategies; + @Schema(description = "Whether to create vertex if it does not exist") @JsonProperty("create_if_not_exist") public boolean createIfNotExist = true; diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinAPI.java index 110a3ef5b8..c1701ea943 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinAPI.java @@ -25,6 +25,7 @@ import com.codahale.metrics.Histogram; import com.codahale.metrics.annotation.Timed; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -55,6 +56,7 @@ public class GremlinAPI extends GremlinQueryAPI { @Produces(APPLICATION_JSON_WITH_CHARSET) public Response post(@Context HugeConfig conf, @Context HttpHeaders headers, + @Parameter(description = "The Gremlin query request body") String request) { /* The following code is reserved for forwarding request */ // context.getRequestDispatcher(location).forward(request, response); diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinQueryAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinQueryAPI.java index 1f35da5f1c..2ab55f584a 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinQueryAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/gremlin/GremlinQueryAPI.java @@ -43,7 +43,8 @@ public class GremlinQueryAPI extends API { "java.util.concurrent.TimeoutException", "groovy.lang.", "org.codehaus.", - "org.apache.hugegraph." + "org.apache.hugegraph.", + "org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException" ); @Context diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/AlgorithmAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/AlgorithmAPI.java index 82c0611f5f..79933bc371 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/AlgorithmAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/AlgorithmAPI.java @@ -36,6 +36,7 @@ import com.codahale.metrics.annotation.Timed; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -61,9 +62,13 @@ public class AlgorithmAPI extends API { @Produces(APPLICATION_JSON_WITH_CHARSET) @RedirectFilter.RedirectMasterRole public Map post(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The algorithm name") @PathParam("name") String algorithm, + @Parameter(description = "The algorithm parameters") Map parameters) { LOG.debug("Graph [{}] schedule algorithm job: {}", graph, parameters); E.checkArgument(algorithm != null && !algorithm.isEmpty(), diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/ComputerAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/ComputerAPI.java index 3e88f8ccb6..d5188385cc 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/ComputerAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/ComputerAPI.java @@ -36,6 +36,7 @@ import com.codahale.metrics.annotation.Timed; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -61,9 +62,13 @@ public class ComputerAPI extends API { @Produces(APPLICATION_JSON_WITH_CHARSET) @RedirectFilter.RedirectMasterRole public Map post(@Context GraphManager manager, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The computer name") @PathParam("name") String computer, + @Parameter(description = "The computer parameters") Map parameters) { LOG.debug("Graph [{}] schedule computer job: {}", graph, parameters); E.checkArgument(computer != null && !computer.isEmpty(), diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/GremlinAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/GremlinAPI.java index 2b28364b26..779cf19b66 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/GremlinAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/GremlinAPI.java @@ -46,6 +46,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -77,8 +79,11 @@ public class GremlinAPI extends API { "$action=gremlin_execute"}) @RedirectFilter.RedirectMasterRole public Map post(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The Gremlin job request") GremlinRequest request) { LOG.debug("Graph [{}] schedule gremlin job: {}", graph, request); checkCreatingBody(request); @@ -99,12 +104,16 @@ public static class GremlinRequest implements Checkable { // See org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer @JsonProperty + @Schema(description = "The Gremlin script to execute", required = true) private String gremlin; @JsonProperty + @Schema(description = "The bindings for the Gremlin script") private Map bindings = new HashMap<>(); @JsonProperty + @Schema(description = "The language of the Gremlin script", example = "gremlin-groovy") private String language = "gremlin-groovy"; @JsonProperty + @Schema(description = "The aliases for graph references") private Map aliases = new HashMap<>(); public String gremlin() { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/RebuildAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/RebuildAPI.java index 35e0d2cadc..3219c8b3ab 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/RebuildAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/RebuildAPI.java @@ -31,6 +31,7 @@ import com.codahale.metrics.annotation.Timed; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -56,9 +57,12 @@ public class RebuildAPI extends API { "$action=index_label_write"}) @RedirectFilter.RedirectMasterRole public Map vertexLabelRebuild(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex label to rebuild") @PathParam("name") String name) { LOG.debug("Graph [{}] rebuild vertex label: {}", graph, name); @@ -75,9 +79,12 @@ public Map vertexLabelRebuild(@Context GraphManager manager, @RolesAllowed({"space", "$graphspace=$graphspace $owner=$graph " + "$action=index_label_write"}) public Map edgeLabelRebuild(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The edge label name to rebuild") @PathParam("name") String name) { LOG.debug("Graph [{}] rebuild edge label: {}", graph, name); @@ -95,9 +102,12 @@ public Map edgeLabelRebuild(@Context GraphManager manager, "$action=index_label_write"}) @RedirectFilter.RedirectMasterRole public Map indexLabelRebuild(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The index label name to rebuild") @PathParam("name") String name) { LOG.debug("Graph [{}] rebuild index label: {}", graph, name); diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/TaskAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/TaskAPI.java index 151d3356e8..d35cc9a955 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/TaskAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/job/TaskAPI.java @@ -41,6 +41,7 @@ import com.codahale.metrics.annotation.Timed; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.BadRequestException; @@ -69,12 +70,18 @@ public class TaskAPI extends API { @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public Map list(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The task status to filter") @QueryParam("status") String status, + @Parameter(description = "The task ids to filter") @QueryParam("ids") List ids, + @Parameter(description = "The maximum number of tasks") @QueryParam("limit") @DefaultValue("100") long limit, + @Parameter(description = "The page token for pagination") @QueryParam("page") String page) { LOG.debug("Graph [{}] list tasks with status {}, ids {}, " + "limit {}, page {}", graph, status, ids, limit, page); @@ -124,8 +131,11 @@ public Map list(@Context GraphManager manager, @Path("{id}") @Produces(APPLICATION_JSON_WITH_CHARSET) public Map get(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The task id") @PathParam("id") long id) { LOG.debug("Graph [{}] get task: {}", graph, id); @@ -139,9 +149,13 @@ public Map get(@Context GraphManager manager, @Path("{id}") @RedirectFilter.RedirectMasterRole public void delete(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The task id") @PathParam("id") long id, + @Parameter(description = "Force delete the task even if it's running") @DefaultValue("false") @QueryParam("force") boolean force) { LOG.debug("Graph [{}] delete task: {}", graph, id); @@ -158,10 +172,14 @@ public void delete(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RedirectFilter.RedirectMasterRole public Map update(@Context GraphManager manager, + @Parameter(description = "The graphspace name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The task id") @PathParam("id") long id, + @Parameter(description = "The action to perform on the task") @QueryParam("action") String action) { LOG.debug("Graph [{}] cancel task: {}", graph, id); diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/metrics/MetricsAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/metrics/MetricsAPI.java index c6c6e8c962..b457b66bfc 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/metrics/MetricsAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/metrics/MetricsAPI.java @@ -71,6 +71,7 @@ import com.codahale.metrics.annotation.Timed; import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -193,6 +194,8 @@ public String timers() { @RolesAllowed({"space", "$owner= $action=metrics_read"}) @Operation(summary = "get all base metrics") public String all(@Context GraphManager manager, + @Parameter(description = "Output format type: 'json' for JSON format, " + + "other values for Prometheus format") @QueryParam("type") String type) { if (type != null && type.equals(JSON_STR)) { return baseMetricAll(); @@ -207,7 +210,9 @@ public String all(@Context GraphManager manager, @Produces(APPLICATION_TEXT_WITH_CHARSET) @RolesAllowed({"space", "$owner= $action=metrics_read"}) @Operation(summary = "get all statistics metrics") - public String statistics(@QueryParam("type") String type) { + public String statistics( + @Parameter(description = "Output format type: 'json' for JSON format") + @QueryParam("type") String type) { Map> metricMap = statistics(); if (type != null && type.equals(JSON_STR)) { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java index aef06dca9b..9316d7341b 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java @@ -29,6 +29,7 @@ import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter; import org.apache.hugegraph.auth.HugeAuthenticator.RequiredPerm; +import org.apache.hugegraph.auth.HugeGraphAuthProxy; import org.apache.hugegraph.auth.HugePermission; import org.apache.hugegraph.config.HugeConfig; import org.apache.hugegraph.core.GraphManager; @@ -44,6 +45,7 @@ import com.codahale.metrics.annotation.Timed; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -87,6 +89,7 @@ private static Map convConfig(Map config) { @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$dynamic"}) public Object list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, @Context SecurityContext sc) { LOG.debug("List graphs in graph space {}", graphSpace); @@ -95,13 +98,13 @@ public Object list(@Context GraphManager manager, } Set graphs = manager.graphs(graphSpace); LOG.debug("Get graphs list from graph manager with size {}", - graphs.size()); + graphs.size()); // Filter by user role Set filterGraphs = new HashSet<>(); for (String graph : graphs) { LOG.debug("Get graph {} and verify auth", graph); String role = RequiredPerm.roleFor(graphSpace, graph, - HugePermission.READ); + HugePermission.READ); if (sc.isUserInRole(role)) { try { graph(manager, graphSpace, graph); @@ -123,12 +126,14 @@ public Object list(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$owner=$name"}) public Object get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name) { LOG.debug("Get graph by name '{}'", name); HugeGraph g = graph(manager, graphSpace, name); - return ImmutableMap.of("name", g.spaceGraphName(), "backend", g.backend()); + return ImmutableMap.of("name", g.name(), "backend", g.backend()); } @DELETE @@ -137,8 +142,11 @@ public Object get(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space"}) public void drop(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name, + @Parameter(description = "Confirmation message to drop the graph") @QueryParam("confirm_message") String message) { LOG.debug("Drop graph by name '{}'", name); @@ -153,12 +161,14 @@ public void drop(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"analyst"}) public Object reload(@Context GraphManager manager, + @Parameter( + description = "The action map containing 'action'='reload'") Map actionMap) { LOG.info("[SERVER] Manage graph with action map {}", actionMap); E.checkArgument(actionMap != null && actionMap.containsKey(GRAPH_ACTION), - "Please pass '%s' for graphs manage", GRAPH_ACTION); + "Please pass '%s' for graphs manage", GRAPH_ACTION); String action = actionMap.get(GRAPH_ACTION); if (action.equals(GRAPH_ACTION_RELOAD)) { manager.reload(); @@ -176,12 +186,19 @@ public Object reload(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space"}) public Object create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name to create") @PathParam("name") String name, + @Parameter(description = "The graph name to clone from (optional)") @QueryParam("clone_graph_name") String clone, + @Parameter( + description = "The graph configuration options including " + + "'backend', 'serializer', 'store' and optionally " + + "'description'") Map configs) { LOG.debug("Create graph {} with config options '{}' in " + - "graph space '{}'", name, configs, graphSpace); + "graph space '{}'", name, configs, graphSpace); GraphSpace gs = manager.graphSpace(graphSpace); HugeGraph graph; E.checkArgumentNotNull(gs, "Not existed graph space: '%s'", graphSpace); @@ -198,8 +215,7 @@ public Object create(@Context GraphManager manager, } } - // todo: auth get actual user info - String creator = "admin"; + String creator = HugeGraphAuthProxy.username(); if (StringUtils.isNotEmpty(clone)) { // Clone from existing graph @@ -208,18 +224,18 @@ public Object create(@Context GraphManager manager, } else { // Create new graph graph = manager.createGraph(graphSpace, name, creator, - convConfig(configs), true); + convConfig(configs), true); } String description = (String) configs.get(GRAPH_DESCRIPTION); if (description == null) { description = Strings.EMPTY; } - Object result = ImmutableMap.of("name", graph.spaceGraphName(), - "nickname", graph.nickname(), - "backend", graph.backend(), - "description", description); + Object result = ImmutableMap.of("name", graph.name(), + "nickname", graph.nickname(), + "backend", graph.backend(), + "description", description); LOG.info("user [{}] create graph [{}] in graph space [{}] with config " + - "[{}]", creator, name, graphSpace, configs); + "[{}]", creator, name, graphSpace, configs); return result; } @@ -229,7 +245,9 @@ public Object create(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space"}) public File getConf(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name) { LOG.debug("Get graph configuration by name '{}'", name); @@ -250,8 +268,12 @@ public File getConf(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @RolesAllowed({"space"}) public void clear(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name, + @Parameter(description = "Confirmation message to clear all data, must be: " + + CONFIRM_CLEAR) @QueryParam("confirm_message") String message) { LOG.debug("Clear graph by name '{}'", name); @@ -267,7 +289,9 @@ public void clear(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space", "$owner=$name"}) public Object createSnapshot(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name) { LOG.debug("Create snapshot for graph '{}'", name); @@ -282,7 +306,9 @@ public Object createSnapshot(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space", "$owner=$name"}) public Object resumeSnapshot(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name) { LOG.debug("Resume snapshot for graph '{}'", name); @@ -298,7 +324,9 @@ public Object resumeSnapshot(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space"}) public String compact(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name) { LOG.debug("Manually compact graph '{}'", name); @@ -313,7 +341,9 @@ public String compact(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space", "$owner=$name"}) public Map mode(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name, GraphMode mode) { LOG.debug("Set mode to: '{}' of graph '{}'", mode, name); @@ -347,7 +377,9 @@ public Map mode(@Context GraphManager manager, @RolesAllowed({"space"}) public Map graphReadMode( @Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("name") String name, GraphReadMode readMode) { LOG.debug("Set graph-read-mode to: '{}' of graph '{}'", @@ -357,7 +389,7 @@ public Map graphReadMode( "Graph-read-mode can't be null"); E.checkArgument(readMode == GraphReadMode.ALL || readMode == GraphReadMode.OLTP_ONLY, - "Graph-read-mode could be ALL or OLTP_ONLY"); + "Graph-read-mode could be ALL or OLTP_ONLY"); HugeGraph g = graph(manager, graphSpace, name); manager.graphReadMode(graphSpace, name, readMode); g.readMode(readMode); diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/WhiteIpListAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/WhiteIpListAPI.java index e965ed21a9..a0ee5af9cb 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/WhiteIpListAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/WhiteIpListAPI.java @@ -38,6 +38,7 @@ import com.google.common.collect.ImmutableMap; import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -139,6 +140,9 @@ public Map updateWhiteIPs(@Context GraphManager manager, @RolesAllowed("admin") @Operation(summary = "enable/disable the white ip list") public Map updateStatus(@Context GraphManager manager, + @Parameter(description = "Status to set: " + + "'true' to enable, " + + "'false' to disable") @QueryParam("status") String status) { LOG.debug("Enable or disable white ip list"); E.checkArgument("true".equals(status) || diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/raft/RaftAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/raft/RaftAPI.java index c981858be0..f868df522e 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/raft/RaftAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/raft/RaftAPI.java @@ -40,6 +40,7 @@ import com.codahale.metrics.annotation.Timed; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -67,8 +68,11 @@ public class RaftAPI extends API { @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member"}) public Map> listPeers(@Context GraphManager manager, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The raft group name") @QueryParam("group") @DefaultValue("default") String group) { @@ -87,8 +91,11 @@ public Map> listPeers(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member"}) public Map getLeader(@Context GraphManager manager, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The raft group name") @QueryParam("group") @DefaultValue("default") String group) { @@ -108,11 +115,15 @@ public Map getLeader(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member"}) public Map transferLeader(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The raft group name") @QueryParam("group") @DefaultValue("default") String group, + @Parameter(description = "The endpoint address") @QueryParam("endpoint") String endpoint) { LOG.debug("Graph [{}] prepare to transfer leader to: {}", @@ -133,11 +144,17 @@ public Map transferLeader(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member"}) public Map setLeader(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The raft group name") @QueryParam("group") @DefaultValue("default") String group, + @Parameter( + description = "The endpoint address to set as " + + "leader") @QueryParam("endpoint") String endpoint) { LOG.debug("Graph [{}] prepare to set leader to: {}", @@ -158,10 +175,15 @@ public Map setLeader(@Context GraphManager manager, @RolesAllowed({"space_member"}) @RedirectFilter.RedirectMasterRole public Map addPeer(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The raft group name") @QueryParam("group") @DefaultValue("default") String group, + @Parameter( + description = "The endpoint address of the peer to add") @QueryParam("endpoint") String endpoint) { LOG.debug("Graph [{}] prepare to add peer: {}", graph, endpoint); @@ -189,10 +211,16 @@ public Map addPeer(@Context GraphManager manager, @RolesAllowed({"space_member"}) @RedirectFilter.RedirectMasterRole public Map removePeer(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The raft group name") @QueryParam("group") @DefaultValue("default") String group, + @Parameter( + description = "The endpoint address of the peer to " + + "remove") @QueryParam("endpoint") String endpoint) { LOG.debug("Graph [{}] prepare to remove peer: {}", graph, endpoint); diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/EdgeLabelAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/EdgeLabelAPI.java index 09d7fe542e..f2026d58bd 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/EdgeLabelAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/EdgeLabelAPI.java @@ -45,6 +45,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -75,7 +77,9 @@ public class EdgeLabelAPI extends API { "$action=edge_label_write"}) @RedirectFilter.RedirectMasterRole public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, JsonEdgeLabel jsonEdgeLabel) { LOG.debug("Graph [{}] create edge label: {}", graph, jsonEdgeLabel); @@ -84,7 +88,7 @@ public String create(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); EdgeLabel.Builder builder = jsonEdgeLabel.convert2Builder(g); EdgeLabel edgeLabel = builder.create(); - return manager.serializer(g).writeEdgeLabel(edgeLabel); + return manager.serializer().writeEdgeLabel(edgeLabel); } @PUT @@ -96,9 +100,13 @@ public String create(@Context GraphManager manager, "$action=edge_label_write"}) @RedirectFilter.RedirectMasterRole public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The edge label name") @PathParam("name") String name, + @Parameter(description = "Action to perform: 'append' or 'remove'") @QueryParam("action") String action, JsonEdgeLabel jsonEdgeLabel) { LOG.debug("Graph [{}] {} edge label: {}", @@ -114,7 +122,7 @@ public String update(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); EdgeLabel.Builder builder = jsonEdgeLabel.convert2Builder(g); EdgeLabel edgeLabel = append ? builder.append() : builder.eliminate(); - return manager.serializer(g).writeEdgeLabel(edgeLabel); + return manager.serializer().writeEdgeLabel(edgeLabel); } @GET @@ -123,8 +131,11 @@ public String update(@Context GraphManager manager, @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + "$action=edge_label_read"}) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "Filter edge labels by names") @QueryParam("names") List names) { boolean listAll = CollectionUtils.isEmpty(names); if (listAll) { @@ -143,7 +154,7 @@ public String list(@Context GraphManager manager, labels.add(g.schema().getEdgeLabel(name)); } } - return manager.serializer(g).writeEdgeLabels(labels); + return manager.serializer().writeEdgeLabels(labels); } @GET @@ -153,14 +164,17 @@ public String list(@Context GraphManager manager, @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + "$action=edge_label_read"}) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The edge label name") @PathParam("name") String name) { LOG.debug("Graph [{}] get edge label by name '{}'", graph, name); HugeGraph g = graph(manager, graphSpace, graph); EdgeLabel edgeLabel = g.schema().getEdgeLabel(name); - return manager.serializer(g).writeEdgeLabel(edgeLabel); + return manager.serializer().writeEdgeLabel(edgeLabel); } @DELETE @@ -173,8 +187,11 @@ public String get(@Context GraphManager manager, "$action=edge_label_delete"}) @RedirectFilter.RedirectMasterRole public Map delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The edge label name to delete") @PathParam("name") String name) { LOG.debug("Graph [{}] remove edge label by name '{}'", graph, name); @@ -189,38 +206,55 @@ public Map delete(@Context GraphManager manager, * JsonEdgeLabel is only used to receive create and append requests */ @JsonIgnoreProperties(value = {"index_labels", "status"}) + @Schema(description = "Edge label creation/update request") private static class JsonEdgeLabel implements Checkable { + @Schema(description = "The edge label ID (only used in RESTORING mode)") @JsonProperty("id") public long id; + @Schema(description = "The edge label name", required = true) @JsonProperty("name") public String name; + @Schema(description = "The edge label type: NORMAL, EDGE, or RELATION") @JsonProperty("edgelabel_type") public EdgeLabelType edgeLabelType; + @Schema(description = "The parent edge label name (for inheritance)") @JsonProperty("parent_label") public String fatherLabel; + @Schema(description = "The source vertex label name", required = true) @JsonProperty("source_label") public String sourceLabel; + @Schema(description = "The target vertex label name", required = true) @JsonProperty("target_label") public String targetLabel; + @Schema(description = "Links between source and target vertex labels") @JsonProperty("links") public Set> links; + @Schema(description = "The frequency: NORMAL or ONE_DAILY") @JsonProperty("frequency") public Frequency frequency; + @Schema(description = "The property key names associated with this edge label") @JsonProperty("properties") public String[] properties; + @Schema(description = "The sort key names for edge properties") @JsonProperty("sort_keys") public String[] sortKeys; + @Schema(description = "The nullable property key names") @JsonProperty("nullable_keys") public String[] nullableKeys; + @Schema(description = "Time-to-live in seconds") @JsonProperty("ttl") public long ttl; + @Schema(description = "The property key name to use as TTL start time") @JsonProperty("ttl_start_time") public String ttlStartTime; + @Schema(description = "Whether to enable label indexing") @JsonProperty("enable_label_index") public Boolean enableLabelIndex; + @Schema(description = "User-defined metadata") @JsonProperty("user_data") public Userdata userdata; + @Schema(description = "Whether to check if edge label exists before creation") @JsonProperty("check_exist") public Boolean checkExist; diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/IndexLabelAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/IndexLabelAPI.java index 77a28b08a8..ec0e3a37eb 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/IndexLabelAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/IndexLabelAPI.java @@ -45,6 +45,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -75,7 +77,9 @@ public class IndexLabelAPI extends API { "$action=index_label_write"}) @RedirectFilter.RedirectMasterRole public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, JsonIndexLabel jsonIndexLabel) { LOG.debug("Graph [{}] create index label: {}", graph, jsonIndexLabel); @@ -85,7 +89,7 @@ public String create(@Context GraphManager manager, IndexLabel.Builder builder = jsonIndexLabel.convert2Builder(g); SchemaElement.TaskWithSchema il = builder.createWithTask(); il.indexLabel(mapIndexLabel(il.indexLabel())); - return manager.serializer(g).writeTaskWithSchema(il); + return manager.serializer().writeTaskWithSchema(il); } @PUT @@ -95,9 +99,13 @@ public String create(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RedirectFilter.RedirectMasterRole public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The index label name") @PathParam("name") String name, + @Parameter(description = "Action to perform: 'append' or 'remove'") @QueryParam("action") String action, IndexLabelAPI.JsonIndexLabel jsonIndexLabel) { LOG.debug("Graph [{}] {} index label: {}", @@ -112,7 +120,7 @@ public String update(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); IndexLabel.Builder builder = jsonIndexLabel.convert2Builder(g); IndexLabel indexLabel = append ? builder.append() : builder.eliminate(); - return manager.serializer(g).writeIndexlabel(mapIndexLabel(indexLabel)); + return manager.serializer().writeIndexlabel(mapIndexLabel(indexLabel)); } @GET @@ -121,8 +129,11 @@ public String update(@Context GraphManager manager, @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + "$action=index_label_read"}) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "Filter index labels by names") @QueryParam("names") List names) { boolean listAll = CollectionUtils.isEmpty(names); if (listAll) { @@ -141,7 +152,7 @@ public String list(@Context GraphManager manager, labels.add(g.schema().getIndexLabel(name)); } } - return manager.serializer(g).writeIndexlabels(mapIndexLabels(labels)); + return manager.serializer().writeIndexlabels(mapIndexLabels(labels)); } @GET @@ -151,14 +162,17 @@ public String list(@Context GraphManager manager, @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + "$action=index_label_read"}) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The index label name") @PathParam("name") String name) { LOG.debug("Graph [{}] get index label by name '{}'", graph, name); HugeGraph g = graph(manager, graphSpace, graph); IndexLabel indexLabel = g.schema().getIndexLabel(name); - return manager.serializer(g).writeIndexlabel(mapIndexLabel(indexLabel)); + return manager.serializer().writeIndexlabel(mapIndexLabel(indexLabel)); } @DELETE @@ -171,8 +185,11 @@ public String get(@Context GraphManager manager, "$action=index_label_delete"}) @RedirectFilter.RedirectMasterRole public Map delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The index label name to delete") @PathParam("name") String name) { LOG.debug("Graph [{}] remove index label by name '{}'", graph, name); @@ -206,24 +223,34 @@ private static IndexLabel mapIndexLabel(IndexLabel label) { * JsonIndexLabel is only used to receive create and append requests */ @JsonIgnoreProperties(value = {"status"}) + @Schema(description = "Index label creation/update request") private static class JsonIndexLabel implements Checkable { + @Schema(description = "The index label ID (only used in RESTORING mode)") @JsonProperty("id") public long id; + @Schema(description = "The index label name", required = true) @JsonProperty("name") public String name; + @Schema(description = "The base type: VERTEX or EDGE", required = true) @JsonProperty("base_type") public HugeType baseType; + @Schema(description = "The base label name (vertex/edge label name)", required = true) @JsonProperty("base_value") public String baseValue; + @Schema(description = "The index type: SECONDARY, RANGE, SEARCH, or VECTOR") @JsonProperty("index_type") public IndexType indexType; + @Schema(description = "The property key names to build index on", required = true) @JsonProperty("fields") public String[] fields; + @Schema(description = "User-defined metadata") @JsonProperty("user_data") public Userdata userdata; + @Schema(description = "Whether to check if index label exists before creation") @JsonProperty("check_exist") public Boolean checkExist; + @Schema(description = "Whether to rebuild the index after creation") @JsonProperty("rebuild") public Boolean rebuild; diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/PropertyKeyAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/PropertyKeyAPI.java index c95e25339a..27d6ab1da2 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/PropertyKeyAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/PropertyKeyAPI.java @@ -48,6 +48,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -75,10 +77,12 @@ public class PropertyKeyAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=property_key_write"}) + "$action=property_key_write"}) @RedirectFilter.RedirectMasterRole public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, JsonPropertyKey jsonPropertyKey) { LOG.debug("Graph [{}] create property key: {}", graph, jsonPropertyKey); @@ -87,7 +91,7 @@ public String create(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); PropertyKey.Builder builder = jsonPropertyKey.convert2Builder(g); SchemaElement.TaskWithSchema pk = builder.createWithTask(); - return manager.serializer(g).writeTaskWithSchema(pk); + return manager.serializer().writeTaskWithSchema(pk); } @PUT @@ -97,12 +101,20 @@ public String create(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=property_key_write"}) + "$action=property_key_write"}) @RedirectFilter.RedirectMasterRole public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The property key name") @PathParam("name") String name, + @Parameter( + description = + "Action to perform: 'append' to add new properties, " + + "'remove' to delete existing properties, " + + "'clear' to clear OLAP property data") @QueryParam("action") String action, PropertyKeyAPI.JsonPropertyKey jsonPropertyKey) { LOG.debug("Graph [{}] {} property key: {}", @@ -121,7 +133,7 @@ public String update(@Context GraphManager manager, Id id = g.clearPropertyKey(propertyKey); SchemaElement.TaskWithSchema pk = new SchemaElement.TaskWithSchema(propertyKey, id); - return manager.serializer(g).writeTaskWithSchema(pk); + return manager.serializer().writeTaskWithSchema(pk); } // Parse action parameter @@ -133,17 +145,20 @@ public String update(@Context GraphManager manager, builder.eliminate(); SchemaElement.TaskWithSchema pk = new SchemaElement.TaskWithSchema(propertyKey, IdGenerator.ZERO); - return manager.serializer(g).writeTaskWithSchema(pk); + return manager.serializer().writeTaskWithSchema(pk); } @GET @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=property_key_read"}) + "$action=property_key_read"}) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "Filter property keys by names") @QueryParam("names") List names) { boolean listAll = CollectionUtils.isEmpty(names); if (listAll) { @@ -162,7 +177,7 @@ public String list(@Context GraphManager manager, propKeys.add(g.schema().getPropertyKey(name)); } } - return manager.serializer(g).writePropertyKeys(propKeys); + return manager.serializer().writePropertyKeys(propKeys); } @GET @@ -170,7 +185,7 @@ public String list(@Context GraphManager manager, @Path("{name}") @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=property_key_read"}) + "$action=property_key_read"}) public String get(@Context GraphManager manager, @PathParam("graphspace") String graphSpace, @PathParam("graph") String graph, @@ -179,7 +194,7 @@ public String get(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); PropertyKey propertyKey = g.schema().getPropertyKey(name); - return manager.serializer(g).writePropertyKey(propertyKey); + return manager.serializer().writePropertyKey(propertyKey); } @DELETE @@ -189,11 +204,14 @@ public String get(@Context GraphManager manager, @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + - "$action=property_key_delete"}) + "$action=property_key_delete"}) @RedirectFilter.RedirectMasterRole public Map delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The property key name to delete") @PathParam("name") String name) { LOG.debug("Graph [{}] remove property key by name '{}'", graph, name); @@ -208,24 +226,36 @@ public Map delete(@Context GraphManager manager, * JsonPropertyKey is only used to receive create and append requests */ @JsonIgnoreProperties(value = {"status"}) + @Schema(description = "Property key creation/update request") private static class JsonPropertyKey implements Checkable { + @Schema(description = "The property key ID (only used in RESTORING mode)") @JsonProperty("id") public long id; + @Schema(description = "The property key name", required = true) @JsonProperty("name") public String name; + @Schema(description = "The cardinality: SINGLE, LIST, or SET") @JsonProperty("cardinality") public Cardinality cardinality; + @Schema(description = "The data type: STRING, TEXT, INT, LONG, FLOAT, " + + "DOUBLE, BLOB, BOOLEAN, DATE, UUID") @JsonProperty("data_type") public DataType dataType; + @Schema(description = "The aggregate type: NONE, SUM, MAX, MIN, SUB, " + + "SET, INC, BIGDECIMAL") @JsonProperty("aggregate_type") public AggregateType aggregateType; + @Schema(description = "The write type: OLTP, OLAP, IMMUTABLE") @JsonProperty("write_type") public WriteType writeType; + @Schema(description = "Parent property keys for meta property") @JsonProperty("properties") public String[] properties; + @Schema(description = "User-defined metadata") @JsonProperty("user_data") public Userdata userdata; + @Schema(description = "Whether to check if property key exists before creation") @JsonProperty("check_exist") public Boolean checkExist; diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/SchemaAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/SchemaAPI.java index 0fb0b1cd15..07968925e7 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/SchemaAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/SchemaAPI.java @@ -65,6 +65,6 @@ public String list(@Context GraphManager manager, schemaMap.put("edgelabels", schema.getEdgeLabels()); schemaMap.put("indexlabels", schema.getIndexLabels()); - return manager.serializer(g).writeMap(schemaMap); + return manager.serializer().writeMap(schemaMap); } } diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/VertexLabelAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/VertexLabelAPI.java index a845be7a66..c86622f7e5 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/VertexLabelAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/schema/VertexLabelAPI.java @@ -43,6 +43,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -73,7 +75,9 @@ public class VertexLabelAPI extends API { "$action=vertex_label_write"}) @RedirectFilter.RedirectMasterRole public String create(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, JsonVertexLabel jsonVertexLabel) { LOG.debug("Graph [{}] create vertex label: {}", @@ -83,7 +87,7 @@ public String create(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); VertexLabel.Builder builder = jsonVertexLabel.convert2Builder(g); VertexLabel vertexLabel = builder.create(); - return manager.serializer(g).writeVertexLabel(vertexLabel); + return manager.serializer().writeVertexLabel(vertexLabel); } @PUT @@ -95,9 +99,13 @@ public String create(@Context GraphManager manager, "$action=vertex_label_write"}) @RedirectFilter.RedirectMasterRole public String update(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex label name") @PathParam("name") String name, + @Parameter(description = "Action to perform: 'append' or 'remove'") @QueryParam("action") String action, JsonVertexLabel jsonVertexLabel) { LOG.debug("Graph [{}] {} vertex label: {}", @@ -115,7 +123,7 @@ public String update(@Context GraphManager manager, VertexLabel vertexLabel = append ? builder.append() : builder.eliminate(); - return manager.serializer(g).writeVertexLabel(vertexLabel); + return manager.serializer().writeVertexLabel(vertexLabel); } @GET @@ -124,8 +132,11 @@ public String update(@Context GraphManager manager, @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + "$action=vertex_label_read"}) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "Filter vertex labels by names") @QueryParam("names") List names) { boolean listAll = CollectionUtils.isEmpty(names); if (listAll) { @@ -144,7 +155,7 @@ public String list(@Context GraphManager manager, labels.add(g.schema().getVertexLabel(name)); } } - return manager.serializer(g).writeVertexLabels(labels); + return manager.serializer().writeVertexLabels(labels); } @GET @@ -154,14 +165,17 @@ public String list(@Context GraphManager manager, @RolesAllowed({"space_member", "$graphspace=$graphspace $owner=$graph " + "$action=vertex_label_read"}) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex label name") @PathParam("name") String name) { LOG.debug("Graph [{}] get vertex label by name '{}'", graph, name); HugeGraph g = graph(manager, graphSpace, graph); VertexLabel vertexLabel = g.schema().getVertexLabel(name); - return manager.serializer(g).writeVertexLabel(vertexLabel); + return manager.serializer().writeVertexLabel(vertexLabel); } @DELETE @@ -174,8 +188,11 @@ public String get(@Context GraphManager manager, "$action=vertex_label_delete"}) @RedirectFilter.RedirectMasterRole public Map delete(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex label name to delete") @PathParam("name") String name) { LOG.debug("Graph [{}] remove vertex label by name '{}'", graph, name); @@ -190,28 +207,41 @@ public Map delete(@Context GraphManager manager, * JsonVertexLabel is only used to receive create and append requests */ @JsonIgnoreProperties(value = {"index_labels", "status"}) + @Schema(description = "Vertex label creation/update request") private static class JsonVertexLabel implements Checkable { + @Schema(description = "The vertex label ID (only used in RESTORING mode)") @JsonProperty("id") public long id; + @Schema(description = "The vertex label name", required = true) @JsonProperty("name") public String name; + @Schema(description = "The ID strategy: AUTOMATIC, PRIMARY_KEY, " + + "CUSTOMIZE_STRING, CUSTOMIZE_NUMBER, CUSTOMIZE_UUID") @JsonProperty("id_strategy") public IdStrategy idStrategy; + @Schema(description = "The property key names associated with this vertex label") @JsonProperty("properties") public String[] properties; + @Schema(description = "The primary key names (used with PRIMARY_KEY strategy)") @JsonProperty("primary_keys") public String[] primaryKeys; + @Schema(description = "The nullable property key names") @JsonProperty("nullable_keys") public String[] nullableKeys; + @Schema(description = "Time-to-live in seconds") @JsonProperty("ttl") public long ttl; + @Schema(description = "The property key name to use as TTL start time") @JsonProperty("ttl_start_time") public String ttlStartTime; + @Schema(description = "Whether to enable label indexing") @JsonProperty("enable_label_index") public Boolean enableLabelIndex; + @Schema(description = "User-defined metadata") @JsonProperty("user_data") public Userdata userdata; + @Schema(description = "Whether to check if vertex label exists before creation") @JsonProperty("check_exist") public Boolean checkExist; diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java index c4f604aac9..35bc40aed0 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java @@ -19,6 +19,9 @@ package org.apache.hugegraph.api.space; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import java.util.Set; @@ -26,6 +29,8 @@ import org.apache.commons.lang.StringUtils; import org.apache.hugegraph.api.API; import org.apache.hugegraph.api.filter.StatusFilter.Status; +import org.apache.hugegraph.auth.AuthManager; +import org.apache.hugegraph.auth.HugeGraphAuthProxy; import org.apache.hugegraph.core.GraphManager; import org.apache.hugegraph.define.Checkable; import org.apache.hugegraph.exception.NotFoundException; @@ -40,6 +45,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Singleton; @@ -51,6 +58,7 @@ import jakarta.ws.rs.Path; import jakarta.ws.rs.PathParam; import jakarta.ws.rs.Produces; +import jakarta.ws.rs.QueryParam; import jakarta.ws.rs.core.Context; import jakarta.ws.rs.core.SecurityContext; @@ -70,6 +78,7 @@ public class GraphSpaceAPI extends API { @Produces(APPLICATION_JSON_WITH_CHARSET) public Object list(@Context GraphManager manager, @Context SecurityContext sc) { + ensurePdModeEnabled(manager); Set spaces = manager.graphSpaces(); return ImmutableMap.of("graphSpaces", spaces); } @@ -79,7 +88,9 @@ public Object list(@Context GraphManager manager, @Path("{graphspace}") @Produces(APPLICATION_JSON_WITH_CHARSET) public Object get(@Context GraphManager manager, + @Parameter(description = "The name of the graph space") @PathParam("graphspace") String graphSpace) { + ensurePdModeEnabled(manager); manager.getSpaceStorage(graphSpace); GraphSpace gs = space(manager, graphSpace); @@ -92,6 +103,58 @@ public Object get(@Context GraphManager manager, return gsInfo; } + @GET + @Timed + @Path("profile") + @Produces(APPLICATION_JSON_WITH_CHARSET) + @RolesAllowed({"admin"}) + public Object listProfile(@Context GraphManager manager, + @Parameter(description = "Filter graph spaces by " + + "name or nickname prefix") + @QueryParam("prefix") String prefix, + @Context SecurityContext sc) { + ensurePdModeEnabled(manager); + Set spaces = manager.graphSpaces(); + List> spaceList = new ArrayList<>(); + List> result = new ArrayList<>(); + String user = HugeGraphAuthProxy.username(); + AuthManager authManager = manager.authManager(); + // FIXME: defaultSpace related interface is not implemented + // String defaultSpace = authManager.getDefaultSpace(user); + SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); + for (String sp : spaces) { + manager.getSpaceStorage(sp); + GraphSpace gs = space(manager, sp); + Map gsProfile = gs.info(); + boolean isManager = verifyPermission(user, authManager, sp); + + // 设置当前用户的是否允许访问该空间 + if (gs.auth() && !isManager) { + gsProfile.put("authed", false); + } else { + gsProfile.put("authed", true); + } + + gsProfile.put("create_time", format.format(gs.createTime())); + gsProfile.put("update_time", format.format(gs.updateTime())); + if (!isPrefix(gsProfile, prefix)) { + continue; + } + + gsProfile.put("default", false); + result.add(gsProfile); + //boolean defaulted = StringUtils.equals(sp, defaultSpace); + //gsProfile.put("default", defaulted); + //if (defaulted) { + // result.add(gsProfile); + //} else { + // spaceList.add(gsProfile); + //} + } + result.addAll(spaceList); + return result; + } + @POST @Timed @Status(Status.CREATED) @@ -100,10 +163,10 @@ public Object get(@Context GraphManager manager, @RolesAllowed({"admin"}) public String create(@Context GraphManager manager, JsonGraphSpace jsonGraphSpace) { - + ensurePdModeEnabled(manager); jsonGraphSpace.checkCreate(false); - String creator = "admin"; + String creator = HugeGraphAuthProxy.username(); GraphSpace exist = manager.graphSpace(jsonGraphSpace.name); E.checkArgument(exist == null, "The graph space '%s' has existed", jsonGraphSpace.name); @@ -129,9 +192,10 @@ public boolean isPrefix(Map profile, String prefix) { @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"admin"}) public Map manage(@Context GraphManager manager, + @Parameter(description = "The name of the graph space") @PathParam("name") String name, Map actionMap) { - + ensurePdModeEnabled(manager); E.checkArgument(actionMap != null && actionMap.size() == 2 && actionMap.containsKey(GRAPH_SPACE_ACTION), "Invalid request body '%s'", actionMap); @@ -259,7 +323,9 @@ public Map manage(@Context GraphManager manager, @Produces(APPLICATION_JSON_WITH_CHARSET) @RolesAllowed({"admin"}) public void delete(@Context GraphManager manager, + @Parameter(description = "The name of the graph space") @PathParam("name") String name) { + ensurePdModeEnabled(manager); manager.dropGraphSpace(name); } @@ -274,54 +340,79 @@ private String getDpUserName(String graphSpace) { "_dp" : graphSpace.toLowerCase() + "_dp"; } + private boolean verifyPermission(String user, AuthManager authManager, String graphSpace) { + return authManager.isAdminManager(user) || + authManager.isSpaceManager(graphSpace, user) || + authManager.isSpaceMember(graphSpace, user); + } + private static class JsonGraphSpace implements Checkable { @JsonProperty("name") + @Schema(description = "The name of the graph space", required = true) public String name; @JsonProperty("nickname") + @Schema(description = "The nickname of the graph space") public String nickname; @JsonProperty("description") + @Schema(description = "The description of the graph space") public String description; @JsonProperty("cpu_limit") + @Schema(description = "The CPU limit for the graph space", required = true) public int cpuLimit; @JsonProperty("memory_limit") + @Schema(description = "The memory limit for the graph space", required = true) public int memoryLimit; @JsonProperty("storage_limit") + @Schema(description = "The storage limit for the graph space", required = true) public int storageLimit; @JsonProperty("compute_cpu_limit") + @Schema(description = "The compute CPU limit for the graph space") public int computeCpuLimit = 0; @JsonProperty("compute_memory_limit") + @Schema(description = "The compute memory limit for the graph space") public int computeMemoryLimit = 0; @JsonProperty("oltp_namespace") + @Schema(description = "The OLTP namespace for the graph space") public String oltpNamespace = ""; @JsonProperty("olap_namespace") + @Schema(description = "The OLAP namespace for the graph space") public String olapNamespace = ""; @JsonProperty("storage_namespace") + @Schema(description = "The storage namespace for the graph space") public String storageNamespace = ""; @JsonProperty("max_graph_number") + @Schema(description = "The maximum number of graphs allowed in the space", required = true) public int maxGraphNumber; @JsonProperty("max_role_number") + @Schema(description = "The maximum number of roles allowed in the space") public int maxRoleNumber; @JsonProperty("dp_username") + @Schema(description = "The data platform username for the graph space") public String dpUserName; @JsonProperty("dp_password") + @Schema(description = "The data platform password for the graph space") public String dpPassWord; @JsonProperty("auth") + @Schema(description = "Whether authentication is enabled for the graph space") public boolean auth = false; @JsonProperty("configs") + @Schema(description = "Additional configurations for the graph space") public Map configs; @JsonProperty("operator_image_path") + @Schema(description = "The operator image path for the graph space") public String operatorImagePath = ""; @JsonProperty("internal_algorithm_image_url") + @Schema(description = "The internal algorithm image URL for the graph space") public String internalAlgorithmImageUrl = ""; @Override @@ -397,10 +488,13 @@ public String toString() { private static class JsonDefaultRole implements Checkable { @JsonProperty("user") + @Schema(description = "The username") private String user; @JsonProperty("role") + @Schema(description = "The role name") private String role; @JsonProperty("graph") + @Schema(description = "The graph name") private String graph; @Override diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/AllShortestPathsAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/AllShortestPathsAPI.java index beefdea25b..3880b1239e 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/AllShortestPathsAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/AllShortestPathsAPI.java @@ -41,6 +41,7 @@ import com.codahale.metrics.annotation.Timed; import com.google.common.collect.ImmutableList; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.DefaultValue; @@ -62,21 +63,33 @@ public class AllShortestPathsAPI extends API { @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The source vertex ID") @QueryParam("source") String source, + @Parameter(description = "The target vertex ID") @QueryParam("target") String target, + @Parameter(description = "The direction of traversal") @QueryParam("direction") String direction, + @Parameter(description = "The edge label to traverse") @QueryParam("label") String edgeLabel, + @Parameter(description = "The maximum depth of traversal") @QueryParam("max_depth") int depth, + @Parameter(description = "The maximum degree of vertices") @QueryParam("max_degree") @DefaultValue(DEFAULT_MAX_DEGREE) long maxDegree, + @Parameter(description = "The degree to skip") @QueryParam("skip_degree") @DefaultValue("0") long skipDegree, + @Parameter(description = "Whether to include vertex details") @QueryParam("with_vertex") @DefaultValue("false") boolean withVertex, + @Parameter(description = "Whether to include edge details") @QueryParam("with_edge") @DefaultValue("false") boolean withEdge, + @Parameter(description = "The capacity of the traversal") @QueryParam("capacity") @DefaultValue(DEFAULT_CAPACITY) long capacity) { LOG.debug("Graph [{}] get shortest path from '{}', to '{}' with " + diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/CountAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/CountAPI.java index 6e4a1fe177..7dd58dd892 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/CountAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/CountAPI.java @@ -42,6 +42,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.POST; @@ -61,7 +63,9 @@ public class CountAPI extends API { @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String post(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, CountRequest request) { LOG.debug("Graph [{}] get count from '{}' with request {}", @@ -85,7 +89,7 @@ public String post(@Context GraphManager manager, long count = traverser.count(sourceId, steps, request.containsTraversed, request.dedupSize); - return manager.serializer(g).writeMap(ImmutableMap.of("count", count)); + return manager.serializer().writeMap(ImmutableMap.of("count", count)); } private static List steps(HugeGraph graph, CountRequest request) { @@ -100,12 +104,16 @@ private static List steps(HugeGraph graph, CountRequest request) { private static class CountRequest { @JsonProperty("source") + @Schema(description = "The source vertex ID", required = true) public Object source; @JsonProperty("steps") + @Schema(description = "The steps to traverse", required = true) public List steps; @JsonProperty("contains_traversed") + @Schema(description = "Whether to include traversed vertices") public boolean containsTraversed = false; @JsonProperty("dedup_size") + @Schema(description = "The deduplication size limit") public long dedupSize = 1000000L; @Override @@ -120,15 +128,20 @@ public String toString() { private static class Step { @JsonProperty("direction") + @Schema(description = "The direction of traversal", example = "BOTH") public Directions direction = Directions.BOTH; @JsonProperty("labels") + @Schema(description = "The edge labels to traverse") public List labels; @JsonProperty("properties") + @Schema(description = "The properties to filter edges") public Map properties; @JsonAlias("degree") @JsonProperty("max_degree") + @Schema(description = "The maximum degree of vertices to traverse") public long maxDegree = Long.parseLong(DEFAULT_MAX_DEGREE); @JsonProperty("skip_degree") + @Schema(description = "The degree to skip when traversing") public long skipDegree = Long.parseLong(DEFAULT_SKIP_DEGREE); @Override diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/EdgesAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/EdgesAPI.java index 4aea4fb1b6..807fcce92c 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/EdgesAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/EdgesAPI.java @@ -38,6 +38,7 @@ import com.codahale.metrics.annotation.Timed; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.DefaultValue; @@ -76,7 +77,7 @@ public String list(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); Iterator edges = g.edges(ids); - return manager.serializer(g).writeEdges(edges, false); + return manager.serializer().writeEdges(edges, false); } @GET @@ -87,13 +88,14 @@ public String list(@Context GraphManager manager, public String shards(@Context GraphManager manager, @PathParam("graphspace") String graphSpace, @PathParam("graph") String graph, + @Parameter(description = "The split size for shards") @QueryParam("split_size") long splitSize) { LOG.debug("Graph [{}] get vertex shards with split size '{}'", graph, splitSize); HugeGraph g = graph(manager, graphSpace, graph); List shards = g.metadata(HugeType.EDGE_OUT, "splits", splitSize); - return manager.serializer(g).writeList("shards", shards); + return manager.serializer().writeList("shards", shards); } @GET @@ -122,6 +124,6 @@ public String scan(@Context GraphManager manager, } Iterator edges = g.edges(query); - return manager.serializer(g).writeEdges(edges, query.paging()); + return manager.serializer().writeEdges(edges, query.paging()); } } diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KneighborAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KneighborAPI.java index 3912d9c764..83183d08c5 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KneighborAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KneighborAPI.java @@ -50,6 +50,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -73,16 +74,25 @@ public class KneighborAPI extends TraverserAPI { @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The source vertex ID") @QueryParam("source") String sourceV, + @Parameter(description = "The direction of traversal") @QueryParam("direction") String direction, + @Parameter(description = "The edge label to traverse") @QueryParam("label") String edgeLabel, + @Parameter(description = "The maximum depth of traversal") @QueryParam("max_depth") int depth, + @Parameter(description = "Whether to return only count") @QueryParam("count_only") @DefaultValue("false") boolean countOnly, + @Parameter(description = "The maximum degree of vertices") @QueryParam("max_degree") @DefaultValue(DEFAULT_MAX_DEGREE) long maxDegree, + @Parameter(description = "The maximum number of results") @QueryParam("limit") @DefaultValue(DEFAULT_ELEMENTS_LIMIT) int limit) { LOG.debug("Graph [{}] get k-neighbor from '{}' with " + diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KoutAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KoutAPI.java index 2a0e29662f..e784e38b40 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KoutAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/KoutAPI.java @@ -50,6 +50,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -73,20 +74,31 @@ public class KoutAPI extends TraverserAPI { @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The source vertex ID") @QueryParam("source") String source, + @Parameter(description = "The direction of traversal") @QueryParam("direction") String direction, + @Parameter(description = "The edge label to traverse") @QueryParam("label") String edgeLabel, + @Parameter(description = "The maximum depth of traversal") @QueryParam("max_depth") int depth, + @Parameter(description = "Whether to find nearest vertices first") @QueryParam("nearest") @DefaultValue("true") boolean nearest, + @Parameter(description = "Whether to return only count") @QueryParam("count_only") @DefaultValue("false") boolean count_only, + @Parameter(description = "The maximum degree of vertices") @QueryParam("max_degree") @DefaultValue(DEFAULT_MAX_DEGREE) long maxDegree, + @Parameter(description = "The capacity of the traversal") @QueryParam("capacity") @DefaultValue(DEFAULT_CAPACITY) long capacity, + @Parameter(description = "The maximum number of results") @QueryParam("limit") @DefaultValue(DEFAULT_ELEMENTS_LIMIT) int limit) { LOG.debug("Graph [{}] get k-out from '{}' with " + diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/NeighborRankAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/NeighborRankAPI.java index dbefbad558..08396aa0b3 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/NeighborRankAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/NeighborRankAPI.java @@ -87,7 +87,7 @@ public String neighborRank(@Context GraphManager manager, traverser = new NeighborRankTraverser(g, request.alpha, request.capacity); List> ranks = traverser.neighborRank(sourceId, steps); - return manager.serializer(g).writeList("ranks", ranks); + return manager.serializer().writeList("ranks", ranks); } private static List steps(HugeGraph graph, diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/PersonalRankAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/PersonalRankAPI.java index c2b2db514c..45393e2a2b 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/PersonalRankAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/PersonalRankAPI.java @@ -102,7 +102,7 @@ public String personalRank(@Context GraphManager manager, Map ranks = traverser.personalRank(sourceId, request.label, request.withLabel); ranks = HugeTraverser.topN(ranks, request.sorted, request.limit); - return manager.serializer(g).writeMap(ranks); + return manager.serializer().writeMap(ranks); } private static class RankRequest { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/ShortestPathAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/ShortestPathAPI.java index e53d7a7d1b..6a6ecd2317 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/ShortestPathAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/ShortestPathAPI.java @@ -41,6 +41,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.DefaultValue; @@ -62,21 +63,33 @@ public class ShortestPathAPI extends API { @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The source vertex ID") @QueryParam("source") String source, + @Parameter(description = "The target vertex ID") @QueryParam("target") String target, + @Parameter(description = "The direction of traversal") @QueryParam("direction") String direction, + @Parameter(description = "The edge label to traverse") @QueryParam("label") String edgeLabel, + @Parameter(description = "The maximum depth of traversal") @QueryParam("max_depth") int depth, + @Parameter(description = "The maximum degree of vertices") @QueryParam("max_degree") @DefaultValue(DEFAULT_MAX_DEGREE) long maxDegree, + @Parameter(description = "The degree to skip") @QueryParam("skip_degree") @DefaultValue("0") long skipDegree, + @Parameter(description = "Whether to include vertex details") @QueryParam("with_vertex") @DefaultValue("false") boolean withVertex, + @Parameter(description = "Whether to include edge details") @QueryParam("with_edge") @DefaultValue("false") boolean withEdge, + @Parameter(description = "The capacity of the traversal") @QueryParam("capacity") @DefaultValue(DEFAULT_CAPACITY) long capacity) { LOG.debug("Graph [{}] get shortest path from '{}', to '{}' with " + diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/TraverserAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/TraverserAPI.java index 923b3d43fa..28f776a3e6 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/TraverserAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/TraverserAPI.java @@ -32,6 +32,8 @@ import com.fasterxml.jackson.annotation.JsonAlias; import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + public class TraverserAPI extends API { protected static EdgeStep step(HugeGraph graph, Step step) { @@ -61,15 +63,20 @@ protected static Steps steps(HugeGraph graph, VESteps steps) { protected static class Step { @JsonProperty("direction") + @Schema(description = "The direction of traversal", example = "BOTH") public Directions direction; @JsonProperty("labels") + @Schema(description = "The edge labels to traverse") public List labels; @JsonProperty("properties") + @Schema(description = "The properties to filter edges") public Map properties; @JsonAlias("degree") @JsonProperty("max_degree") + @Schema(description = "The maximum degree of vertices to traverse") public long maxDegree = Long.parseLong(DEFAULT_MAX_DEGREE); @JsonProperty("skip_degree") + @Schema(description = "The degree to skip when traversing") public long skipDegree = 0L; @Override @@ -84,9 +91,11 @@ public String toString() { protected static class VEStepEntity { @JsonProperty("label") + @Schema(description = "The label of the step") public String label; @JsonProperty("properties") + @Schema(description = "The properties for the step") public Map properties; @Override @@ -99,15 +108,20 @@ public String toString() { protected static class VESteps { @JsonProperty("direction") + @Schema(description = "The direction of traversal", example = "BOTH") public Directions direction; @JsonAlias("degree") @JsonProperty("max_degree") + @Schema(description = "The maximum degree of vertices to traverse") public long maxDegree = Long.parseLong(DEFAULT_MAX_DEGREE); @JsonProperty("skip_degree") + @Schema(description = "The degree to skip when traversing") public long skipDegree = 0L; @JsonProperty("vertex_steps") + @Schema(description = "The vertex steps in the traversal") public List vSteps; @JsonProperty("edge_steps") + @Schema(description = "The edge steps in the traversal") public List eSteps; @Override diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/Vertices.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/Vertices.java index d5be694893..3efee83ab2 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/Vertices.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/Vertices.java @@ -36,13 +36,18 @@ import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; + public class Vertices { @JsonProperty("ids") + @Schema(description = "The vertex IDs", example = "[\"1:Tom\", \"2:Mary\"]") public Set ids; @JsonProperty("label") + @Schema(description = "The vertex label", example = "person") public String label; @JsonProperty("properties") + @Schema(description = "The vertex properties in key-value format") public Map properties; public Iterator vertices(HugeGraph g) { diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/VerticesAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/VerticesAPI.java index 4963b87dba..2f853ec352 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/VerticesAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/VerticesAPI.java @@ -38,6 +38,7 @@ import com.codahale.metrics.annotation.Timed; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.DefaultValue; @@ -60,8 +61,11 @@ public class VerticesAPI extends API { @Compress @Produces(APPLICATION_JSON_WITH_CHARSET) public String list(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The vertex IDs") @QueryParam("ids") List stringIds) { LOG.debug("Graph [{}] get vertices by ids: {}", graph, stringIds); @@ -76,7 +80,7 @@ public String list(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); Iterator vertices = g.vertices(ids); - return manager.serializer(g).writeVertices(vertices, false); + return manager.serializer().writeVertices(vertices, false); } @GET @@ -93,7 +97,7 @@ public String shards(@Context GraphManager manager, HugeGraph g = graph(manager, graphSpace, graph); List shards = g.metadata(HugeType.VERTEX, "splits", splitSize); - return manager.serializer(g).writeList("shards", shards); + return manager.serializer().writeList("shards", shards); } @GET @@ -122,6 +126,6 @@ public String scan(@Context GraphManager manager, } Iterator vertices = g.vertices(query); - return manager.serializer(g).writeVertices(vertices, query.paging()); + return manager.serializer().writeVertices(vertices, query.paging()); } } diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/WeightedShortestPathAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/WeightedShortestPathAPI.java index 3cea3702db..e705bfba09 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/WeightedShortestPathAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/traversers/WeightedShortestPathAPI.java @@ -41,6 +41,7 @@ import com.codahale.metrics.annotation.Timed; +import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.DefaultValue; @@ -62,21 +63,32 @@ public class WeightedShortestPathAPI extends API { @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public String get(@Context GraphManager manager, + @Parameter(description = "The graph space name") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The graph name") @PathParam("graph") String graph, + @Parameter(description = "The source vertex ID") @QueryParam("source") String source, + @Parameter(description = "The target vertex ID") @QueryParam("target") String target, + @Parameter(description = "The direction of traversal") @QueryParam("direction") String direction, + @Parameter(description = "The edge label to traverse") @QueryParam("label") String edgeLabel, + @Parameter(description = "The weight property name") @QueryParam("weight") String weight, + @Parameter(description = "The maximum degree of vertices") @QueryParam("max_degree") @DefaultValue(DEFAULT_MAX_DEGREE) long maxDegree, - @QueryParam("skip_degree") + @Parameter(description = "The degree to skip") @QueryParam("skip_degree") @DefaultValue("0") long skipDegree, + @Parameter(description = "Whether to include vertex details") @QueryParam("with_vertex") @DefaultValue("false") boolean withVertex, + @Parameter(description = "Whether to include edge details") @QueryParam("with_edge") @DefaultValue("false") boolean withEdge, + @Parameter(description = "The capacity of the traversal") @QueryParam("capacity") @DefaultValue(DEFAULT_CAPACITY) long capacity) { LOG.debug("Graph [{}] get weighted shortest path between '{}' and " + diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/variables/VariablesAPI.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/variables/VariablesAPI.java index 0d878d9262..680c42c7e3 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/variables/VariablesAPI.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/variables/VariablesAPI.java @@ -30,6 +30,8 @@ import com.codahale.metrics.annotation.Timed; import com.google.common.collect.ImmutableMap; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.inject.Singleton; import jakarta.ws.rs.Consumes; @@ -55,8 +57,11 @@ public class VariablesAPI extends API { @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON_WITH_CHARSET) public Map update(@Context GraphManager manager, + @Parameter(description = "The name of the graph space") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The name of the graph") @PathParam("graph") String graph, + @Parameter(description = "The key of the variable") @PathParam("key") String key, JsonVariableValue value) { E.checkArgument(value != null && value.data != null, @@ -72,7 +77,9 @@ public Map update(@Context GraphManager manager, @Timed @Produces(APPLICATION_JSON_WITH_CHARSET) public Map list(@Context GraphManager manager, + @Parameter(description = "The name of the graph space") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The name of the graph") @PathParam("graph") String graph) { LOG.debug("Graph [{}] get variables", graph); @@ -85,8 +92,11 @@ public Map list(@Context GraphManager manager, @Path("{key}") @Produces(APPLICATION_JSON_WITH_CHARSET) public Map get(@Context GraphManager manager, + @Parameter(description = "The name of the graph space") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The name of the graph") @PathParam("graph") String graph, + @Parameter(description = "The key of the variable") @PathParam("key") String key) { LOG.debug("Graph [{}] get variable by key '{}'", graph, key); @@ -104,8 +114,11 @@ public Map get(@Context GraphManager manager, @Path("{key}") @Consumes(APPLICATION_JSON) public void delete(@Context GraphManager manager, + @Parameter(description = "The name of the graph space") @PathParam("graphspace") String graphSpace, + @Parameter(description = "The name of the graph") @PathParam("graph") String graph, + @Parameter(description = "The key of the variable") @PathParam("key") String key) { LOG.debug("Graph [{}] remove variable by key '{}'", graph, key); @@ -115,6 +128,7 @@ public void delete(@Context GraphManager manager, private static class JsonVariableValue { + @Schema(description = "The value of the variable", required = true) public Object data; @Override diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/ConfigAuthenticator.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/ConfigAuthenticator.java deleted file mode 100644 index eaad573d5e..0000000000 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/ConfigAuthenticator.java +++ /dev/null @@ -1,111 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hugegraph.auth; - -import java.net.InetAddress; -import java.util.HashMap; -import java.util.Map; -import java.util.Objects; - -import org.apache.commons.lang.NotImplementedException; -import org.apache.hugegraph.HugeGraph; -import org.apache.hugegraph.backend.id.IdGenerator; -import org.apache.hugegraph.config.HugeConfig; -import org.apache.hugegraph.config.ServerOptions; -import org.apache.hugegraph.util.E; -import org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential.CredentialGraphTokens; - -import jakarta.ws.rs.core.SecurityContext; - -public class ConfigAuthenticator implements HugeAuthenticator { - - public static final String KEY_USERNAME = CredentialGraphTokens.PROPERTY_USERNAME; - public static final String KEY_PASSWORD = CredentialGraphTokens.PROPERTY_PASSWORD; - - private final Map tokens; - - public ConfigAuthenticator() { - this.tokens = new HashMap<>(); - } - - @Override - public void setup(HugeConfig config) { - this.tokens.putAll(config.getMap(ServerOptions.AUTH_USER_TOKENS)); - assert !this.tokens.containsKey(USER_ADMIN); - this.tokens.put(USER_ADMIN, config.get(ServerOptions.AUTH_ADMIN_TOKEN)); - } - - /** - * Verify if a user is legal - * - * @param username the username for authentication - * @param password the password for authentication - * @return String No permission if return ROLE_NONE else return a role - */ - @Override - public UserWithRole authenticate(final String username, - final String password, - final String token) { - E.checkArgumentNotNull(username, - "The username parameter can't be null"); - E.checkArgumentNotNull(password, - "The password parameter can't be null"); - E.checkArgument(token == null, "The token must be null"); - - RolePermission role; - if (password.equals(this.tokens.get(username))) { - if (username.equals(USER_ADMIN)) { - role = ROLE_ADMIN; - } else { - // Return role with all permission, set username as owner graph - role = RolePermission.all(username); - } - } else { - role = ROLE_NONE; - } - - return new UserWithRole(IdGenerator.of(username), username, role); - } - - @Override - public void unauthorize(SecurityContext context) { - } - - @Override - public AuthManager authManager() { - throw new NotImplementedException("AuthManager is unsupported by ConfigAuthenticator"); - } - - @Override - public HugeGraph graph() { - throw new NotImplementedException("graph() is unsupported by ConfigAuthenticator"); - } - - @Override - public void initAdminUser(String password) { - String adminToken = this.tokens.get(USER_ADMIN); - E.checkArgument(Objects.equals(adminToken, password), - "The password can't be changed for " + - "ConfigAuthenticator"); - } - - @Override - public SaslNegotiator newSaslNegotiator(InetAddress remoteAddress) { - throw new NotImplementedException("SaslNegotiator is unsupported by ConfigAuthenticator"); - } -} diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeFactoryAuthProxy.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeFactoryAuthProxy.java index 41e9186d7b..57486a4079 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeFactoryAuthProxy.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeFactoryAuthProxy.java @@ -129,7 +129,6 @@ private static void registerPrivateActions() { Reflection.registerFieldsToFilter(StandardAuthenticator.class, "graph"); Reflection.registerMethodsToFilter(StandardAuthenticator.class, "initAdminUser", "inputPassword", "graph"); - Reflection.registerFieldsToFilter(ConfigAuthenticator.class, "tokens"); Reflection.registerFieldsToFilter(HugeFactoryAuthProxy.class, "PROTECT_METHODS"); Reflection.registerMethodsToFilter(HugeFactoryAuthProxy.class, "genRegisterPrivateActions", "registerClass", "registerPrivateActions", @@ -508,7 +507,6 @@ private static void genRegisterPrivateActions() { registerPrivateActions(InheritableThreadLocal.class); registerPrivateActions(StandardAuthenticator.class); - registerPrivateActions(ConfigAuthenticator.class); registerPrivateActions(HugeFactoryAuthProxy.class); registerPrivateActions(HugeAuthenticator.User.class); diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeGraphAuthProxy.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeGraphAuthProxy.java index a4769bb4da..a414afd711 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeGraphAuthProxy.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeGraphAuthProxy.java @@ -87,6 +87,7 @@ import org.apache.hugegraph.util.E; import org.apache.hugegraph.util.Log; import org.apache.hugegraph.util.RateLimiter; +import org.apache.hugegraph.vector.VectorIndexManager; import org.apache.tinkerpop.gremlin.process.computer.GraphComputer; import org.apache.tinkerpop.gremlin.process.traversal.Bytecode; import org.apache.tinkerpop.gremlin.process.traversal.Bytecode.Instruction; @@ -186,6 +187,7 @@ public static Context setAdmin() { public static Context getContext() { // Return task context first String taskContext = TaskManager.getContext(); + User user = User.fromJson(taskContext); if (user != null) { return new Context(user); @@ -834,6 +836,11 @@ public RaftGroupManager raftGroupManager() { return this.hugegraph.raftGroupManager(); } + @Override + public VectorIndexManager vectorIndexManager() { + return this.hugegraph.vectorIndexManager(); + } + @Override public void registerRpcServices(RpcServiceConfig4Server serverConfig, RpcServiceConfig4Client clientConfig) { @@ -953,6 +960,14 @@ public void updateTime(Date updateTime) { this.hugegraph.updateTime(updateTime); } + public static String username() { + Context context = HugeGraphAuthProxy.getContext(); + if (context == null) { + return "anonymous"; + } + return context.user.username(); + } + private Cache cache(String prefix, long capacity, long expiredTime) { String name = prefix + "-" + this.hugegraph.spaceGraphName(); @@ -1559,7 +1574,6 @@ public List listAllUsers(long limit) { @Override public Id createGroup(HugeGroup group) { this.updateCreator(group); - verifyUserPermission(HugePermission.WRITE, group); this.invalidRoleCache(); return this.authManager.createGroup(group); } @@ -1567,35 +1581,29 @@ public Id createGroup(HugeGroup group) { @Override public Id updateGroup(HugeGroup group) { this.updateCreator(group); - verifyUserPermission(HugePermission.WRITE, group); this.invalidRoleCache(); return this.authManager.updateGroup(group); } @Override public HugeGroup deleteGroup(Id id) { - verifyUserPermission(HugePermission.DELETE, - this.authManager.getGroup(id)); this.invalidRoleCache(); return this.authManager.deleteGroup(id); } @Override public HugeGroup getGroup(Id id) { - return verifyUserPermission(HugePermission.READ, - this.authManager.getGroup(id)); + return this.authManager.getGroup(id); } @Override public List listGroups(List ids) { - return verifyUserPermission(HugePermission.READ, - this.authManager.listGroups(ids)); + return this.authManager.listGroups(ids); } @Override public List listAllGroups(long limit) { - return verifyUserPermission(HugePermission.READ, - this.authManager.listAllGroups(limit)); + return this.authManager.listAllGroups(limit); } @Override diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/config/ServerOptions.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/config/ServerOptions.java index 5a785eef4d..278542854b 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/config/ServerOptions.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/config/ServerOptions.java @@ -32,7 +32,7 @@ public class ServerOptions extends OptionHolder { "The url for listening of graph server.", disallowEmpty(), "http://127.0.0.1:8080" - ); + ).withUrlNormalization("http://"); public static final ConfigOption SERVER_EVENT_HUB_THREADS = new ConfigOption<>( @@ -118,7 +118,7 @@ public class ServerOptions extends OptionHolder { "The url of gremlin server.", disallowEmpty(), "http://127.0.0.1:8182" - ); + ).withUrlNormalization("http://"); public static final ConfigOption GREMLIN_SERVER_TIMEOUT = new ConfigOption<>( @@ -270,7 +270,7 @@ public class ServerOptions extends OptionHolder { "to clients. only used when starting the server in k8s.", disallowEmpty(), "http://0.0.0.0:8080" - ); + ).withUrlNormalization("http://"); public static final ConfigOption SERVER_K8S_URL = new ConfigOption<>( @@ -278,7 +278,7 @@ public class ServerOptions extends OptionHolder { "The url of k8s.", disallowEmpty(), "https://127.0.0.1:8888" - ); + ).withUrlNormalization("https://"); public static final ConfigOption SERVER_K8S_USE_CA = new ConfigOption<>( @@ -389,7 +389,7 @@ public class ServerOptions extends OptionHolder { "batch.max_vertices_per_batch", "The maximum number of vertices submitted per batch.", positiveInt(), - 500 + 2500 ); public static final ConfigOption MAX_EDGES_PER_BATCH = @@ -397,7 +397,7 @@ public class ServerOptions extends OptionHolder { "batch.max_edges_per_batch", "The maximum number of edges submitted per batch.", positiveInt(), - 500 + 2500 ); public static final ConfigOption MAX_WRITE_RATIO = @@ -406,7 +406,7 @@ public class ServerOptions extends OptionHolder { "The maximum thread ratio for batch writing, " + "only take effect if the batch.max_write_threads is 0.", rangeInt(0, 100), - 50 + 70 ); public static final ConfigOption MAX_WRITE_THREADS = @@ -462,8 +462,7 @@ public class ServerOptions extends OptionHolder { new ConfigOption<>( "auth.authenticator", "The class path of authenticator implementation. " + - "e.g., org.apache.hugegraph.auth.StandardAuthenticator, " + - "or org.apache.hugegraph.auth.ConfigAuthenticator.", + "e.g., org.apache.hugegraph.auth.StandardAuthenticator.", null, "" ); @@ -471,31 +470,12 @@ public class ServerOptions extends OptionHolder { public static final ConfigOption ADMIN_PA = new ConfigOption<>( "auth.admin_pa", - "The class path of authenticator implementation. " + - "e.g., org.apache.hugegraph.auth.StandardAuthenticator, " + - "or org.apache.hugegraph.auth.ConfigAuthenticator.", + "The default password for built-in admin account, " + + "takes effect on first startup.", null, "pa" ); - public static final ConfigOption AUTH_ADMIN_TOKEN = - new ConfigOption<>( - "auth.admin_token", - "Token for administrator operations, " + - "only for org.apache.hugegraph.auth.ConfigAuthenticator.", - disallowEmpty(), - "162f7848-0b6d-4faf-b557-3a0797869c55" - ); - - public static final ConfigListOption AUTH_USER_TOKENS = - new ConfigListOption<>( - "auth.user_tokens", - "The map of user tokens with name and password, " + - "only for org.apache.hugegraph.auth.ConfigAuthenticator.", - disallowEmpty(), - "hugegraph:9fd95c9c-711b-415b-b85f-d4df46ba5c31" - ); - public static final ConfigOption SSL_KEYSTORE_FILE = new ConfigOption<>( "ssl.keystore_file", diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java index 24949314a8..770e75cc74 100644 --- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java +++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java @@ -22,6 +22,7 @@ import static org.apache.hugegraph.space.GraphSpace.DEFAULT_GRAPH_SPACE_SERVICE_NAME; import java.io.IOException; +import java.io.StringWriter; import java.text.ParseException; import java.util.Arrays; import java.util.Collections; @@ -275,7 +276,7 @@ private static String serviceId(String graphSpace, Service.ServiceType type, .replace("_", "-").toLowerCase(); } - private boolean usePD() { + public boolean isPDEnabled() { return this.PDExist; } @@ -1226,11 +1227,43 @@ private void dropGraphLocal(HugeGraph graph) { public HugeGraph createGraph(String graphSpace, String name, String creator, Map configs, boolean init) { - if (!usePD()) { - return createGraphLocal(configs.toString(), name); + if (!isPDEnabled()) { + // Extract nickname from configs + String nickname; + if (configs.get("nickname") != null) { + nickname = configs.get("nickname").toString(); + checkNickname(nickname); + } else { + nickname = name; + } + + Date timeStamp = new Date(); + + // Convert Map to Properties format string + PropertiesConfiguration propConfig = new PropertiesConfiguration(); + for (Map.Entry entry : configs.entrySet()) { + propConfig.setProperty(entry.getKey(), entry.getValue()); + } + StringWriter writer = new StringWriter(); + try { + propConfig.write(writer); + } catch (Exception e) { + throw new HugeException("Failed to convert config map to properties", e); + } + + HugeGraph graph = createGraphLocal(name, writer.toString()); + + // Set metadata fields for non-PD mode + graph.nickname(nickname); + graph.creator(creator); + graph.createTime(timeStamp); + graph.updateTime(timeStamp); + + return graph; } - // When the registered graph space is not DEFAULT, only the graphs within that registered graph space are loaded. + // When the registered graph space is not DEFAULT, only the graphs within that registered + // graph space are loaded. if (!"DEFAULT".equals(this.serviceGraphSpace) && !this.serviceGraphSpace.equals(graphSpace)) { throw new HugeException(String.format( @@ -1291,7 +1324,7 @@ public HugeGraph createGraph(String graphSpace, String name, String creator, Date timeStamp = new Date(); - configs.putIfAbsent("nickname", nickname); + // Note: nickname was already extracted and removed from configs earlier configs.putIfAbsent("creator", creator); configs.putIfAbsent("create_time", timeStamp); configs.putIfAbsent("update_time", timeStamp); @@ -1514,7 +1547,7 @@ private void closeTx(final Set graphSourceNamesToCloseTxOn, } private String defaultSpaceGraphName(String graphName) { - return "DEFAULT-" + graphName; + return spaceGraphName("DEFAULT", graphName); } private void loadGraph(String name, String graphConfPath) { @@ -1578,9 +1611,9 @@ private void checkBackendVersionOrExit(HugeConfig config) { if (!hugegraph.backendStoreFeatures().supportsPersistence()) { hugegraph.initBackend(); if (this.requireAuthentication()) { - String token = config.get(ServerOptions.AUTH_ADMIN_TOKEN); + String adminPassword = config.get(ServerOptions.ADMIN_PA); try { - this.authenticator().initAdminUser(token); + this.authenticator().initAdminUser(adminPassword); } catch (Exception e) { throw new BackendException( "The backend store of '%s' can't " + @@ -1904,7 +1937,7 @@ public Set getServiceUrls(String graphSpace, String service, public HugeGraph graph(String graphSpace, String name) { String key = String.join(DELIMITER, graphSpace, name); Graph graph = this.graphs.get(key); - if (graph == null && usePD()) { + if (graph == null && isPDEnabled()) { Map> configs = this.metaManager.graphConfigs(graphSpace); // If current server registered graph space is not DEFAULT, only load graph creation @@ -1931,7 +1964,7 @@ public HugeGraph graph(String graphSpace, String name) { } public void dropGraphLocal(String name) { - HugeGraph graph = this.graph(name); + HugeGraph graph = this.graph(DEFAULT_GRAPH_SPACE_SERVICE_NAME + "-" + name); E.checkArgument(this.conf.get(ServerOptions.ENABLE_DYNAMIC_CREATE_DROP), "Not allowed to drop graph '%s' dynamically, " + "please set `enable_dynamic_create_drop` to true.", @@ -1948,7 +1981,7 @@ public void dropGraphLocal(String name) { } public void dropGraph(String graphSpace, String name, boolean clear) { - if (!usePD()) { + if (!isPDEnabled()) { dropGraphLocal(name); return; } @@ -2052,6 +2085,17 @@ private void checkOptionsUnique(String graphSpace, public Set graphs(String graphSpace) { Set graphs = new HashSet<>(); + + if (!isPDEnabled()) { + for (String key : this.graphs.keySet()) { + String[] parts = key.split(DELIMITER); + if (parts[0].equals(graphSpace)) { + graphs.add(parts[1]); + } + } + return graphs; + } + for (String key : this.metaManager.graphConfigs(graphSpace).keySet()) { graphs.add(key.split(DELIMITER)[1]); } @@ -2059,7 +2103,7 @@ public Set graphs(String graphSpace) { } public GraphSpace graphSpace(String name) { - if (!usePD()) { + if (!isPDEnabled()) { return new GraphSpace("DEFAULT"); } GraphSpace space = this.graphSpaces.get(name); @@ -2107,6 +2151,13 @@ private MapConfiguration buildConfig(Map configs) { public void graphReadMode(String graphSpace, String graphName, GraphReadMode readMode) { + + if (!isPDEnabled()) { + HugeGraph g = this.graph(spaceGraphName(graphSpace, graphName)); + g.readMode(readMode); + return; + } + try { Map configs = this.metaManager.getGraphConfig(graphSpace, graphName); diff --git a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraOptions.java b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraOptions.java index a9ccf97765..6cb3b41389 100644 --- a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraOptions.java +++ b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraOptions.java @@ -130,4 +130,47 @@ public static synchronized CassandraOptions instance() { positiveInt(), 12 * 60 * 60 ); + + public static final ConfigOption CASSANDRA_RECONNECT_BASE_DELAY = + new ConfigOption<>( + "cassandra.reconnect_base_delay", + "The base delay in milliseconds used by the driver's " + + "exponential reconnection policy when a Cassandra host " + + "becomes unreachable.", + rangeInt(100L, Long.MAX_VALUE), + 1000L + ); + + public static final ConfigOption CASSANDRA_RECONNECT_MAX_DELAY = + new ConfigOption<>( + "cassandra.reconnect_max_delay", + "The maximum delay in milliseconds used by the driver's " + + "exponential reconnection policy when a Cassandra host " + + "becomes unreachable.", + rangeInt(1000L, Long.MAX_VALUE), + 10_000L + ); + + public static final ConfigOption CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS = + new ConfigOption<>( + "cassandra.query_retry_max_attempts", + "The maximum number of retry attempts applied at query-time when " + + "a Cassandra host is temporarily unreachable. " + + "OperationTimedOutException is retried only for " + + "idempotent statements. " + + "Set to 0 to disable query-time retries.", + rangeInt(0, Integer.MAX_VALUE), + 3 + ); + + public static final ConfigOption CASSANDRA_QUERY_RETRY_INTERVAL = + new ConfigOption<>( + "cassandra.query_retry_interval", + "The interval in milliseconds between query-time retries " + + "when a Cassandra host is temporarily unreachable. The " + + "actual wait grows with exponential backoff, capped at " + + "cassandra.reconnect_max_delay.", + rangeInt(100L, Long.MAX_VALUE), + 1000L + ); } diff --git a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSerializer.java b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSerializer.java index fc3c499a81..f2d4474daf 100644 --- a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSerializer.java +++ b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSerializer.java @@ -24,10 +24,13 @@ import java.util.Map; import java.util.Set; +import org.apache.commons.lang.NotImplementedException; +import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.backend.BackendException; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.backend.id.IdUtil; +import org.apache.hugegraph.backend.query.ConditionQuery; import org.apache.hugegraph.backend.serializer.BytesBuffer; import org.apache.hugegraph.backend.serializer.TableBackendEntry; import org.apache.hugegraph.backend.serializer.TableSerializer; @@ -38,6 +41,7 @@ import org.apache.hugegraph.structure.HugeElement; import org.apache.hugegraph.structure.HugeIndex; import org.apache.hugegraph.structure.HugeProperty; +import org.apache.hugegraph.structure.HugeVectorIndexMap; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.DataType; @@ -166,6 +170,17 @@ public BackendEntry writeOlapVertex(HugeVertex vertex) { return entry; } + @Override + public BackendEntry writeVectorSequence(HugeVectorIndexMap indexMap) { + throw new NotImplementedException("Unsupported writeVectorSequence()"); + } + + @Override + public HugeVectorIndexMap readVectorSequence(HugeGraph graph, ConditionQuery query, + BackendEntry entry) { + throw new NotImplementedException("Unsupported readVectorSequence()"); + } + @Override protected Object writeProperty(PropertyKey propertyKey, Object value) { BytesBuffer buffer = BytesBuffer.allocate(BytesBuffer.BUF_PROPERTY); diff --git a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSessionPool.java b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSessionPool.java index 7a9ffa2b91..a217d53444 100644 --- a/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSessionPool.java +++ b/hugegraph-server/hugegraph-cassandra/src/main/java/org/apache/hugegraph/backend/store/cassandra/CassandraSessionPool.java @@ -20,12 +20,15 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; import org.apache.hugegraph.backend.BackendException; import org.apache.hugegraph.backend.store.BackendSession.AbstractBackendSession; import org.apache.hugegraph.backend.store.BackendSessionPool; import org.apache.hugegraph.config.HugeConfig; import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; import com.datastax.driver.core.BatchStatement; import com.datastax.driver.core.Cluster; @@ -34,22 +37,67 @@ import com.datastax.driver.core.ProtocolOptions.Compression; import com.datastax.driver.core.ResultSet; import com.datastax.driver.core.ResultSetFuture; +import com.datastax.driver.core.SimpleStatement; import com.datastax.driver.core.SocketOptions; import com.datastax.driver.core.Statement; +import com.datastax.driver.core.exceptions.DriverException; import com.datastax.driver.core.exceptions.InvalidQueryException; +import com.datastax.driver.core.exceptions.NoHostAvailableException; +import com.datastax.driver.core.exceptions.OperationTimedOutException; +import com.datastax.driver.core.policies.ExponentialReconnectionPolicy; public class CassandraSessionPool extends BackendSessionPool { + private static final Logger LOG = Log.logger(CassandraSessionPool.class); + private static final int SECOND = 1000; + private static final String HEALTH_CHECK_CQL = + "SELECT now() FROM system.local"; + + /** + * Guards the one-time JVM-wide warning about {@code commitAsync()} not + * being covered by query-time retries. {@link CassandraSessionPool} is + * instantiated once per backend store per graph, so without this guard + * the warning would fire many times on startup for a structural + * limitation that does not change between instances. + */ + private static final AtomicBoolean ASYNC_RETRY_WARNING_LOGGED = + new AtomicBoolean(false); private Cluster cluster; private final String keyspace; + private final int maxRetries; + private final long retryInterval; + private final long retryBaseDelay; + private final long retryMaxDelay; public CassandraSessionPool(HugeConfig config, String keyspace, String store) { super(config, keyspace + "/" + store); this.cluster = null; this.keyspace = keyspace; + this.maxRetries = config.get( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS); + this.retryInterval = config.get( + CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL); + long reconnectBase = config.get( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY); + long reconnectMax = config.get( + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY); + E.checkArgument(reconnectMax >= reconnectBase, + "'%s' (%s) must be >= '%s' (%s)", + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY.name(), + reconnectMax, + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(), + reconnectBase); + this.retryBaseDelay = reconnectBase; + this.retryMaxDelay = reconnectMax; + + if (this.maxRetries > 0 && + ASYNC_RETRY_WARNING_LOGGED.compareAndSet(false, true)) { + LOG.warn("cassandra.query_retry_max_attempts={} applies to sync commit()" + + " only. commitAsync() has no retry protection.", this.maxRetries); + } } @Override @@ -86,6 +134,12 @@ public synchronized void open() { builder.withSocketOptions(socketOptions); + // Reconnection policy: let driver keep retrying nodes in background + // with exponential backoff after they go down (see issue #2740). + builder.withReconnectionPolicy( + new ExponentialReconnectionPolicy(this.retryBaseDelay, + this.retryMaxDelay)); + // Credential options String username = config.get(CassandraOptions.CASSANDRA_USERNAME); String password = config.get(CassandraOptions.CASSANDRA_PASSWORD); @@ -161,7 +215,7 @@ public void rollback() { @Override public ResultSet commit() { - ResultSet rs = this.session.execute(this.batch); + ResultSet rs = this.executeWithRetry(this.batch); // Clear batch if execute() successfully (retained if failed) this.batch.clear(); return rs; @@ -169,12 +223,25 @@ public ResultSet commit() { public void commitAsync() { Collection statements = this.batch.getStatements(); + if (statements.isEmpty()) { + this.batch.clear(); + return; + } int count = 0; int processors = Math.min(statements.size(), 1023); List results = new ArrayList<>(processors + 1); + com.datastax.driver.core.Session driverSession = + this.sessionForAsyncCommit(); for (Statement s : statements) { - ResultSetFuture future = this.session.executeAsync(s); + // TODO: track async retry support in a follow-up issue. + // commitAsync() bypasses executeWithRetry(). + // During a Cassandra restart, async writes may fail with + // NoHostAvailableException even when maxRetries > 0. Callers + // must handle ResultSetFuture failures surfaced by + // getUninterruptibly(). A follow-up issue should wrap each + // future with retry semantics. + ResultSetFuture future = driverSession.executeAsync(s); results.add(future); if (++count > processors) { @@ -197,15 +264,99 @@ public ResultSet query(Statement statement) { } public ResultSet execute(Statement statement) { - return this.session.execute(statement); + return this.executeWithRetry(statement); } public ResultSet execute(String statement) { - return this.session.execute(statement); + return this.executeWithRetry(new SimpleStatement(statement)); } public ResultSet execute(String statement, Object... args) { - return this.session.execute(statement, args); + return this.executeWithRetry(new SimpleStatement(statement, args)); + } + + /** + * Execute a statement, retrying on transient connectivity failures + * (NoHostAvailableException / OperationTimedOutException). The driver + * itself keeps retrying connections in the background via the + * reconnection policy, so once Cassandra comes back online, a + * subsequent attempt here will succeed without restarting the server. + * + *

      OperationTimedOutException is only retried for statements marked + * idempotent; otherwise a timed-out mutation might be applied once by + * Cassandra and then duplicated by a client-side retry. + * + *

      If the driver session has been discarded (e.g. by + * {@link #reconnectIfNeeded()} after a failed health-check) it is + * lazily reopened at the start of each attempt. + * + *

      Blocking note: retries block the calling thread via + * {@link Thread#sleep(long)}. Worst-case a single call blocks for + * {@code maxRetries * retryMaxDelay} ms. Under high-throughput + * workloads concurrent threads may pile up in {@code sleep()} during + * a Cassandra outage. For such deployments lower + * {@code cassandra.query_retry_max_attempts} (default 3) and + * {@code cassandra.reconnect_max_delay} (default 10000ms) so the + * request fails fast and pressure is released back to the caller. + */ + private ResultSet executeWithRetry(Statement statement) { + int retries = CassandraSessionPool.this.maxRetries; + long interval = CassandraSessionPool.this.retryInterval; + long maxDelay = CassandraSessionPool.this.retryMaxDelay; + DriverException lastError = null; + for (int attempt = 0; attempt <= retries; attempt++) { + try { + if (this.session == null || this.session.isClosed()) { + // Lazy reopen: may itself throw NHAE while + // Cassandra is still unreachable; the catch below + // treats that as a transient failure. + this.session = null; + this.open(); + } + return this.session.execute(statement); + } catch (NoHostAvailableException | OperationTimedOutException e) { + lastError = e; + if (e instanceof OperationTimedOutException && + !Boolean.TRUE.equals(statement.isIdempotent())) { + throw new BackendException( + "Cassandra query timed out and won't be " + + "retried because the statement is not " + + "marked idempotent", e); + } + if (attempt >= retries) { + break; + } + long cap = maxDelay > 0 ? maxDelay : interval; + long shift = 1L << Math.min(attempt, 20); + long delay; + try { + // Guard against Long overflow when retryInterval is huge. + delay = Math.min(Math.multiplyExact(interval, shift), cap); + } catch (ArithmeticException overflow) { + delay = cap; + } + LOG.warn("Cassandra temporarily unavailable ({}), " + + "retry {}/{} in {} ms", + e.getClass().getSimpleName(), attempt + 1, + retries, delay); + try { + Thread.sleep(delay); + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + throw new BackendException("Interrupted while " + + "waiting to retry " + + "Cassandra query", ie); + } + } + } + // Preserve original exception as cause (stack trace + type) by + // pre-formatting the message and using the (String, Throwable) + // constructor explicitly to avoid ambiguity with varargs overloads. + String msg = String.format( + "Failed to execute Cassandra query after %s retries: %s", + retries, + lastError == null ? "" : lastError.getMessage()); + throw new BackendException(msg, lastError); } private void tryOpen() { @@ -217,6 +368,24 @@ private void tryOpen() { } } + private com.datastax.driver.core.Session sessionForAsyncCommit() { + if (this.session == null || this.session.isClosed()) { + this.session = null; + try { + this.open(); + } catch (DriverException e) { + throw new BackendException( + "Failed to open Cassandra session for async commit", + e); + } + } + if (this.session == null) { + throw new BackendException( + "Cassandra session is unavailable for async commit"); + } + return this.session; + } + @Override public void open() { this.opened = true; @@ -255,6 +424,56 @@ public boolean hasChanges() { return this.batch.size() > 0; } + /** + * Periodic liveness probe invoked by {@link BackendSessionPool} to + * recover thread-local sessions after Cassandra has been restarted. + * Reopens the driver session if it was closed and pings the cluster + * with a lightweight query. On failure the session is discarded via + * {@link #reset()} so the next call to + * {@link #executeWithRetry(Statement)} reopens it; any exception + * here is swallowed so the caller can still issue the real query. + */ + @Override + public void reconnectIfNeeded() { + if (!this.opened) { + return; + } + try { + if (this.session == null || this.session.isClosed()) { + this.session = null; + this.tryOpen(); + } + if (this.session != null) { + this.session.execute(new SimpleStatement(HEALTH_CHECK_CQL)); + } + } catch (NoHostAvailableException | OperationTimedOutException e) { + LOG.debug("Cassandra health-check failed, resetting session: {}", + e.getMessage()); + this.reset(); + } + } + + /** + * Force-close the driver session so it is re-opened on the next + * {@link #opened()} call. Used when a failure is observed and we + * want to start fresh on the next attempt. + */ + @Override + public void reset() { + if (this.session == null) { + return; + } + try { + this.session.close(); + } catch (Exception e) { + // Do not swallow Error (OOM / StackOverflow); only log + // ordinary exceptions raised by the driver on close. + LOG.warn("Failed to reset Cassandra session", e); + } finally { + this.session = null; + } + } + public Collection statements() { return this.batch.getStatements(); } diff --git a/hugegraph-server/hugegraph-core/pom.xml b/hugegraph-server/hugegraph-core/pom.xml index 0b12f8b25f..2334496329 100644 --- a/hugegraph-server/hugegraph-core/pom.xml +++ b/hugegraph-server/hugegraph-core/pom.xml @@ -32,7 +32,7 @@ 1.3.11 0.7.4 5.12.1 - 1.8.0 + 1.8.1 1.10.0 2.6.2 portable-1.8.3 @@ -197,6 +197,8 @@ commons-compress ${commons-compress.version} + org.lz4 lz4-java diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraph.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraph.java index 88f1142e97..ba346e179f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraph.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/HugeGraph.java @@ -49,6 +49,7 @@ import org.apache.hugegraph.schema.VertexLabel; import org.apache.hugegraph.structure.HugeFeatures; import org.apache.hugegraph.task.TaskScheduler; +import org.apache.hugegraph.traversal.optimize.HugeCountStrategy; import org.apache.hugegraph.traversal.optimize.HugeCountStepStrategy; import org.apache.hugegraph.traversal.optimize.HugeGraphStepStrategy; import org.apache.hugegraph.traversal.optimize.HugePrimaryKeyStrategy; @@ -56,7 +57,9 @@ import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.GraphMode; import org.apache.hugegraph.type.define.GraphReadMode; +import org.apache.hugegraph.vector.VectorIndexManager; import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies; +import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy; import org.apache.tinkerpop.gremlin.structure.Edge; import org.apache.tinkerpop.gremlin.structure.Graph; import org.apache.tinkerpop.gremlin.structure.Property; @@ -278,6 +281,8 @@ public interface HugeGraph extends Graph { RaftGroupManager raftGroupManager(); + VectorIndexManager vectorIndexManager(); + void proxy(HugeGraph graph); boolean sameAs(HugeGraph graph); @@ -378,7 +383,9 @@ static void registerTraversalStrategies(Class clazz) { TraversalStrategies strategies = TraversalStrategies.GlobalCache .getStrategies(Graph.class) .clone(); - strategies.addStrategies(HugeVertexStepStrategy.instance(), + strategies.removeStrategies(CountStrategy.class); + strategies.addStrategies(HugeCountStrategy.instance(), + HugeVertexStepStrategy.instance(), HugeGraphStepStrategy.instance(), HugeCountStepStrategy.instance(), HugePrimaryKeyStrategy.instance()); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java index 9d5f5b720c..77e24812e4 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java @@ -108,6 +108,7 @@ import org.apache.hugegraph.util.LockUtil; import org.apache.hugegraph.util.Log; import org.apache.hugegraph.variables.HugeVariables; +import org.apache.hugegraph.vector.VectorIndexManager; import org.apache.tinkerpop.gremlin.process.computer.GraphComputer; import org.apache.tinkerpop.gremlin.structure.Edge; import org.apache.tinkerpop.gremlin.structure.Graph; @@ -190,6 +191,7 @@ public class StandardHugeGraph implements HugeGraph { private Date createTime; private Date updateTime; private KvStore kvStore; + private VectorIndexManager vectorIndexManager; public StandardHugeGraph(HugeConfig config) { this.params = new StandardHugeGraphParams(); @@ -1120,7 +1122,7 @@ public void create(String configPath, GlobalMasterInfo nodeInfo) { this.serverStarted(nodeInfo); // Write config to the disk file - String confPath = ConfigUtil.writeToFile(configPath, this.spaceGraphName(), + String confPath = ConfigUtil.writeToFile(configPath, this.name, this.configuration()); this.configuration.file(confPath); } @@ -1243,6 +1245,11 @@ public RaftGroupManager raftGroupManager() { return provider.raftNodeManager(); } + @Override + public VectorIndexManager vectorIndexManager() { + return this.vectorIndexManager; + } + @Override public HugeConfig configuration() { return this.configuration; @@ -1394,7 +1401,7 @@ public AbstractCacheNotifier(EventHub hub, CacheNotifier proxy) { "Expect event action argument"); String action = (String) args[0]; LOG.debug("Event action: {}", action); - if (Cache.ACTION_INVALIDED.equals(action)) { + if (Cache.ACTION_INVALID.equals(action)) { event.checkArgs(String.class, HugeType.class, Object.class); HugeType type = (HugeType) args[1]; Object ids = args[2]; @@ -1410,7 +1417,7 @@ public AbstractCacheNotifier(EventHub hub, CacheNotifier proxy) { E.checkArgument(false, "Unexpected argument: %s", ids); } return true; - } else if (Cache.ACTION_CLEARED.equals(action)) { + } else if (Cache.ACTION_CLEAR.equals(action)) { event.checkArgs(String.class, HugeType.class); HugeType type = (HugeType) args[1]; LOG.debug("Calling proxy.clear with type: {}", type); @@ -1435,17 +1442,20 @@ public void close() { @Override public void invalid(HugeType type, Id id) { - this.hub.notify(Events.CACHE, Cache.ACTION_INVALID, type, id); + this.hub.notifyExcept(Events.CACHE, this.cacheEventListener, + Cache.ACTION_INVALID, type, id); } @Override public void invalid2(HugeType type, Object[] ids) { - this.hub.notify(Events.CACHE, Cache.ACTION_INVALID, type, ids); + this.hub.notifyExcept(Events.CACHE, this.cacheEventListener, + Cache.ACTION_INVALID, type, ids); } @Override public void clear(HugeType type) { - this.hub.notify(Events.CACHE, Cache.ACTION_CLEAR, type); + this.hub.notifyExcept(Events.CACHE, this.cacheEventListener, + Cache.ACTION_CLEAR, type); } @Override diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/RolePermission.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/RolePermission.java index 834cbb569c..43ad50887d 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/RolePermission.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/RolePermission.java @@ -82,7 +82,7 @@ public static RolePermission role(String graphSpace, String graph, perm.ordinal() >= HugePermission.READ.ordinal()) { role.add(graphSpace, graph, perm, HugeResource.ALL_RES); } else { - // if perm is not read, write, delete or excute, set resources null + // if perm is not read, write, delete or execute, set resources null role.add(graphSpace, graph, perm, null); } return role; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManager.java index 67931a0450..a3224811f3 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManager.java @@ -580,6 +580,7 @@ public HugeUser matchUser(String name, String password) { } if (StringEncoding.checkPassword(password, user.password())) { + // TODO: rehash password if bcrypt work factor is lower than expected this.pwdCache.update(user.id(), password); return user; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManagerV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManagerV2.java index 5dcbc9378a..d2df45626c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManagerV2.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManagerV2.java @@ -947,6 +947,7 @@ public HugeUser matchUser(String name, String password) { } if (StringEncoding.checkPassword(password, user.password())) { + // TODO: rehash password if bcrypt work factor is lower than expected this.pwdCache.update(user.id(), password); return user; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/Cache.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/Cache.java index f58a9ce450..73910fd08c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/Cache.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/Cache.java @@ -24,8 +24,6 @@ public interface Cache { String ACTION_INVALID = "invalid"; String ACTION_CLEAR = "clear"; - String ACTION_INVALIDED = "invalided"; - String ACTION_CLEARED = "cleared"; V get(K id); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CacheListenerHolder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CacheListenerHolder.java new file mode 100644 index 0000000000..b4133679bb --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CacheListenerHolder.java @@ -0,0 +1,41 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.backend.cache; + +import org.apache.hugegraph.event.EventHub; +import org.apache.hugegraph.event.EventListener; + +/* + * Listener lifetime must cover all active transactions for the graph. + * The holder is removed from the registry and unregistered from EventHub + * only when the last transaction releases it. + */ +final class CacheListenerHolder { + + final EventListener listener; + final EventHub hub; + // Must only be read or written inside ConcurrentMap.compute() for the + // enclosing registry; ConcurrentHashMap.compute() serialises per-key access. + int refCount; + + CacheListenerHolder(EventListener listener, EventHub hub) { + this.listener = listener; + this.hub = hub; + this.refCount = 1; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedGraphTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedGraphTransaction.java index ed49082f22..dadfd7ec77 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedGraphTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedGraphTransaction.java @@ -24,6 +24,8 @@ import java.util.Iterator; import java.util.List; import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import org.apache.hugegraph.HugeGraphParams; import org.apache.hugegraph.backend.cache.CachedBackendStore.QueryId; @@ -60,11 +62,20 @@ public final class CachedGraphTransaction extends GraphTransaction { private static final long AVG_VERTEX_ENTRY_SIZE = 40L; private static final long AVG_EDGE_ENTRY_SIZE = 100L; + /* + * Listener lifetime must cover all active transactions for the graph. + * The holder is removed from the registry and unregistered from EventHub + * only when the last transaction releases it. + */ + private static final ConcurrentMap + GRAPH_CACHE_EVENT_LISTENERS = new ConcurrentHashMap<>(); + private final Cache verticesCache; private final Cache edgesCache; private EventListener storeEventListener; private EventListener cacheEventListener; + private CacheListenerHolder holder; public CachedGraphTransaction(HugeGraphParams graph, BackendStore store) { super(graph, store); @@ -138,7 +149,7 @@ private void listenChanges() { } // Listen cache event: "cache"(invalid cache item) - this.cacheEventListener = event -> { + EventListener listener = event -> { LOG.debug("Graph {} received graph cache event: {}", this.graph(), event); Object[] args = event.args(); @@ -184,18 +195,52 @@ private void listenChanges() { } return false; }; - if (graphCacheListenStatus.putIfAbsent(this.params().spaceGraphName(), true) == null) { - EventHub graphEventHub = this.params().graphEventHub(); - graphEventHub.listen(Events.CACHE, this.cacheEventListener); - } + EventHub graphEventHub = this.params().graphEventHub(); + String graphName = this.params().spaceGraphName(); + CacheListenerHolder acquired = GRAPH_CACHE_EVENT_LISTENERS.compute( + graphName, (key, existing) -> { + if (existing == null || existing.hub != graphEventHub) { + // Graph close/reopen creates a new EventHub for the + // same graph name; replace the stale holder. Old + // transactions skip decrement via identity check. + if (existing != null) { + existing.hub.unlisten(Events.CACHE, + existing.listener); + } + graphEventHub.listen(Events.CACHE, listener); + return new CacheListenerHolder(listener, graphEventHub); + } + existing.refCount++; + return existing; + }); + this.holder = acquired; + this.cacheEventListener = acquired.listener; } private void unlistenChanges() { String graphName = this.params().spaceGraphName(); - if (graphCacheListenStatus.remove(graphName) != null) { - EventHub graphEventHub = this.params().graphEventHub(); - graphEventHub.unlisten(Events.CACHE, this.cacheEventListener); + CacheListenerHolder ours = this.holder; + if (ours != null) { + GRAPH_CACHE_EVENT_LISTENERS.compute(graphName, (key, existing) -> { + if (existing == null || existing != ours) { + return existing; + } + existing.refCount--; + if (existing.refCount == 0) { + existing.hub.unlisten(Events.CACHE, existing.listener); + return null; + } + return existing; + }); + this.holder = null; + this.cacheEventListener = null; } + // TODO (follow-up): storeEventListenStatus has the same owner-first + // close bug this PR fixes for GRAPH_CACHE_EVENT_LISTENERS. A non-owner + // transaction can remove the tracking entry, unlisten its own + // never-registered storeEventListener as a no-op, and leave the + // original store listener registered but untracked. Apply the same + // ref-counted holder pattern in a follow-up PR. if (storeEventListenStatus.remove(graphName) != null) { this.store().provider().unlisten(this.storeEventListener); } @@ -203,12 +248,14 @@ private void unlistenChanges() { private void notifyChanges(String action, HugeType type, Id[] ids) { EventHub graphEventHub = this.params().graphEventHub(); - graphEventHub.notify(Events.CACHE, action, type, ids); + graphEventHub.notifyExcept(Events.CACHE, this.cacheEventListener, + action, type, ids); } private void notifyChanges(String action, HugeType type) { EventHub graphEventHub = this.params().graphEventHub(); - graphEventHub.notify(Events.CACHE, action, type); + graphEventHub.notifyExcept(Events.CACHE, this.cacheEventListener, + action, type); } public void clearCache(HugeType type, boolean notify) { @@ -220,7 +267,7 @@ public void clearCache(HugeType type, boolean notify) { } if (notify) { - this.notifyChanges(Cache.ACTION_CLEARED, null); + this.notifyChanges(Cache.ACTION_CLEAR, null); } } @@ -397,7 +444,7 @@ protected void commitMutation2Backend(BackendMutation... mutations) { this.verticesCache.invalidate(vertex.id()); } if (vertexOffset > 0) { - this.notifyChanges(Cache.ACTION_INVALIDED, + this.notifyChanges(Cache.ACTION_INVALID, HugeType.VERTEX, vertexIds); } } @@ -411,7 +458,7 @@ protected void commitMutation2Backend(BackendMutation... mutations) { if (invalidEdgesCache && this.enableCacheEdge()) { // TODO: Use a more precise strategy to update the edge cache this.edgesCache.clear(); - this.notifyChanges(Cache.ACTION_CLEARED, HugeType.EDGE); + this.notifyChanges(Cache.ACTION_CLEAR, HugeType.EDGE); } } } @@ -425,7 +472,7 @@ public void removeIndex(IndexLabel indexLabel) { if (indexLabel.baseType() == HugeType.EDGE_LABEL) { // TODO: Use a more precise strategy to update the edge cache this.edgesCache.clear(); - this.notifyChanges(Cache.ACTION_CLEARED, HugeType.EDGE); + this.notifyChanges(Cache.ACTION_CLEAR, HugeType.EDGE); } } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransaction.java index 20a355e872..d393be7461 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransaction.java @@ -21,6 +21,7 @@ import java.util.List; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import java.util.function.Consumer; import org.apache.hugegraph.HugeGraphParams; @@ -42,6 +43,14 @@ public final class CachedSchemaTransaction extends SchemaTransaction { + /* + * Listener lifetime must cover all active transactions for the graph. + * The holder is removed from the registry and unregistered from EventHub + * only when the last transaction releases it. + */ + private static final ConcurrentMap + SCHEMA_CACHE_EVENT_LISTENERS = new ConcurrentHashMap<>(); + private final Cache idCache; private final Cache nameCache; @@ -49,6 +58,7 @@ public final class CachedSchemaTransaction extends SchemaTransaction { private EventListener storeEventListener; private EventListener cacheEventListener; + private CacheListenerHolder holder; public CachedSchemaTransaction(HugeGraphParams graph, BackendStore store) { super(graph, store); @@ -111,7 +121,7 @@ private void listenChanges() { this.store().provider().listen(this.storeEventListener); // Listen cache event: "cache"(invalid cache item) - this.cacheEventListener = event -> { + EventListener listener = event -> { LOG.debug("Graph {} received schema cache event: {}", this.graph(), event); Object[] args = event.args(); @@ -132,9 +142,26 @@ private void listenChanges() { return false; }; EventHub schemaEventHub = this.params().schemaEventHub(); - if (!schemaEventHub.containsListener(Events.CACHE)) { - schemaEventHub.listen(Events.CACHE, this.cacheEventListener); - } + String graph = this.params().spaceGraphName(); + CacheListenerHolder acquired = SCHEMA_CACHE_EVENT_LISTENERS.compute( + graph, (key, existing) -> { + if (existing == null || existing.hub != schemaEventHub) { + // Graph close/reopen creates a new EventHub for the + // same graph name; replace the stale holder. Old + // transactions skip decrement via identity check. + if (existing != null) { + existing.hub.unlisten(Events.CACHE, + existing.listener); + } + schemaEventHub.listen(Events.CACHE, listener); + return new CacheListenerHolder(listener, + schemaEventHub); + } + existing.refCount++; + return existing; + }); + this.holder = acquired; + this.cacheEventListener = acquired.listener; } private void unlistenChanges() { @@ -142,18 +169,36 @@ private void unlistenChanges() { this.store().provider().unlisten(this.storeEventListener); // Unlisten cache event - EventHub schemaEventHub = this.params().schemaEventHub(); - schemaEventHub.unlisten(Events.CACHE, this.cacheEventListener); + CacheListenerHolder ours = this.holder; + if (ours != null) { + SCHEMA_CACHE_EVENT_LISTENERS.compute( + this.params().spaceGraphName(), (key, existing) -> { + if (existing == null || existing != ours) { + return existing; + } + existing.refCount--; + if (existing.refCount == 0) { + existing.hub.unlisten(Events.CACHE, + existing.listener); + return null; + } + return existing; + }); + this.holder = null; + this.cacheEventListener = null; + } } private void notifyChanges(String action, HugeType type, Id id) { EventHub graphEventHub = this.params().schemaEventHub(); - graphEventHub.notify(Events.CACHE, action, type, id); + graphEventHub.notifyExcept(Events.CACHE, this.cacheEventListener, + action, type, id); } private void notifyChanges(String action, HugeType type) { EventHub graphEventHub = this.params().schemaEventHub(); - graphEventHub.notify(Events.CACHE, action, type); + graphEventHub.notifyExcept(Events.CACHE, this.cacheEventListener, + action, type); } private void resetCachedAll(HugeType type) { @@ -179,7 +224,7 @@ public void clearCache(boolean notify) { this.arrayCaches.clear(); if (notify) { - this.notifyChanges(Cache.ACTION_CLEARED, null); + this.notifyChanges(Cache.ACTION_CLEAR, null); } } @@ -221,7 +266,7 @@ protected void updateSchema(SchemaElement schema, this.updateCache(schema); - this.notifyChanges(Cache.ACTION_INVALIDED, schema.type(), schema.id()); + this.notifyChanges(Cache.ACTION_INVALID, schema.type(), schema.id()); } @Override @@ -230,7 +275,7 @@ protected void addSchema(SchemaElement schema) { this.updateCache(schema); - this.notifyChanges(Cache.ACTION_INVALIDED, schema.type(), schema.id()); + this.notifyChanges(Cache.ACTION_INVALID, schema.type(), schema.id()); } @Override @@ -283,7 +328,7 @@ public void removeSchema(SchemaElement schema) { this.invalidateCache(schema.type(), schema.id()); - this.notifyChanges(Cache.ACTION_INVALIDED, schema.type(), schema.id()); + this.notifyChanges(Cache.ACTION_INVALID, schema.type(), schema.id()); } @Override diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java index c335d50f0a..d6fbe97964 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/cache/CachedSchemaTransactionV2.java @@ -19,8 +19,11 @@ import java.util.ArrayList; import java.util.List; +import java.util.Map; import java.util.Set; +import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Consumer; import org.apache.hugegraph.HugeGraphParams; @@ -33,6 +36,7 @@ import org.apache.hugegraph.event.EventListener; import org.apache.hugegraph.meta.MetaDriver; import org.apache.hugegraph.meta.MetaManager; +import org.apache.hugegraph.meta.MetaManager.SchemaCacheClearEvent; import org.apache.hugegraph.perf.PerfUtil; import org.apache.hugegraph.schema.SchemaElement; import org.apache.hugegraph.type.HugeType; @@ -43,6 +47,29 @@ public class CachedSchemaTransactionV2 extends SchemaTransactionV2 { + private static final String ID_CACHE_PREFIX = "schema-id"; + private static final String NAME_CACHE_PREFIX = "schema-name"; + + // MetaDriver doesn't expose unlisten, register the meta listener once. + // Lifecycle: this JVM-global flag is intentionally never reset by + // unlistenChanges() (the underlying gRPC watch is process-wide). If that + // watch is silently dropped after a transport reconnect, recovery is not + // automatic; resetMetaListenerForReconnect() is only a manual hook to let + // the next schema operation install a fresh watch. + private static final AtomicBoolean metaEventListenerRegistered = + new AtomicBoolean(false); + + private static final Object META_LISTENER_LOCK = new Object(); + + /** + * Per-JVM identifier emitted with every schema-cache-clear meta event so + * the listener can skip its own echo. Lifecycle: generated once per + * classloader at class init, never reused, regenerated on JVM restart. + * This is not a stable node identity, only a local self-echo filter. + */ + private static final String SCHEMA_CACHE_CLEAR_SOURCE = + UUID.randomUUID().toString(); + private final Cache idCache; private final Cache nameCache; @@ -58,8 +85,8 @@ public CachedSchemaTransactionV2(MetaDriver metaDriver, final long capacity = graphParams.configuration() .get(CoreOptions.SCHEMA_CACHE_CAPACITY); - this.idCache = this.cache("schema-id", capacity); - this.nameCache = this.cache("schema-name", capacity); + this.idCache = this.cache(ID_CACHE_PREFIX, capacity); + this.nameCache = this.cache(NAME_CACHE_PREFIX, capacity); SchemaCaches attachment = this.idCache.attachment(); if (attachment == null) { @@ -86,11 +113,38 @@ public void close() { } private Cache cache(String prefix, long capacity) { - final String name = prefix + "-" + this.graph().spaceGraphName(); + final String name = cacheName(prefix, this.graph().spaceGraphName()); // NOTE: must disable schema cache-expire due to getAllSchema() return CacheManager.instance().cache(name, capacity); } + private static String cacheName(String prefix, String spaceGraphName) { + return prefix + "-" + spaceGraphName; + } + + private static void clearSchemaCache(String spaceGraphName) { + Map> caches = CacheManager.instance().caches(); + + // Clear name cache first so the (name -> id -> object) lookup path + // fails fast instead of returning a stale object backed by an + // already-empty id cache during the TOCTOU window. + Cache nameCache = caches.get(cacheName(NAME_CACHE_PREFIX, + spaceGraphName)); + if (nameCache != null) { + nameCache.clear(); + } + + Cache idCache = caches.get(cacheName(ID_CACHE_PREFIX, + spaceGraphName)); + if (idCache != null) { + SchemaCaches arrayCaches = idCache.attachment(); + if (arrayCaches != null) { + arrayCaches.clear(); + } + idCache.clear(); + } + } + private void listenChanges() { // Listen store event: "store.init", "store.clear", ... Set storeEvents = ImmutableSet.of(Events.STORE_INIT, @@ -100,7 +154,8 @@ private void listenChanges() { if (storeEvents.contains(event.name())) { LOG.debug("Graph {} clear schema cache on event '{}'", this.graph(), event.name()); - this.clearCache(true); + boolean notify = !Events.STORE_INIT.equals(event.name()); + this.clearCache(notify); return true; } return false; @@ -145,12 +200,88 @@ private void listenChanges() { if (!schemaEventHub.containsListener(Events.CACHE)) { schemaEventHub.listen(Events.CACHE, this.cacheEventListener); } + + listenSchemaCacheClear(); + } + + private static void listenSchemaCacheClear() { + synchronized (META_LISTENER_LOCK) { + if (metaEventListenerRegistered.get()) { + return; + } + try { + MetaManager.instance().listenSchemaCacheClear( + CachedSchemaTransactionV2::handleSchemaCacheClearEvent); + // Set AFTER the underlying watch is live so a concurrent + // caller that observes the flag is guaranteed an active + // subscription, and a failure leaves the flag false so the + // next caller retries registration. + metaEventListenerRegistered.set(true); + } catch (Exception e) { + throw e instanceof RuntimeException + ? (RuntimeException) e + : new RuntimeException( + "Failed to register schema cache clear listener", + e); + } + } + } + + /** + * Consumer invoked by the MetaManager schema-cache-clear watch. Extracted + * as a package-private static method so end-to-end tests can drive the + * publish -> callback -> {@link #clearSchemaCache(String)} path without + * depending on a live etcd/PD watch. + */ + static void handleSchemaCacheClearEvent(T response) { + List events = + MetaManager.instance() + .extractSchemaCacheClearEventsFromResponse( + response); + if (events == null) { + return; + } + for (SchemaCacheClearEvent event : events) { + if (SCHEMA_CACHE_CLEAR_SOURCE.equals(event.source())) { + continue; + } + String graphName = event.graph(); + LOG.debug("Graph {} clear schema cache on meta event", graphName); + clearSchemaCache(graphName); + } + } + + /** + * Manually reset the JVM-global meta listener flag after detecting that + * the MetaManager transport reconnected and dropped the underlying gRPC + * watch. This method is not wired to a MetaManager/MetaDriver reconnect + * callback today; callers must invoke it explicitly after detecting that + * condition. Without such a manual reset {@link #metaEventListenerRegistered} + * would stay {@code true} forever and this JVM would stop receiving + * cross-node schema cache clear events with no error or warning. + * + *

      TODO: wire this into MetaManager once it exposes a transport + * reconnect callback (e.g. {@code listenReconnect} / + * {@code onTransportReconnect}). Until then it must be invoked + * explicitly by code that detects the reconnect. + */ + public static void resetMetaListenerForReconnect() { + if (metaEventListenerRegistered.compareAndSet(true, false)) { + LOG.warn("Schema cache clear meta listener lost on reconnect - " + + "will re-register on next schema operation."); + } } public void clearCache(boolean notify) { - this.idCache.clear(); + // Same TOCTOU ordering as clearSchemaCache(String): clear nameCache + // first, then the array attachment, then idCache last. this.nameCache.clear(); this.arrayCaches.clear(); + this.idCache.clear(); + + if (notify) { + this.maybeNotifySchemaCacheClear(); + } } private void resetCachedAllIfReachedCapacity() { @@ -202,6 +333,8 @@ protected void updateSchema(SchemaElement schema, super.updateSchema(schema, updateCallback); this.updateCache(schema); + // Status transitions are internal bookkeeping; notifying here causes a + // broadcast storm for every updateSchemaStatus() call from background jobs. } @Override @@ -210,11 +343,9 @@ protected void addSchema(SchemaElement schema) { this.updateCache(schema); - if (!this.graph().option(CoreOptions.TASK_SYNC_DELETION)) { - MetaManager.instance() - .notifySchemaCacheClear(this.graph().graphSpace(), - this.graph().name()); - } + // Schema additions must always propagate to remote nodes regardless + // of TASK_SYNC_DELETION (which only gates removal flows). + this.notifySchemaCacheClear(); } private void updateCache(SchemaElement schema) { @@ -238,13 +369,25 @@ public void removeSchema(SchemaElement schema) { this.invalidateCache(schema.type(), schema.id()); + this.maybeNotifySchemaCacheClear(); + } + + private void maybeNotifySchemaCacheClear() { + // Only suppress notifications for removal tasks when + // TASK_SYNC_DELETION=true: the caller propagates cache invalidation + // synchronously, so the meta-event broadcast would be redundant. if (!this.graph().option(CoreOptions.TASK_SYNC_DELETION)) { - MetaManager.instance() - .notifySchemaCacheClear(this.graph().graphSpace(), - this.graph().name()); + this.notifySchemaCacheClear(); } } + private void notifySchemaCacheClear() { + MetaManager.instance() + .notifySchemaCacheClear(this.graph().graphSpace(), + this.graph().name(), + SCHEMA_CACHE_CLEAR_SOURCE); + } + @Override @SuppressWarnings("unchecked") protected T getSchema(HugeType type, Id id) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java index 09e223e4ca..8d9ecd4332 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java @@ -195,7 +195,7 @@ private static boolean equals(final Object first, * * @param first is actual value, might be Number/Date or String, It is * probably that the `first` is serialized to String. - * @param second is value in query condition, must be Number/Date + * @param second is value in query condition, must be Number/Date/Boolean * @return the value 0 if first is numerically equal to second; * a value less than 0 if first is numerically less than * second; and a value greater than 0 if first is @@ -208,6 +208,8 @@ private static int compare(final Object first, final Object second) { (Number) second); } else if (second instanceof Date) { return compareDate(first, (Date) second); + } else if (second instanceof Boolean) { + return compareBoolean(first, (Boolean) second); } throw new IllegalArgumentException(String.format( @@ -230,6 +232,18 @@ private static int compareDate(Object first, Date second) { second, second.getClass().getSimpleName())); } + private static int compareBoolean(Object first, Boolean second) { + if (first instanceof Boolean) { + return Boolean.compare((Boolean) first, second); + } + + throw new IllegalArgumentException(String.format( + "Can't compare between %s(%s) and %s(%s)", + first, first == null ? null : + first.getClass().getSimpleName(), + second, second.getClass().getSimpleName())); + } + private void checkBaseType(Object value, Class clazz) { if (!clazz.isInstance(value)) { String valueClass = value == null ? "null" : diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java index 8a5706a774..063d23aa6d 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java @@ -288,11 +288,13 @@ public T condition(Object key) { return value; } + boolean initialized = false; Set intersectValues = InsertionOrderUtil.newSet(); for (Object value : valuesEQ) { List valueAsList = ImmutableList.of(value); - if (intersectValues.isEmpty()) { + if (!initialized) { intersectValues.addAll(valueAsList); + initialized = true; } else { CollectionUtil.intersectWithModify(intersectValues, valueAsList); @@ -301,8 +303,9 @@ public T condition(Object key) { for (Object value : valuesIN) { @SuppressWarnings("unchecked") List valueAsList = (List) value; - if (intersectValues.isEmpty()) { + if (!initialized) { intersectValues.addAll(valueAsList); + initialized = true; } else { CollectionUtil.intersectWithModify(intersectValues, valueAsList); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQueryFlatten.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQueryFlatten.java index 83af41b008..649f88e7b3 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQueryFlatten.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQueryFlatten.java @@ -115,12 +115,23 @@ private static Condition flattenIn(Condition condition, boolean supportIn) { } case AND: Condition.And and = (Condition.And) condition; - return new Condition.And(flattenIn(and.left(), supportIn), - flattenIn(and.right(), supportIn)); + Condition andLeft = flattenIn(and.left(), supportIn); + Condition andRight = flattenIn(and.right(), supportIn); + if (andLeft == null || andRight == null) { + return null; + } + return new Condition.And(andLeft, andRight); case OR: Condition.Or or = (Condition.Or) condition; - return new Condition.Or(flattenIn(or.left(), supportIn), - flattenIn(or.right(), supportIn)); + Condition orLeft = flattenIn(or.left(), supportIn); + Condition orRight = flattenIn(or.right(), supportIn); + if (orLeft == null) { + return orRight; + } + if (orRight == null) { + return orLeft; + } + return new Condition.Or(orLeft, orRight); default: throw new AssertionError(String.format("Wrong condition type: '%s'", condition.type())); @@ -427,9 +438,26 @@ private static boolean validRange(Relation low, Relation high) { if (low == null || high == null) { return true; } - return compare(low, high) < 0 || compare(low, high) == 0 && - low.relation() == Condition.RelationType.GTE && - high.relation() == Condition.RelationType.LTE; + int compared = compare(low, high); + if (compared > 0) { + return false; + } + if (compared == 0) { + return low.relation() == Condition.RelationType.GTE && + high.relation() == Condition.RelationType.LTE; + } + return !emptyBooleanRange(low, high); + } + + private static boolean emptyBooleanRange(Relation low, Relation high) { + if (!(low.value() instanceof Boolean) || + !(high.value() instanceof Boolean)) { + return false; + } + return Boolean.FALSE.equals(low.value()) && + Boolean.TRUE.equals(high.value()) && + low.relation() == Condition.RelationType.GT && + high.relation() == Condition.RelationType.LT; } private static boolean validEq(Relation eq, Relation low, Relation high) { @@ -507,6 +535,9 @@ private static int compare(Relation first, Relation second) { return NumericUtil.compareNumber(firstValue, (Number) secondValue); } else if (firstValue instanceof Date && secondValue instanceof Date) { return ((Date) firstValue).compareTo((Date) secondValue); + } else if (firstValue instanceof Boolean && + secondValue instanceof Boolean) { + return Boolean.compare((Boolean) firstValue, (Boolean) secondValue); } else { throw new IllegalArgumentException(String.format("Can't compare between %s and %s", first, second)); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java index 0bb07760a5..600fbd64d7 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BinarySerializer.java @@ -18,6 +18,7 @@ package org.apache.hugegraph.backend.serializer; import static org.apache.hugegraph.schema.SchemaElement.UNDEF; +import static org.apache.hugegraph.structure.HugeIndex.number2bytes; import java.util.Arrays; import java.util.Collection; @@ -54,6 +55,7 @@ import org.apache.hugegraph.structure.HugeElement; import org.apache.hugegraph.structure.HugeIndex; import org.apache.hugegraph.structure.HugeProperty; +import org.apache.hugegraph.structure.HugeVectorIndexMap; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.structure.HugeVertexProperty; import org.apache.hugegraph.type.HugeType; @@ -66,6 +68,7 @@ import org.apache.hugegraph.type.define.HugeKeys; import org.apache.hugegraph.type.define.IdStrategy; import org.apache.hugegraph.type.define.IndexType; +import org.apache.hugegraph.type.define.IndexVectorState; import org.apache.hugegraph.type.define.SchemaStatus; import org.apache.hugegraph.type.define.SerialEnum; import org.apache.hugegraph.type.define.WriteType; @@ -116,7 +119,7 @@ protected BinaryBackendEntry newBackendEntry(HugeType type, Id id) { return new BinaryBackendEntry(type, (BinaryId) id); } - if (type.isIndex()) { + if (type.isIndex() || type.isVectorIndex() || type.code() == (byte) 182) { if (this.enablePartition) { if (type.isStringIndex()) { // TODO: add string index partition @@ -387,8 +390,10 @@ protected byte[] formatIndexName(HugeIndex index) { protected void parseIndexName(HugeGraph graph, ConditionQuery query, BinaryBackendEntry entry, HugeIndex index, Object fieldValues) { + boolean isVectorIndex = index.type().isVectorIndex(); for (BackendColumn col : entry.columns()) { - if (indexFieldValuesUnmatched(col.value, fieldValues)) { + if ((isVectorIndex && isVectorDleted(col.value)) || + (!isVectorIndex && indexFieldValuesUnmatched(col.value, fieldValues))) { // Skip if field-values is not matched (just the same hash) continue; } @@ -402,6 +407,32 @@ protected void parseIndexName(HugeGraph graph, ConditionQuery query, } } + protected byte[] formatVectorSequenceName(HugeVectorIndexMap vectorIndexMap) { + Id sequenceId = vectorIndexMap.sequenceId(); + Object vectorId = vectorIndexMap.fieldValues(); + + // sequenceId_length + vectorId(int) + int idLen = sequenceId.length() + 4; + BytesBuffer buffer = BytesBuffer.allocate(idLen); + // Write index-id (raw bytes, no length prefix, matching newBackendEntry) + buffer.write(sequenceId.asBytes()); + // Write vectorId as fixed 4-byte int (matching readInt in parseVectorSequenceName) + buffer.writeInt(((Number) vectorId).intValue()); + return buffer.bytes(); + } + + protected void parseVectorSequenceName(BinaryBackendEntry entry, + HugeVectorIndexMap vectorIndexMap) { + for (BackendColumn col : entry.columns()) { + BytesBuffer buffer = BytesBuffer.wrap(col.name); + + // sequenceId = prefix(1byte) + indexlabelid(4bytes) + sequence(8byte) + buffer.read(vectorIndexMap.sequenceId().length()); + Object fieldValue = buffer.readInt(); + vectorIndexMap.fieldValues(fieldValue); + } + } + @Override public BackendEntry writeVertex(HugeVertex vertex) { if (vertex.olap()) { @@ -593,8 +624,14 @@ public BackendEntry writeIndex(HugeIndex index) { id = index.hashId(); // Save field-values as column value if the key is a hash string value = StringEncoding.encode(index.fieldValues().toString()); + } else if (index instanceof HugeVectorIndexMap) { + HugeVectorIndexMap indexMap = (HugeVectorIndexMap) index; + BytesBuffer buffer = BytesBuffer.allocate(9); + buffer.writeLong(indexMap.sequence()); + buffer.write((byte) indexMap.vectorState().code()); + value = buffer.bytes(); } - + // 添加type等于vector 的writeindex entry = newBackendEntry(type, id); if (index.indexLabel().olap()) { entry.olap(true); @@ -634,6 +671,30 @@ public HugeIndex readIndex(HugeGraph graph, ConditionQuery query, return index; } + @Override + public BackendEntry writeVectorSequence(HugeVectorIndexMap indexMap) { + BinaryBackendEntry entry; + Id id = indexMap.sequenceId(); + entry = newBackendEntry(HugeType.VECTOR_SEQUENCE, id); + byte[] value = null; + entry.column(formatVectorSequenceName(indexMap), value); + return entry; + } + + @Override + public HugeVectorIndexMap readVectorSequence(HugeGraph graph, ConditionQuery query, + BackendEntry bytesEntry) { + if (bytesEntry == null) { + return null; + } + BinaryBackendEntry entry = this.convertEntry(bytesEntry); + byte[] bytes = entry.id().asBytes(); + HugeVectorIndexMap indexMap = HugeVectorIndexMap.parseSequenceId(graph, bytes); + + this.parseVectorSequenceName(entry, indexMap); + return indexMap; + } + @Override public BackendEntry writeId(HugeType type, Id id) { return newBackendEntry(type, id); @@ -988,6 +1049,12 @@ protected static boolean indexFieldValuesUnmatched(byte[] value, return false; } + protected static boolean isVectorDleted(byte[] value) { + BytesBuffer buffer = BytesBuffer.wrap(value); + buffer.readLong(); + return IndexVectorState.DELETING.code() == buffer.read(); + } + public static void increaseOne(byte[] bytes) { final byte BYTE_MAX_VALUE = (byte) 0xff; final byte INCREASE_STEP = 0x01; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java index fb52347677..1c2ce93067 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/BytesBuffer.java @@ -777,7 +777,7 @@ public BytesBuffer writeIndexId(Id id, HugeType type, boolean withEnding) { public BinaryId readIndexId(HugeType type) { byte[] id; - if (type.isRange4Index()) { + if (type.isRange4Index() || type.isVectorIndex()) { // HugeTypeCode 1 byte + IndexLabel 4 bytes + fieldValue 4 bytes id = this.read(9); } else if (type.isRange8Index()) { @@ -795,9 +795,14 @@ public BinaryId asId() { } public BinaryId parseId(HugeType type, boolean enablePartition) { - if (type.isIndex()) { + if (type.isIndex() || type.isVectorIndex()) { return this.readIndexId(type); } + if (type.code() == (byte) 182) { + // VECTOR_SEQUENCE: 1 byte prefix(0) + 4 bytes schemaId + 8 bytes sequence = 13 bytes + byte[] bytes = this.read(13); + return new BinaryId(bytes, null); + } // Parse id from bytes if ((type.isVertex() || type.isEdge()) && enablePartition) { this.readShort(); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java index 2d14df1c84..f3cbffc95c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/GraphSerializer.java @@ -26,6 +26,7 @@ import org.apache.hugegraph.structure.HugeEdge; import org.apache.hugegraph.structure.HugeEdgeProperty; import org.apache.hugegraph.structure.HugeIndex; +import org.apache.hugegraph.structure.HugeVectorIndexMap; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.structure.HugeVertexProperty; import org.apache.hugegraph.type.HugeType; @@ -53,6 +54,10 @@ public interface GraphSerializer { HugeIndex readIndex(HugeGraph graph, ConditionQuery query, BackendEntry entry); + BackendEntry writeVectorSequence(HugeVectorIndexMap indexMap); + + HugeVectorIndexMap readVectorSequence(HugeGraph graph, ConditionQuery query, BackendEntry entry); + BackendEntry writeId(HugeType type, Id id); Query writeQuery(Query query); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java index 2d5cb81ec1..f571a30232 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/serializer/TextSerializer.java @@ -51,6 +51,7 @@ import org.apache.hugegraph.structure.HugeIndex; import org.apache.hugegraph.structure.HugeIndex.IdWithExpiredTime; import org.apache.hugegraph.structure.HugeProperty; +import org.apache.hugegraph.structure.HugeVectorIndexMap; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.structure.HugeVertexProperty; import org.apache.hugegraph.type.HugeType; @@ -418,6 +419,17 @@ public HugeIndex readIndex(HugeGraph graph, ConditionQuery query, return index; } + @Override + public BackendEntry writeVectorSequence(HugeVectorIndexMap indexMap) { + throw new RuntimeException("Method not implemented error."); + } + + @Override + public HugeVectorIndexMap readVectorSequence(HugeGraph graph, ConditionQuery query, + BackendEntry entry) { + throw new RuntimeException("Method not implemented error."); + } + @Override public TextBackendEntry writeId(HugeType type, Id id) { id = this.writeQueryId(type, id); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/AbstractTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/AbstractTransaction.java index 43393252d2..89eed44f8e 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/AbstractTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/AbstractTransaction.java @@ -17,6 +17,8 @@ package org.apache.hugegraph.backend.tx; +import java.util.HashMap; +import java.util.Map; import java.util.Set; import org.apache.commons.lang3.StringUtils; @@ -67,6 +69,9 @@ public abstract class AbstractTransaction implements Transaction { protected final AbstractSerializer serializer; + protected static final ThreadLocal> vectorIndexChanges = + ThreadLocal.withInitial(HashMap::new); + public AbstractTransaction(HugeGraphParams graph, BackendStore store) { E.checkNotNull(graph, "graph"); E.checkNotNull(store, "store"); @@ -234,12 +239,20 @@ public void commit() throws BackendException { this.committing = true; try { this.commit2Backend(); + signalChangedIndexes(); } finally { this.committing = false; this.reset(); } } + private void signalChangedIndexes() { + Map changes = vectorIndexChanges.get(); + if (changes.isEmpty()) return; + + changes.keySet().forEach(id -> graph().vectorIndexManager().signal(id)); + } + @Override public void commitIfGtSize(int size) throws BackendException { if (this.mutationSize() >= size) { @@ -296,6 +309,9 @@ protected void reset() { if (this.mutation == null || !this.mutation.isEmpty()) { this.mutation = new BackendMutation(); } + if (!this.vectorIndexChanges.get().isEmpty()) { + vectorIndexChanges.get().clear(); + } } protected BackendMutation mutation() { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java index 7388425167..6cda974eb6 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphIndexTransaction.java @@ -76,6 +76,7 @@ import org.apache.hugegraph.structure.HugeIndex; import org.apache.hugegraph.structure.HugeIndex.IdWithExpiredTime; import org.apache.hugegraph.structure.HugeProperty; +import org.apache.hugegraph.structure.HugeVectorIndexMap; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.task.EphemeralJobQueue; import org.apache.hugegraph.type.HugeType; @@ -308,12 +309,48 @@ protected void updateIndex(Id ilId, HugeElement element, boolean removed) { this.updateIndex(indexLabel, value, element.id(), expiredTime, removed); break; + case VECTOR: + value = nnPropValues.get(0); + E.checkState(nnPropValues.size() == 1, + "Expect only one property in range index"); + E.checkArgument(value instanceof List, + "Vector value must be a list but got %s", value.getClass()); + Id elementId = element.id(); + /* + * This column only stores the vector-id → vertex-id mapping and tracks the state. + * Entries are removed only after the actual vector index is deleted in JVector. + * The column is garbage-collected once the data has been flushed to disk. + * generate new vector id from the context + */ + + int vectorId = this.graph().vectorIndexManager().getNextVectorId(indexLabel.id()); + this.updateVectorIndex(indexLabel, vectorId, elementId, expiredTime, removed); + break; + default: throw new AssertionError(String.format( "Unknown index type '%s'", indexLabel.indexType())); } } + private void updateVectorIndex(IndexLabel indexLabel, Object vectorId, Id elementId, + long expiredTime, boolean removed){ + + HugeVectorIndexMap indexMap = new HugeVectorIndexMap(this.graph(), indexLabel, removed); + indexMap.fieldValues(vectorId); + + vectorIndexChanges.get().put(indexLabel.id(), true); + long sequence = this.graph().vectorIndexManager().getNextSequence(indexLabel.id()); + indexMap.sequence(sequence); + indexMap.elementIds(elementId, expiredTime); + this.doAppend(this.serializer.writeIndex(indexMap)); + // writeIndex + LOG.debug("updateVectorIndex: vertexId=" + elementId + + ", vectorId=" + vectorId + ", sequence=" + sequence + + ", indexLabel=" + indexLabel.id()); + this.doAppend(this.serializer.writeVectorSequence(indexMap)); + } + private void updateIndex(IndexLabel indexLabel, Object propValue, Id elementId, long expiredTime, boolean removed) { HugeIndex index = new HugeIndex(this.graph(), indexLabel); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java index 763ccaa0ee..5e33e0b3fc 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java @@ -140,8 +140,6 @@ public class GraphTransaction extends IndexableTransaction { private final int verticesCapacity; private final int edgesCapacity; - protected static final ConcurrentHashMap graphCacheListenStatus = - new ConcurrentHashMap<>(); protected static final ConcurrentHashMap storeEventListenStatus = new ConcurrentHashMap<>(); @@ -942,6 +940,7 @@ protected Iterator queryEdgesByIds(Object[] edgeIds, // NOTE: allowed duplicated edges if query by duplicated ids List ids = InsertionOrderUtil.newList(); Map edges = new HashMap<>(edgeIds.length); + Set distinctIds = InsertionOrderUtil.newSet(edgeIds.length); IdQuery query = new IdQuery(HugeType.EDGE); for (Object edgeId : edgeIds) { @@ -968,11 +967,12 @@ protected Iterator queryEdgesByIds(Object[] edgeIds, query.query(id); } ids.add(id); + distinctIds.add(id); } if (!query.empty()) { // Query from backend store - if (edges.isEmpty() && query.idsSize() == ids.size()) { + if (edges.isEmpty() && distinctIds.size() == ids.size()) { /* * Sort at the lower layer and return directly if there is no * local vertex and duplicated id. diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/config/AuthOptions.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/config/AuthOptions.java index c996082dab..5653c67885 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/config/AuthOptions.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/config/AuthOptions.java @@ -44,8 +44,7 @@ public static synchronized AuthOptions instance() { new ConfigOption<>( "auth.authenticator", "The class path of authenticator implementation. " + - "e.g., org.apache.hugegraph.auth.StandardAuthenticator, " + - "or org.apache.hugegraph.auth.ConfigAuthenticator.", + "e.g., org.apache.hugegraph.auth.StandardAuthenticator.", null, "" ); @@ -59,24 +58,6 @@ public static synchronized AuthOptions instance() { "hugegraph" ); - public static final ConfigOption AUTH_ADMIN_TOKEN = - new ConfigOption<>( - "auth.admin_token", - "Token for administrator operations, " + - "only for org.apache.hugegraph.auth.ConfigAuthenticator.", - disallowEmpty(), - "162f7848-0b6d-4faf-b557-3a0797869c55" - ); - - public static final ConfigListOption AUTH_USER_TOKENS = - new ConfigListOption<>( - "auth.user_tokens", - "The map of user tokens with name and password, " + - "only for org.apache.hugegraph.auth.ConfigAuthenticator.", - disallowEmpty(), - "hugegraph:9fd95c9c-711b-415b-b85f-d4df46ba5c31" - ); - public static final ConfigOption AUTH_REMOTE_URL = new ConfigOption<>( "auth.remote_url", diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java index e37338f9b6..ddb7c1a981 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java @@ -87,7 +87,7 @@ public class HugeGraphSONModule extends TinkerPopJacksonModule { private static final String TYPE_NAMESPACE = "hugegraph"; - private static final boolean OPTIMIZE_SERIALIZE = true; + private static boolean OPTIMIZE_SERIALIZE = true; @SuppressWarnings("rawtypes") private static final Map TYPE_DEFINITIONS; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java index 9bf0142d76..78fde3e858 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/job/schema/IndexLabelRebuildJob.java @@ -142,6 +142,7 @@ private void rebuildIndex(SchemaLabel label, Collection indexLabelIds) { for (IndexLabel il : ils) { schemaTx.updateSchemaStatus(il, SchemaStatus.CREATED); } + // todo: add check indexlable is vector index, if it is call vector rebuild job } finally { locks.unlock(); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/arbitrator/MemoryArbitratorImpl.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/arbitrator/MemoryArbitratorImpl.java index d8ce73afde..496b8ca9e3 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/arbitrator/MemoryArbitratorImpl.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/arbitrator/MemoryArbitratorImpl.java @@ -55,7 +55,7 @@ public long reclaimGlobally(MemoryPool queryPool, long neededBytes) { if (memoryPool.equals(queryPool)) { continue; } - LOG.info("Global reclaim triggerred by {} select {} to reclaim", queryPool, + LOG.info("Global reclaim triggered by {} select {} to reclaim", queryPool, memoryPool); long res = memoryPool.tryToReclaimLocalMemory(currentNeededBytes, queryPool); totalReclaimedBytes += res; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java index 551b21997e..6637baf22c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/MetaManager.java @@ -57,11 +57,16 @@ import org.apache.hugegraph.space.SchemaTemplate; import org.apache.hugegraph.space.Service; import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.JsonUtil; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; import com.google.common.collect.ImmutableMap; public class MetaManager { + private static final Logger LOG = Log.logger(MetaManager.class); + public static final String META_PATH_DELIMITER = "/"; public static final String META_PATH_JOIN = "-"; @@ -119,6 +124,8 @@ public class MetaManager { public static final long LOCK_DEFAULT_LEASE = 30L; public static final long LOCK_DEFAULT_TIMEOUT = 10L; public static final int RANDOM_USER_ID = 100; + private static final String SCHEMA_CACHE_CLEAR_GRAPH_KEY = "graph"; + private static final String SCHEMA_CACHE_CLEAR_SOURCE_KEY = "source"; private static final String META_PATH_URLS = "URLS"; private static final String META_PATH_PD_PEERS = "HSTORE_PD_PEERS"; private static final MetaManager INSTANCE = new MetaManager(); @@ -380,6 +387,23 @@ public List extractGraphsFromResponse(T response) { return this.metaDriver.extractValuesFromResponse(response); } + public List extractSchemaCacheClearEventsFromResponse( + T response) { + List values = this.metaDriver.extractValuesFromResponse(response); + if (values == null) { + return null; + } + + List events = new ArrayList<>(values.size()); + for (String value : values) { + SchemaCacheClearEvent event = SchemaCacheClearEvent.fromValue(value); + if (event != null) { + events.add(event); + } + } + return events; + } + public Map extractKVFromResponse(T response) { return this.metaDriver.extractKVFromResponse(response); } @@ -499,7 +523,12 @@ public void notifyGraphClear(String graphSpace, String graph) { } public void notifySchemaCacheClear(String graphSpace, String graph) { - this.graphMetaManager.notifySchemaCacheClear(graphSpace, graph); + this.notifySchemaCacheClear(graphSpace, graph, null); + } + + public void notifySchemaCacheClear(String graphSpace, String graph, + String source) { + this.graphMetaManager.notifySchemaCacheClear(graphSpace, graph, source); } public void notifyGraphCacheClear(String graphSpace, String graph) { @@ -1287,6 +1316,70 @@ public void setWhiteIpStatus(boolean status) { this.metaDriver.put(key, ((Boolean) status).toString()); } + public static String schemaCacheClearEventValue(String graph, + String source) { + if (StringUtils.isEmpty(source)) { + return graph; + } + return JsonUtil.toJson(ImmutableMap.of(SCHEMA_CACHE_CLEAR_GRAPH_KEY, + graph, + SCHEMA_CACHE_CLEAR_SOURCE_KEY, + source)); + } + + public static final class SchemaCacheClearEvent { + + private final String graph; + private final String source; + + private SchemaCacheClearEvent(String graph, String source) { + this.graph = graph; + this.source = source; + } + + public String graph() { + return this.graph; + } + + public String source() { + return this.source; + } + + @SuppressWarnings("unchecked") + static SchemaCacheClearEvent fromValue(String value) { + if (StringUtils.isEmpty(value)) { + return null; + } + // Compatibility: events published before source-id support stored + // only the graph name as a plain string. Keep accepting that format + // so mixed-version clusters can consume old/new schema-cache-clear + // events during rolling upgrades. + if (value.charAt(0) != '{') { + return new SchemaCacheClearEvent(value, null); + } + + Map payload; + try { + payload = JsonUtil.fromJson(value, Map.class); + } catch (RuntimeException e) { + LOG.debug("Malformed schema-cache-clear payload, ignoring: {}", + value, e); + return null; + } + + Object graph = payload.get(SCHEMA_CACHE_CLEAR_GRAPH_KEY); + if (graph == null) { + LOG.debug("Schema-cache-clear payload missing '{}' field: {}", + SCHEMA_CACHE_CLEAR_GRAPH_KEY, value); + return null; + } + + Object source = payload.get(SCHEMA_CACHE_CLEAR_SOURCE_KEY); + String sourceValue = source == null ? null : source.toString(); + return new SchemaCacheClearEvent(graph.toString(), sourceValue); + } + } + public enum MetaDriverType { ETCD, PD diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java index 8d00bfabb2..52b2c3946e 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/meta/managers/GraphMetaManager.java @@ -33,6 +33,7 @@ import static org.apache.hugegraph.meta.MetaManager.META_PATH_SYS_GRAPH_CONF; import static org.apache.hugegraph.meta.MetaManager.META_PATH_UPDATE; import static org.apache.hugegraph.meta.MetaManager.META_PATH_VERTEX_LABEL; +import static org.apache.hugegraph.meta.MetaManager.schemaCacheClearEventValue; import java.util.Map; import java.util.function.Consumer; @@ -94,8 +95,14 @@ public void notifyGraphClear(String graphSpace, String graph) { } public void notifySchemaCacheClear(String graphSpace, String graph) { + this.notifySchemaCacheClear(graphSpace, graph, null); + } + + public void notifySchemaCacheClear(String graphSpace, String graph, + String source) { this.metaDriver.put(this.schemaCacheClearKey(), - graphName(graphSpace, graph)); + schemaCacheClearEventValue( + graphName(graphSpace, graph), source)); } public void notifyGraphCacheClear(String graphSpace, String graph) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java index e20a728c2b..1331549226 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/IndexLabel.java @@ -275,6 +275,8 @@ public interface Builder extends SchemaBuilder { Builder unique(); + Builder vector(); + Builder on(HugeType baseType, String baseValue); Builder indexType(IndexType indexType); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java index 64d5115d80..5bf34ea530 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/PropertyKey.java @@ -121,7 +121,22 @@ public void defineDefaultValue(Object value) { public Object defaultValue() { // TODO add a field default_value - return this.userdata().get(Userdata.DEFAULT_VALUE); + Object value = this.userdata().get(Userdata.DEFAULT_VALUE); + if (value == null) { + return null; + } + + // Userdata is reloaded from JSON as a raw Map, so a typed default + // value (e.g. Date) comes back as a String. Normalize it to the + // runtime type expected by this property key's data type. Idempotent + // for values already of the expected type. + Object raw = value; + if (this.cardinality == Cardinality.SET && value instanceof Collection && + !(value instanceof Set)) { + raw = new LinkedHashSet<>((Collection) value); + } + + return this.validValueOrThrow(raw); } public boolean hasSameContent(PropertyKey other) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java index 966d3eed8a..c36eeaf632 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/SchemaElement.java @@ -96,13 +96,22 @@ public Map userdata() { return Collections.unmodifiableMap(this.userdata); } + /** + * Add userdata. String values of {@link Userdata#CREATE_TIME} are + * normalized to {@link java.util.Date} and malformed strings are rejected. + */ public void userdata(String key, Object value) { E.checkArgumentNotNull(key, "userdata key"); E.checkArgumentNotNull(value, "userdata value"); this.userdata.put(key, value); } + /** + * Add userdata in bulk. String values of {@link Userdata#CREATE_TIME} are + * normalized to {@link java.util.Date} and malformed strings are rejected. + */ public void userdata(Userdata userdata) { + E.checkArgumentNotNull(userdata, "userdata"); this.userdata.putAll(userdata); } @@ -112,6 +121,7 @@ public void removeUserdata(String key) { } public void removeUserdata(Userdata userdata) { + E.checkArgumentNotNull(userdata, "userdata"); for (String key : userdata.keySet()) { this.userdata.remove(key); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/Userdata.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/Userdata.java index b13fbe2314..be8cd768e7 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/Userdata.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/Userdata.java @@ -23,6 +23,7 @@ import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.exception.NotAllowException; import org.apache.hugegraph.type.define.Action; +import org.apache.hugegraph.util.DateUtil; import org.apache.hugegraph.util.E; public class Userdata extends HashMap { @@ -39,6 +40,51 @@ public Userdata(Map map) { this.putAll(map); } + /** + * Normalizes the value before storing so the {@link #CREATE_TIME}-is-Date + * invariant holds regardless of how entries are added. + */ + @Override + public Object put(String key, Object value) { + return super.put(key, normalizeValue(key, value)); + } + + @Override + public void putAll(Map map) { + for (Map.Entry e : map.entrySet()) { + this.put(e.getKey(), e.getValue()); + } + } + + /** + * Normalize internal userdata values whose runtime type can diverge from + * their serialized form. The only such key today is {@link #CREATE_TIME}: + * it is written as a {@link java.util.Date} but persisted as a formatted + * JSON string by the backend serializers, and Jackson cannot re-type a + * value to {@code Date} when the target is a raw {@code Map}. This method + * restores the original type after deserialization. Idempotent for values + * already of the expected type. + *

      + * An empty string is passed through unchanged: it is the key-only + * placeholder used by the {@code eliminate()}/{@code DELETE} builder flow + * (e.g. {@code .userdata(CREATE_TIME, "").eliminate()}), where the value is + * ignored and only the key drives {@code removeUserdata}. Parsing it would + * fail before the eliminate path can apply its key-only semantics. + */ + public static Object normalizeValue(String key, Object value) { + if (CREATE_TIME.equals(key) && value instanceof String && + !((String) value).isEmpty()) { + try { + return DateUtil.parse((String) value); + } catch (RuntimeException e) { + throw new IllegalArgumentException(String.format( + "Invalid userdata '%s' value: '%s'", + CREATE_TIME, value), e); + } + } + return value; + } + public static void check(Userdata userdata, Action action) { if (userdata == null) { return; diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java index 410b094fb9..32937a2cf0 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/EdgeLabelBuilder.java @@ -61,7 +61,7 @@ public class EdgeLabelBuilder extends AbstractBuilder private Set properties; private List sortKeys; private Set nullableKeys; - private long ttl; + private Long ttl; private String ttlStartTime; private Boolean enableLabelIndex; private Userdata userdata; @@ -80,7 +80,7 @@ public EdgeLabelBuilder(ISchemaTransaction transaction, this.properties = new HashSet<>(); this.sortKeys = new ArrayList<>(); this.nullableKeys = new HashSet<>(); - this.ttl = 0L; + this.ttl = null; this.ttlStartTime = null; this.enableLabelIndex = null; this.userdata = new Userdata(); @@ -122,11 +122,7 @@ public EdgeLabel build() { } edgeLabel.frequency(this.frequency == Frequency.DEFAULT ? Frequency.SINGLE : this.frequency); - edgeLabel.ttl(this.ttl); - if (this.ttlStartTime != null) { - edgeLabel.ttlStartTime(this.graph().propertyKey( - this.ttlStartTime).id()); - } + this.updateTTL(edgeLabel); edgeLabel.enableLabelIndex(this.enableLabelIndex == null || this.enableLabelIndex); for (String key : this.properties) { @@ -209,7 +205,7 @@ public EdgeLabel create() { this.checkSortKeys(); this.checkNullableKeys(Action.INSERT); Userdata.check(this.userdata, Action.INSERT); - this.checkTtl(); + this.checkTTL(); this.checkUserdata(Action.INSERT); edgeLabel = this.build(); @@ -312,6 +308,7 @@ public EdgeLabel append() { PropertyKey propertyKey = this.graph().propertyKey(key); edgeLabel.nullableKey(propertyKey.id()); } + this.updateTTL(edgeLabel); edgeLabel.userdata(this.userdata); this.graph().updateEdgeLabel(edgeLabel); return edgeLabel; @@ -670,7 +667,35 @@ private void checkStableVars() { } } - private void checkTtl() { + /** + * Update TTL in two cases: + * 1) ttl > 0L: set or change a positive TTL + * 2) ttl == 0L and existing ttl > 0L: explicitly clear an existing TTL + * This allows removing TTL from a label that previously had TTL configured. + * Note: ttl == null means not set, so we skip the update. + */ + private void updateTTL(EdgeLabel edgeLabel) { + if (this.ttl == null) { + return; + } + if (this.ttl > 0L) { + edgeLabel.ttl(this.ttl); + if (this.ttlStartTime != null) { + edgeLabel.ttlStartTime(this.graph().propertyKey(this.ttlStartTime).id()); + } + } else if (this.ttl == 0L && edgeLabel.ttl() > 0L) { + // Clear TTL and ttlStartTime + edgeLabel.ttl(0L); + edgeLabel.ttlStartTime(IdGenerator.ZERO); + } + } + + private void checkTTL() { + if (this.ttl == null) { + E.checkArgument(this.ttlStartTime == null, + "Can't set ttl start time if ttl is not set"); + return; + } E.checkArgument(this.ttl >= 0, "The ttl must be >= 0, but got: %s", this.ttl); if (this.ttl == 0L) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java index 53b6cabddb..4962646209 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/schema/builder/VertexLabelBuilder.java @@ -52,7 +52,7 @@ public class VertexLabelBuilder extends AbstractBuilder implements VertexLabel.B private final Set properties; private final List primaryKeys; private final Set nullableKeys; - private long ttl; + private Long ttl; private String ttlStartTime; private Boolean enableLabelIndex; private final Userdata userdata; @@ -68,7 +68,7 @@ public VertexLabelBuilder(ISchemaTransaction transaction, this.properties = new HashSet<>(); this.primaryKeys = new ArrayList<>(); this.nullableKeys = new HashSet<>(); - this.ttl = 0L; + this.ttl = null; this.ttlStartTime = null; this.enableLabelIndex = null; this.userdata = new Userdata(); @@ -99,13 +99,8 @@ public VertexLabel build() { this.id, this.name); VertexLabel vertexLabel = new VertexLabel(this.graph(), id, this.name); vertexLabel.idStrategy(this.idStrategy); - vertexLabel.enableLabelIndex(this.enableLabelIndex == null || - this.enableLabelIndex); - vertexLabel.ttl(this.ttl); - if (this.ttlStartTime != null) { - vertexLabel.ttlStartTime(this.graph().propertyKey( - this.ttlStartTime).id()); - } + vertexLabel.enableLabelIndex(this.enableLabelIndex == null || this.enableLabelIndex); + this.updateTTL(vertexLabel); // Assign properties for (String key : this.properties) { PropertyKey propertyKey = this.graph().propertyKey(key); @@ -142,7 +137,7 @@ public VertexLabel create() { this.checkIdStrategy(); this.checkNullableKeys(Action.INSERT); Userdata.check(this.userdata, Action.INSERT); - this.checkTtl(); + this.checkTTL(); this.checkUserdata(Action.INSERT); vertexLabel = this.build(); @@ -225,6 +220,7 @@ public VertexLabel append() { PropertyKey propertyKey = this.graph().propertyKey(key); vertexLabel.nullableKey(propertyKey.id()); } + this.updateTTL(vertexLabel); vertexLabel.userdata(this.userdata); this.graph().updateVertexLabel(vertexLabel); return vertexLabel; @@ -276,8 +272,7 @@ public VertexLabelBuilder id(long id) { @Override public VertexLabelBuilder idStrategy(IdStrategy idStrategy) { - E.checkArgument(this.idStrategy == IdStrategy.DEFAULT || - this.idStrategy == idStrategy, + E.checkArgument(this.idStrategy == IdStrategy.DEFAULT || this.idStrategy == idStrategy, "Not allowed to change id strategy for " + "vertex label '%s'", this.name); this.idStrategy = idStrategy; @@ -434,18 +429,15 @@ private void checkNullableKeys(Action action) { if (action == Action.ELIMINATE) { if (!this.nullableKeys.isEmpty()) { throw new NotAllowException( - "Not support to eliminate nullableKeys " + - "for vertex label currently"); + "Not support to eliminate nullableKeys for vertex label currently"); } return; } VertexLabel vertexLabel = this.vertexLabelOrNull(this.name); // The originProps is empty when firstly create vertex label - List originProps = vertexLabel == null ? - ImmutableList.of() : - this.graph() - .mapPkId2Name(vertexLabel.properties()); + List originProps = vertexLabel == null ? ImmutableList.of() : + this.graph().mapPkId2Name(vertexLabel.properties()); Set appendProps = this.properties; E.checkArgument(CollectionUtil.union(originProps, appendProps) @@ -454,10 +446,8 @@ private void checkNullableKeys(Action action) { "must belong to the origin/new properties: %s/%s", this.nullableKeys, originProps, appendProps); - List primaryKeys = vertexLabel == null ? - this.primaryKeys : - this.graph() - .mapPkId2Name(vertexLabel.primaryKeys()); + List primaryKeys = vertexLabel == null ? this.primaryKeys : + this.graph().mapPkId2Name(vertexLabel.primaryKeys()); E.checkArgument(!CollectionUtil.hasIntersection(primaryKeys, this.nullableKeys), "The nullableKeys: %s are not allowed to " + @@ -465,11 +455,9 @@ private void checkNullableKeys(Action action) { this.nullableKeys, primaryKeys, this.name); if (action == Action.APPEND) { - Collection newAddedProps = CollectionUtils.subtract( - appendProps, originProps); + Collection newAddedProps = CollectionUtils.subtract(appendProps, originProps); E.checkArgument(this.nullableKeys.containsAll(newAddedProps), - "The new added properties: %s must be nullable", - newAddedProps); + "The new added properties: %s must be nullable", newAddedProps); } } @@ -498,8 +486,7 @@ private void checkIdStrategy() { "when using '%s' id strategy", strategy); break; default: - throw new AssertionError(String.format( - "Unknown id strategy '%s'", strategy)); + throw new AssertionError(String.format("Unknown id strategy '%s'", strategy)); } if (this.idStrategy == IdStrategy.PRIMARY_KEY) { this.checkPrimaryKeys(); @@ -546,7 +533,35 @@ private void checkStableVars() { } } - private void checkTtl() { + /** + * Update TTL in two cases: + * 1) ttl > 0L: set or change a positive TTL + * 2) ttl == 0L and existing ttl > 0L: explicitly clear an existing TTL + * This allows removing TTL from a label that previously had TTL configured. + * Note: ttl == null means not set, so we skip the update. + */ + private void updateTTL(VertexLabel vertexLabel) { + if (this.ttl == null) { + return; + } + if (this.ttl > 0L) { + vertexLabel.ttl(this.ttl); + if (this.ttlStartTime != null) { + vertexLabel.ttlStartTime(this.graph().propertyKey(this.ttlStartTime).id()); + } + } else if (this.ttl == 0L && vertexLabel.ttl() > 0L) { + // Clear TTL and ttlStartTime + vertexLabel.ttl(0L); + vertexLabel.ttlStartTime(IdGenerator.ZERO); + } + } + + private void checkTTL() { + if (this.ttl == null) { + E.checkArgument(this.ttlStartTime == null, + "Can't set ttl start time if ttl is not set"); + return; + } E.checkArgument(this.ttl >= 0, "The ttl must be >= 0, but got: %s", this.ttl); if (this.ttl == 0L) { @@ -588,8 +603,7 @@ private void checkUserdata(Action action) { // pass break; default: - throw new AssertionError(String.format( - "Unknown schema action '%s'", action)); + throw new AssertionError(String.format("Unknown schema action '%s'", action)); } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java index 6e76913935..da43bcd80c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeIndex.java @@ -213,8 +213,8 @@ public static Id formatIndexId(HugeType type, Id indexLabelId, String strIndexLabelId = IdGenerator.asStoredString(indexLabelId); return SplicingIdGenerator.splicing(type.string(), strIndexLabelId, value); } else { - assert type.isRangeIndex(); - int length = type.isRange4Index() ? 4 : 8; + assert (type.isRangeIndex() || type.isVectorIndex()); + int length = type.isRange4Index() || type.isVectorIndex() ? 4 : 8; BytesBuffer buffer = BytesBuffer.allocate(HUGE_TYPE_CODE_LENGTH + 4 + length); buffer.write(type.code()); buffer.writeInt(SchemaElement.schemaId(indexLabelId)); @@ -241,7 +241,7 @@ public static HugeIndex parseIndexId(HugeGraph graph, HugeType type, indexLabel = IndexLabel.label(graph, label); values = parts[2]; } else { - assert type.isRange4Index() || type.isRange8Index(); + assert type.isRange4Index() || type.isRange8Index() || type.isVectorIndex(); final int labelLength = 4; E.checkState(id.length > labelLength, "Invalid range index id"); BytesBuffer buffer = BytesBuffer.wrap(id); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeVectorIndexMap.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeVectorIndexMap.java new file mode 100644 index 0000000000..46c5128622 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeVectorIndexMap.java @@ -0,0 +1,127 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.structure; + +import java.util.concurrent.atomic.AtomicLong; + +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.serializer.BytesBuffer; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.schema.SchemaElement; +import org.apache.hugegraph.type.define.IndexVectorState; +import org.apache.hugegraph.util.E; + +public class HugeVectorIndexMap extends HugeIndex{ + + private static final AtomicLong VECTOR_INDEX_SEQUENCE = new AtomicLong(0); + private long vector_sequence; + private IndexVectorState vectorState; + private IndexVectorState dirtyPrefix; + + public HugeVectorIndexMap(HugeGraph graph, IndexLabel indexLabel){ + super(graph, indexLabel); + this.vectorState = IndexVectorState.BUILDING; + vector_sequence = getGlobalNextSequence(); + } + + public HugeVectorIndexMap(HugeGraph graph, IndexLabel indexLabel, boolean removed){ + super(graph, indexLabel); + this.vectorState = removed ? IndexVectorState.DELETING : IndexVectorState.BUILDING; + vector_sequence = getGlobalNextSequence(); + } + + public HugeVectorIndexMap(HugeGraph graph, IndexLabel indexLabel, IndexVectorState state){ + super(graph, indexLabel); + this.vectorState = state; + vector_sequence = getGlobalNextSequence(); + } + + public long sequence(){ + return this.vector_sequence; + } + + public void sequence(long sequence){ + this.vector_sequence = sequence; + } + + public long globalSequence(){ + return VECTOR_INDEX_SEQUENCE.get(); + } + + public static long getGlobalNextSequence(){ + VECTOR_INDEX_SEQUENCE.incrementAndGet(); + return VECTOR_INDEX_SEQUENCE.get(); + } + + public IndexVectorState vectorState(){ + return this.vectorState; + } + + public void setVectorState(IndexVectorState vectorState) { this.vectorState = vectorState; } + + // return the sequence index id + public Id sequenceId(){ + return formatSequenceId(indexLabelId(), this.sequence()); + } + + public Id dirtyLabelId(){ + return formatDirtyLabelId(indexLabelId()); + } + + public static Id formatSequenceId(Id indexLabelId, long sequence){ + // notDirtyPrefix(1byte) + indexlabelId(4byte) + sequence(8byte) + int length = 1 + 4 + 8; + BytesBuffer buffer = BytesBuffer.allocate(length); + buffer.write(0); + buffer.writeInt(SchemaElement.schemaId(indexLabelId)); + buffer.writeLong(sequence); + return buffer.asId(); + } + + public static HugeVectorIndexMap parseSequenceId(HugeGraph graph, byte[] id){ + + final int prefixLength = 1; + final int labelLength = 4; + final int sequenceLength = 8; + BytesBuffer buffer = BytesBuffer.wrap(id); + + E.checkState(id.length == prefixLength + labelLength + sequenceLength, + "Invalid sequence " + "index id"); + E.checkState(buffer.read() == 0, "Invalid sequence index id"); + + Id label = IdGenerator.of(buffer.readInt()); + IndexLabel indexLabel = IndexLabel.label(graph, label); + + long sequence = buffer.readLong(); + HugeVectorIndexMap indexMap = new HugeVectorIndexMap(graph, indexLabel); + indexMap.sequence(sequence); + return indexMap; + } + + public Id formatDirtyLabelId(Id indexLabelId){ + int length = 1 + 4; + BytesBuffer buffer = BytesBuffer.allocate(length); + buffer.write(IndexVectorState.DIRTY_PREFIX.code()); + buffer.writeInt(SchemaElement.schemaId(indexLabelId)); + return buffer.asId(); + } + + +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java index bcef869017..1560ec0b8f 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/task/ServerInfoManager.java @@ -29,6 +29,7 @@ import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.HugeGraphParams; import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.backend.page.PageInfo; import org.apache.hugegraph.backend.query.Condition; import org.apache.hugegraph.backend.query.ConditionQuery; @@ -104,7 +105,9 @@ public synchronized boolean close() { public synchronized void initServerInfo(GlobalMasterInfo nodeInfo) { E.checkArgument(nodeInfo != null, "The global node info can't be null"); - Id serverId = nodeInfo.nodeId(); + this.globalNodeInfo = nodeInfo; + + Id serverId = this.selfNodeId(); HugeServerInfo existed = this.serverInfo(serverId); if (existed != null && existed.alive()) { final long now = DateUtil.now().getTime(); @@ -137,8 +140,6 @@ public synchronized void initServerInfo(GlobalMasterInfo nodeInfo) { } while (page != null); } - this.globalNodeInfo = nodeInfo; - // TODO: save ServerInfo to AuthServer this.saveServerInfo(this.selfNodeId(), this.selfNodeRole()); } @@ -162,7 +163,9 @@ public Id selfNodeId() { if (this.globalNodeInfo == null) { return null; } - return this.globalNodeInfo.nodeId(); + // Scope server id to graph to avoid cross-graph collision + return IdGenerator.of(this.graph.spaceGraphName() + "/" + + this.globalNodeInfo.nodeId().asString()); } public NodeRole selfNodeRole() { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/HugeCountStrategy.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/HugeCountStrategy.java new file mode 100644 index 0000000000..5a8c468a44 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/HugeCountStrategy.java @@ -0,0 +1,272 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.hugegraph.traversal.optimize; + +import java.util.Collection; +import java.util.Collections; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.function.BiPredicate; + +import org.apache.tinkerpop.gremlin.process.traversal.Compare; +import org.apache.tinkerpop.gremlin.process.traversal.Contains; +import org.apache.tinkerpop.gremlin.process.traversal.P; +import org.apache.tinkerpop.gremlin.process.traversal.Step; +import org.apache.tinkerpop.gremlin.process.traversal.Traversal; +import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy; +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__; +import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent; +import org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.filter.ConnectiveStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.filter.IsStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.filter.NotStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeGlobalStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.map.CountGlobalStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.IdentityStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; +import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversalStrategy; +import org.apache.tinkerpop.gremlin.process.traversal.util.ConnectiveP; +import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper; + +/** + * HugeGraph keeps a local copy of TinkerPop's CountStrategy so we can + * safely patch negative-threshold handling without waiting for a full + * dependency upgrade. Count() never yields a negative result, so any + * optimization that turns a negative bound into not() or a negative range + * changes the traversal semantics. + */ +public final class HugeCountStrategy + extends AbstractTraversalStrategy + implements TraversalStrategy.OptimizationStrategy { + + private static final Map RANGE_PREDICATES = + new HashMap() {{ + put(Contains.within, 1L); + put(Contains.without, 0L); + }}; + private static final Set INCREASED_OFFSET_SCALAR_PREDICATES = + EnumSet.of(Compare.eq, Compare.neq, Compare.lte, Compare.gt); + + private static final HugeCountStrategy INSTANCE = new HugeCountStrategy(); + + private HugeCountStrategy() { + } + + public static HugeCountStrategy instance() { + return INSTANCE; + } + + @Override + @SuppressWarnings({"rawtypes", "unchecked"}) + public void apply(final Traversal.Admin traversal) { + final TraversalParent parent = traversal.getParent(); + int size = traversal.getSteps().size(); + Step prev = null; + for (int i = 0; i < size; i++) { + final Step curr = traversal.getSteps().get(i); + if (i < size - 1 && doStrategy(curr)) { + final IsStep isStep = (IsStep) traversal.getSteps().get(i + 1); + final P isStepPredicate = isStep.getPredicate(); + Long highRange = null; + boolean useNotStep = false; + boolean dismissCountIs = false; + boolean hasNegativeCompareBound = false; + + for (P p : isStepPredicate instanceof ConnectiveP ? + ((ConnectiveP) isStepPredicate).getPredicates() : + Collections.singletonList(isStepPredicate)) { + final Object value = p.getValue(); + final BiPredicate predicate = p.getBiPredicate(); + if (value instanceof Number) { + final long highRangeOffset = + INCREASED_OFFSET_SCALAR_PREDICATES.contains(predicate) ? + 1L : 0L; + final Long highRangeCandidate = + (long) Math.ceil(((Number) value).doubleValue()) + + highRangeOffset; + + if ((predicate.equals(Compare.gt) || + predicate.equals(Compare.gte) || + predicate.equals(Compare.lt) || + predicate.equals(Compare.lte)) && + highRangeCandidate < 1L) { + hasNegativeCompareBound = true; + } + + final boolean update = highRange == null || + highRangeCandidate > highRange; + if (update) { + if (parent instanceof EmptyStep) { + useNotStep = false; + } else if (parent instanceof RepeatStep) { + final RepeatStep repeatStep = (RepeatStep) parent; + dismissCountIs = useNotStep = + Objects.equals(traversal, + repeatStep.getUntilTraversal()) || + Objects.equals(traversal, + repeatStep.getEmitTraversal()); + } else { + dismissCountIs = useNotStep = + parent instanceof FilterStep || + parent instanceof SideEffectStep; + } + highRange = highRangeCandidate; + useNotStep &= curr.getLabels().isEmpty() && + isStep.getLabels().isEmpty() && + isStep.getNextStep() instanceof EmptyStep && + ((highRange <= 1L && + predicate.equals(Compare.lt)) || + (highRange == 1L && + (predicate.equals(Compare.eq) || + predicate.equals(Compare.lte)))); + dismissCountIs &= curr.getLabels().isEmpty() && + isStep.getLabels().isEmpty() && + isStep.getNextStep() instanceof EmptyStep && + (highRange == 1L && + (predicate.equals(Compare.gt) || + predicate.equals(Compare.gte))); + } + if (hasNegativeCompareBound) { + /* + * TINKERPOP-2893: + * count() is always >= 0, so optimizations like + * is(lt(-3)) -> not(...) are not semantics-safe. + */ + useNotStep = false; + dismissCountIs = false; + } + } else { + final Long highRangeOffset = RANGE_PREDICATES.get(predicate); + if (value instanceof Collection && highRangeOffset != null) { + final Object high = Collections.max((Collection) value); + if (high instanceof Number) { + final Long highRangeCandidate = + ((Number) high).longValue() + highRangeOffset; + final boolean update = highRange == null || + highRangeCandidate > highRange; + if (update) { + highRange = highRangeCandidate; + } + } + } + } + } + + /* + * HugeGraph extracts RangeGlobalStep into backend queries. A + * negative upper bound is never useful for count(), and would + * become an invalid backend range like [0, -3). + */ + if (highRange != null && highRange < 0L) { + highRange = null; + } + + if (highRange != null) { + if (useNotStep || dismissCountIs) { + traversal.asAdmin().removeStep(isStep); + traversal.asAdmin().removeStep(curr); + size -= 2; + if (!dismissCountIs) { + final TraversalParent p; + if ((p = traversal.getParent()) instanceof FilterStep && + !(p instanceof ConnectiveStep)) { + final Step filterStep = parent.asStep(); + final Traversal.Admin parentTraversal = + filterStep.getTraversal(); + final Step notStep = new NotStep<>( + parentTraversal, + traversal.getSteps().isEmpty() ? + __.identity() : traversal); + filterStep.getLabels().forEach(notStep::addLabel); + TraversalHelper.replaceStep(filterStep, notStep, + parentTraversal); + } else { + final Traversal.Admin inner; + if (prev != null) { + inner = __.start().asAdmin(); + for (;;) { + final Step pp = prev.getPreviousStep(); + inner.addStep(0, prev); + if (pp instanceof EmptyStep || + pp instanceof GraphStep || + !(prev instanceof FilterStep || + prev instanceof SideEffectStep)) { + break; + } + traversal.removeStep(prev); + prev = pp; + size--; + } + } else { + inner = __.identity().asAdmin(); + } + if (prev != null) { + TraversalHelper.replaceStep( + prev, + new NotStep<>(traversal, inner), + traversal); + } else { + traversal.asAdmin().addStep( + new NotStep<>(traversal, inner)); + } + } + } else if (size == 0) { + final Step parentStep = traversal.getParent().asStep(); + if (!(parentStep instanceof EmptyStep)) { + final Traversal.Admin parentTraversal = + parentStep.getTraversal(); + TraversalHelper.replaceStep( + parentStep, + new IdentityStep<>(parentTraversal), + parentTraversal); + } + } + } else { + TraversalHelper.insertBeforeStep( + new RangeGlobalStep<>(traversal, 0L, highRange), + curr, traversal); + } + i++; + } + } + prev = curr; + } + } + + private boolean doStrategy(final Step step) { + if (!(step instanceof CountGlobalStep) || + !(step.getNextStep() instanceof IsStep) || + step.getPreviousStep() instanceof RangeGlobalStep) { + return false; + } + + final Step parent = step.getTraversal().getParent().asStep(); + return (parent instanceof FilterStep || parent.getLabels().isEmpty()) && + !(parent.getNextStep() instanceof MatchStep.MatchEndStep && + ((MatchStep.MatchEndStep) parent.getNextStep()) + .getMatchKey().isPresent()); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java index 11a5c0cee4..7b68f71778 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtil.java @@ -39,13 +39,16 @@ import org.apache.hugegraph.backend.query.Condition; import org.apache.hugegraph.backend.query.ConditionQuery; import org.apache.hugegraph.backend.query.Query; +import org.apache.hugegraph.exception.NotFoundException; import org.apache.hugegraph.exception.NotSupportException; import org.apache.hugegraph.iterator.FilterIterator; +import org.apache.hugegraph.schema.IndexLabel; import org.apache.hugegraph.schema.PropertyKey; import org.apache.hugegraph.schema.SchemaLabel; import org.apache.hugegraph.structure.HugeElement; import org.apache.hugegraph.structure.HugeProperty; import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.DataType; import org.apache.hugegraph.type.define.Directions; import org.apache.hugegraph.type.define.HugeKeys; import org.apache.hugegraph.util.CollectionUtil; @@ -66,6 +69,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeGlobalStep; import org.apache.tinkerpop.gremlin.process.traversal.step.map.CountGlobalStep; import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep; import org.apache.tinkerpop.gremlin.process.traversal.step.map.MaxGlobalStep; import org.apache.tinkerpop.gremlin.process.traversal.step.map.MeanGlobalStep; import org.apache.tinkerpop.gremlin.process.traversal.step.map.MinGlobalStep; @@ -165,38 +169,324 @@ public static void trySetGraph(Step step, HugeGraph graph) { public static void extractHasContainer(HugeGraphStep newStep, Traversal.Admin traversal) { - Step step = newStep; - do { - step = step.getNextStep(); + Step step = newStep.getNextStep(); + while (step instanceof HasStep || step instanceof NoOpBarrierStep) { + Step nextStep = step.getNextStep(); if (step instanceof HasStep) { HasContainerHolder holder = (HasContainerHolder) step; - for (HasContainer has : holder.getHasContainers()) { - if (!GraphStep.processHasContainerIds(newStep, has)) { - newStep.addHasContainer(has); + /* + * Range/neq predicates before match() may trigger a no-index + * query after MatchStep reorders filters. Keep known-indexed + * boolean predicates pushed down, and leave the rest for + * TinkerPop to evaluate. + */ + if (followedByMatchStep(step) && + hasUnusableMatchPredicate(newStep, holder)) { + List extracted = + extractUsableHasContainers(newStep, holder); + for (HasContainer has : extracted) { + holder.removeHasContainer(has); } + if (holder.getHasContainers().isEmpty()) { + TraversalHelper.copyLabels(step, step.getPreviousStep(), + false); + traversal.removeStep(step); + } + step = nextStep; + continue; + } + if (extractHasContainers(newStep, holder)) { + TraversalHelper.copyLabels(step, step.getPreviousStep(), false); + traversal.removeStep(step); } - TraversalHelper.copyLabels(step, step.getPreviousStep(), false); - traversal.removeStep(step); } - } while (step instanceof HasStep || step instanceof NoOpBarrierStep); + step = nextStep; + } + } + + private static boolean followedByMatchStep(Step step) { + Step next = step.getNextStep(); + while (next instanceof HasStep || + next instanceof NoOpBarrierStep || + next instanceof IdentityStep) { + next = next.getNextStep(); + } + return next instanceof MatchStep; + } + + private static boolean hasUnusableMatchPredicate(HugeGraphStep step, + HasContainerHolder holder) { + HugeGraph graph = tryGetGraph(step); + for (HasContainer has : holder.getHasContainers()) { + if (!hasMatchIndexSensitivePredicate(has)) { + continue; + } + if (graph == null || !hasUsableMatchIndex(graph, step, has)) { + return true; + } + } + return false; + } + + private static List extractUsableHasContainers( + HugeGraphStep step, HasContainerHolder holder) { + List extracted = new ArrayList<>(); + HugeGraph graph = tryGetGraph(step); + for (HasContainer has : holder.getHasContainers()) { + if (hasMatchIndexSensitivePredicate(has) && + (graph == null || !hasUsableMatchIndex(graph, step, has))) { + continue; + } + if (!canExtractHasContainer(graph, has)) { + continue; + } + if (!GraphStep.processHasContainerIds(step, has)) { + step.addHasContainer(has); + } + extracted.add(has); + } + return extracted; + } + + private static boolean hasMatchIndexSensitivePredicate(HasContainer has) { + if (hasNullPredicate(has)) { + return true; + } + List> predicates = new ArrayList<>(); + collectPredicates(predicates, ImmutableList.of(has.getPredicate())); + for (P pred : predicates) { + BiPredicate bp = pred.getBiPredicate(); + if (bp == Compare.neq || + bp == Compare.gt || bp == Compare.gte || + bp == Compare.lt || bp == Compare.lte) { + return true; + } + } + return false; + } + + private static boolean hasUsableMatchIndex(HugeGraph graph, + HugeGraphStep step, + HasContainer has) { + if (isSysProp(has.getKey())) { + return false; + } + + PropertyKey pkey; + try { + pkey = graph.propertyKey(has.getKey()); + } catch (NotFoundException e) { + return false; + } + if (!hasOnlyUsableNeqPredicates(pkey, has)) { + return false; + } + if (!canExtractHasContainer(graph, has)) { + return false; + } + + Collection schemaLabels = step.returnsVertex() ? + graph.vertexLabels() : + graph.edgeLabels(); + boolean seen = false; + for (SchemaLabel schemaLabel : schemaLabels) { + if (!schemaLabel.properties().contains(pkey.id())) { + continue; + } + seen = true; + if (pkey.dataType() == DataType.BOOLEAN && + !hasBooleanIndex(graph, schemaLabel, pkey)) { + return false; + } + if (pkey.dataType().isNumber() && + (!hasOnlyRangePredicates(has) || + !hasRangeIndex(graph, schemaLabel, pkey))) { + return false; + } + if (pkey.dataType() != DataType.BOOLEAN && + !pkey.dataType().isNumber()) { + return false; + } + } + return seen; + } + + private static boolean hasOnlyUsableNeqPredicates(PropertyKey pkey, + HasContainer has) { + if (hasNullPredicate(has)) { + return false; + } + List> predicates = new ArrayList<>(); + collectPredicates(predicates, ImmutableList.of(has.getPredicate())); + for (P pred : predicates) { + if (pred.getBiPredicate() != Compare.neq) { + continue; + } + if (pkey.dataType() == DataType.BOOLEAN && + pred.getValue() instanceof Boolean) { + continue; + } + return false; + } + return true; + } + + private static boolean hasNullPredicate(HasContainer has) { + List> predicates = new ArrayList<>(); + collectPredicates(predicates, ImmutableList.of(has.getPredicate())); + for (P pred : predicates) { + if (pred.getValue() == null) { + return true; + } + } + return false; + } + + private static boolean hasBooleanIndex(HugeGraph graph, + SchemaLabel schemaLabel, + PropertyKey pkey) { + for (Id id : schemaLabel.indexLabels()) { + IndexLabel indexLabel = indexLabelOrNull(graph, id); + if (indexLabel == null || + !matchSingleFieldIndex(indexLabel, pkey)) { + continue; + } + if (indexLabel.indexType().isSecondary()) { + return true; + } + } + return false; + } + + private static boolean hasRangeIndex(HugeGraph graph, + SchemaLabel schemaLabel, + PropertyKey pkey) { + for (Id id : schemaLabel.indexLabels()) { + IndexLabel indexLabel = indexLabelOrNull(graph, id); + if (indexLabel == null || + !matchSingleFieldIndex(indexLabel, pkey)) { + continue; + } + if (indexLabel.indexType().isRange()) { + return true; + } + } + return false; + } + + static IndexLabel indexLabelOrNull(HugeGraph graph, Id id) { + try { + return graph.indexLabel(id); + } catch (IllegalArgumentException e) { + return null; + } + } + + private static boolean matchSingleFieldIndex(IndexLabel indexLabel, + PropertyKey pkey) { + return indexLabel.indexFields().size() == 1 && + indexLabel.indexField().equals(pkey.id()); + } + + private static boolean hasOnlyRangePredicates(HasContainer has) { + List> predicates = new ArrayList<>(); + collectPredicates(predicates, ImmutableList.of(has.getPredicate())); + for (P pred : predicates) { + BiPredicate bp = pred.getBiPredicate(); + if (bp != Compare.gt && bp != Compare.gte && + bp != Compare.lt && bp != Compare.lte) { + return false; + } + } + return true; } public static void extractHasContainer(HugeVertexStep newStep, Traversal.Admin traversal) { Step step = newStep; do { + Step nextStep = step.getNextStep(); if (step instanceof HasStep) { HasContainerHolder holder = (HasContainerHolder) step; - for (HasContainer has : holder.getHasContainers()) { - newStep.addHasContainer(has); + if (extractHasContainers(newStep, holder)) { + TraversalHelper.copyLabels(step, step.getPreviousStep(), false); + traversal.removeStep(step); } - TraversalHelper.copyLabels(step, step.getPreviousStep(), false); - traversal.removeStep(step); } - step = step.getNextStep(); + step = nextStep; } while (step instanceof HasStep || step instanceof NoOpBarrierStep); } + private static boolean extractHasContainers(HugeGraphStep newStep, + HasContainerHolder holder) { + HugeGraph graph = TraversalUtil.tryGetGraph(newStep); + if (!canExtractHasContainers(graph, holder)) { + return false; + } + for (HasContainer has : holder.getHasContainers()) { + if (!GraphStep.processHasContainerIds(newStep, has)) { + newStep.addHasContainer(has); + } + } + return true; + } + + private static boolean extractHasContainers(HugeVertexStep newStep, + HasContainerHolder holder) { + HugeGraph graph = TraversalUtil.tryGetGraph(newStep); + if (!canExtractHasContainers(graph, holder)) { + return false; + } + for (HasContainer has : holder.getHasContainers()) { + newStep.addHasContainer(has); + } + return true; + } + + private static boolean canExtractHasContainers(HugeGraph graph, + HasContainerHolder holder) { + for (HasContainer has : holder.getHasContainers()) { + if (!canExtractHasContainer(graph, has)) { + return false; + } + } + return true; + } + + static boolean canExtractHasContainer(HugeGraph graph, + HasContainer has) { + if (isSysProp(has.getKey())) { + return true; + } + if (graph == null) { + return false; + } + + PropertyKey pkey; + try { + pkey = graph.propertyKey(has.getKey()); + } catch (NotFoundException e) { + return false; + } + if (hasNullPredicate(has)) { + return false; + } + if (!pkey.dataType().isText()) { + return true; + } + + List> predicates = new ArrayList<>(); + collectPredicates(predicates, ImmutableList.of(has.getPredicate())); + for (P pred : predicates) { + BiPredicate bp = pred.getBiPredicate(); + if (bp == Compare.gt || bp == Compare.gte || + bp == Compare.lt || bp == Compare.lte) { + return false; + } + } + return true; + } + public static void extractOrder(Step newStep, Traversal.Admin traversal) { Step step = newStep; @@ -419,9 +709,9 @@ public static Condition convOr(HugeGraph graph, return cond; } - private static Condition.Relation convCompare2Relation(HugeGraph graph, - HugeType type, - HasContainer has) { + private static Condition convCompare2Relation(HugeGraph graph, + HugeType type, + HasContainer has) { assert type.isGraph(); BiPredicate bp = has.getPredicate().getBiPredicate(); assert bp instanceof Compare; @@ -459,9 +749,9 @@ private static Condition.Relation convCompare2SyspropRelation(HugeGraph graph, } } - private static Condition.Relation convCompare2UserpropRelation(HugeGraph graph, - HugeType type, - HasContainer has) { + private static Condition convCompare2UserpropRelation(HugeGraph graph, + HugeType type, + HasContainer has) { BiPredicate bp = has.getPredicate().getBiPredicate(); assert bp instanceof Compare; @@ -469,6 +759,11 @@ private static Condition.Relation convCompare2UserpropRelation(HugeGraph graph, PropertyKey pkey = graph.propertyKey(key); Id pkeyId = pkey.id(); Object value = validPropertyValue(has.getValue(), pkey); + if (pkey.dataType() == DataType.BOOLEAN && + value instanceof Boolean) { + return convCompare2BooleanUserpropRelation((Compare) bp, pkeyId, + (Boolean) value); + } switch ((Compare) bp) { case eq: @@ -488,6 +783,31 @@ private static Condition.Relation convCompare2UserpropRelation(HugeGraph graph, } } + private static Condition convCompare2BooleanUserpropRelation(Compare compare, + Id key, + Boolean value) { + switch (compare) { + case eq: + return Condition.eq(key, value); + case neq: + return Condition.eq(key, !value); + case gt: + return value ? Condition.in(key, ImmutableList.of()) : + Condition.eq(key, true); + case gte: + return value ? Condition.eq(key, true) : + Condition.in(key, ImmutableList.of(false, true)); + case lt: + return value ? Condition.eq(key, false) : + Condition.in(key, ImmutableList.of()); + case lte: + return value ? Condition.in(key, ImmutableList.of(false, true)) : + Condition.eq(key, false); + default: + throw new AssertionError(compare); + } + } + private static Condition convRelationType2Relation(HugeGraph graph, HugeType type, HasContainer has) { @@ -678,6 +998,10 @@ private static void updatePredicateValue(P predicate, PropertyKey pkey) { List> leafPredicates = new ArrayList<>(); collectPredicates(leafPredicates, ImmutableList.of(predicate)); for (P pred : leafPredicates) { + if (pred.getBiPredicate() == Compare.neq && + pred.getValue() == null) { + continue; + } Object value = validPropertyValue(pred.getValue(), pkey); pred.setValue(value); } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java index 6b5e7bd0a9..ea5f270a1b 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/HugeType.java @@ -64,10 +64,12 @@ public enum HugeType implements SerialEnum { SEARCH_INDEX(170, "AI"), SHARD_INDEX(175, "HI"), UNIQUE_INDEX(178, "UI"), - VECTOR_INDEX(180, "VI"), + VECTOR_INDEX_MAP(179, "VM"), + TASK(180, "T"), SERVER(181, "SERVER"), + VECTOR_SEQUENCE(182, "VS"), VARIABLE(185, "VA"), @@ -188,6 +190,10 @@ public boolean isUniqueIndex() { return this == UNIQUE_INDEX; } + public boolean isVectorIndex() { + return this == VECTOR_INDEX_MAP; + } + public boolean isVertexAggregateProperty() { return this == AGGR_PROPERTY_V; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/IndexType.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/IndexType.java index e6fe7caeef..d9f5da1c7e 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/IndexType.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/IndexType.java @@ -84,7 +84,7 @@ public HugeType type() { case UNIQUE: return HugeType.UNIQUE_INDEX; case VECTOR: - return HugeType.VECTOR_INDEX; + return HugeType.VECTOR_INDEX_MAP; default: throw new AssertionError(String.format( "Unknown index type '%s'", this)); diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/IndexVectorState.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/IndexVectorState.java new file mode 100644 index 0000000000..87df482b3d --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/IndexVectorState.java @@ -0,0 +1,68 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.type.define; + +public enum IndexVectorState implements SerialEnum{ + + // after written to vector map + BUILDING(1, "building"), + + // after flushed to disk + DISK_FLUSHED(2, "disk_flushed"), + + // after marked deleted + DELETING(3, "deleting"), + + DIRTY_PREFIX(4, "dirty_prefix"); + + private byte code = 0; + private String name = null; + + IndexVectorState(int code, String name) { + assert code < 256; + this.code = (byte) code; + this.name = name; + } + + static { + SerialEnum.register(IndexVectorState.class); + } + + @Override + public byte code(){ return code; } + + public String string() { + return this.name; + } + + public boolean isBuilding() { + return this == BUILDING; + } + + public boolean isDiskFlushed() { + return this == DISK_FLUSHED; + } + + public boolean isDeleting() { + return this == DELETING; + } + + public boolean isDirty() { + return this == DIRTY_PREFIX; + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/SerialEnum.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/SerialEnum.java index 471c0c2d70..b2470bd667 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/SerialEnum.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/type/define/SerialEnum.java @@ -64,5 +64,6 @@ static void registerInternalEnums() { SerialEnum.register(IdStrategy.class); SerialEnum.register(IndexType.class); SerialEnum.register(SchemaStatus.class); + SerialEnum.register(IndexVectorState.class); } } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/CompressUtil.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/CompressUtil.java index 0d41a70959..38175dea2c 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/CompressUtil.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/CompressUtil.java @@ -160,15 +160,26 @@ public static void decompressTar(String sourceFile, String outputDir, private static Path zipSlipProtect(ArchiveEntry entry, Path targetDir) throws IOException { - Path targetDirResolved = targetDir.resolve(entry.getName()); + return zipSlipProtect(entry.getName(), targetDir); + } + + private static Path zipSlipProtect(ZipEntry entry, Path targetDir) + throws IOException { + return zipSlipProtect(entry.getName(), targetDir); + } + + private static Path zipSlipProtect(String entryName, Path targetDir) + throws IOException { + + Path targetDirResolved = targetDir.resolve(entryName); + /* * Make sure normalized file still has targetDir as its prefix, * else throws exception */ Path normalizePath = targetDirResolved.normalize(); if (!normalizePath.startsWith(targetDir.normalize())) { - throw new IOException(String.format("Bad entry: %s", - entry.getName())); + throw new IOException(String.format("Bad entry: %s", entryName)); } return normalizePath; } @@ -220,9 +231,8 @@ public static void decompressZip(String sourceFile, String outputDir, ZipInputStream zis = new ZipInputStream(bis)) { ZipEntry entry; while ((entry = zis.getNextEntry()) != null) { - String fileName = entry.getName(); - File entryFile = new File(Paths.get(outputDir, fileName) - .toString()); + Path entryPath = zipSlipProtect(entry, Paths.get(outputDir)); + File entryFile = new File(entryPath.toString()); FileUtils.forceMkdir(entryFile.getParentFile()); try (FileOutputStream fos = new FileOutputStream(entryFile); BufferedOutputStream bos = new BufferedOutputStream(fos)) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/Consumers.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/Consumers.java index daa54ee958..f4a7671f35 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/Consumers.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/Consumers.java @@ -101,30 +101,56 @@ public void start(String name) { if (this.executor == null) { return; } + LOG.info("Starting {} workers[{}] with queue size {}...", this.workers, name, this.queueSize); + for (int i = 0; i < this.workers; i++) { - this.runningFutures.add( - this.executor.submit(new ContextCallable<>(this::runAndDone))); + // capture submission thread context HERE + ContextCallable task = new ContextCallable<>(this::runAndDone); + + // wrapper ensures latch always decremented even if ContextCallable fails + this.runningFutures.add(this.executor.submit(() -> this.safeRun(task))); + } + } + + private Void safeRun(ContextCallable task) { + try { + return task.call(); // may fail before/after runAndDone() + } catch (Exception e) { + // This exception is from ContextCallable wrapper (setContext/resetContext/delegate dispatch), + // not from runAndDone() business logic (that one is handled inside runAndDone()). + if (this.exception == null) { + this.exception = e; + LOG.error("Consumer worker failed in ContextCallable wrapper", e); + } else { + LOG.warn("Additional worker failure in ContextCallable wrapper; first exception already recorded", e); + } + this.exceptionHandle(e); + } finally { + this.latch.countDown(); } + return null; } private Void runAndDone() { try { this.run(); - } catch (Throwable e) { + } catch (Exception e) { if (e instanceof StopExecution) { this.queue.clear(); putQueueEnd(); } else { - // Only the first exception to one thread can be stored - this.exception = e; - LOG.error("Error when running task", e); + if (this.exception == null) { + this.exception = e; + LOG.error("Unhandled exception in consumer task", e); + } else { + LOG.warn("Additional exception in consumer task; first exception already recorded", e); + } } - exceptionHandle(e); + this.exceptionHandle(e); } finally { this.done(); - this.latch.countDown(); } return null; } diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/StringEncoding.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/StringEncoding.java index c8d831c9cc..7b10738580 100644 --- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/StringEncoding.java +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/StringEncoding.java @@ -36,6 +36,7 @@ public final class StringEncoding { private static final byte[] BYTES_EMPTY = new byte[0]; private static final String STRING_EMPTY = ""; private static final int BLOCK_SIZE = 4096; + private static final int BCRYPT_WORK_FACTOR = 10; static { final String ALG = "SHA-256"; @@ -140,7 +141,9 @@ public static String decompress(byte[] value, float bufferRatio) { } public static String hashPassword(String password) { - return BCrypt.hashpw(password, BCrypt.gensalt(4)); + // OWASP suggests 10 as a minimum and 12–14 for production; + // workFactor 12 is not used by default due to its 200+ ms cost. + return BCrypt.hashpw(password, BCrypt.gensalt(BCRYPT_WORK_FACTOR)); } public static boolean checkPassword(String candidatePassword, String dbPassword) { diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorRuntime.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorRuntime.java new file mode 100644 index 0000000000..643cc197ae --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorRuntime.java @@ -0,0 +1,218 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.JsonUtilCommon; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; + +import io.github.jbellis.jvector.disk.ReaderSupplier; +import io.github.jbellis.jvector.disk.SimpleMappedReader; +import io.github.jbellis.jvector.graph.GraphIndexBuilder; +import io.github.jbellis.jvector.graph.GraphSearcher; +import io.github.jbellis.jvector.graph.RandomAccessVectorValues; +import io.github.jbellis.jvector.graph.SearchResult; +import io.github.jbellis.jvector.graph.disk.OnDiskGraphIndex; +import io.github.jbellis.jvector.util.Bits; +import io.github.jbellis.jvector.vector.VectorSimilarityFunction; +import io.github.jbellis.jvector.vector.VectorizationProvider; +import io.github.jbellis.jvector.vector.types.VectorFloat; +import io.github.jbellis.jvector.vector.types.VectorTypeSupport; + +public class ServerVectorRuntime extends AbstractVectorRuntime { + + private static final Logger LOG = Log.logger(ServerVectorRuntime.class); + private HugeGraphParams graphParams = null; + + public ServerVectorRuntime(String basePath, HugeGraphParams graphParams) { + super(basePath); + this.graphParams = graphParams; + } + + @Override + public void update(Id vectorIndexLableId, Iterator records) { + IndexContext context = obtainContext(vectorIndexLableId); + + // deal with the records + while (records.hasNext()) { + VectorRecord record = records.next(); + if (record.isDeleted()) { + handleDelete(record, context); + continue; + } + handleBuilding(record, context); + } + } + + @Override + public Iterator search(Id indexLabelId, float[] queryVector, int topK) { + IndexContext context = obtainContext(indexLabelId); + LOG.debug("search: ilId={}, graphSize={}, topK={}", + indexLabelId, context.graphView().size(), topK); + VectorTypeSupport vectorTypeSupport = + VectorizationProvider.getInstance().getVectorTypeSupport(); + VectorFloat vector = vectorTypeSupport.createFloatVector(queryVector); + + RandomAccessVectorValues ravv = context.vectors; + + SearchResult sr = GraphSearcher.search(vector, + topK, // return top k result + ravv, + context.similarityFunction, + context.graphView(), + Bits.ALL); + + return Arrays.stream(sr.getNodes()).mapToInt(c -> c.node).iterator(); + } + + @Override + public boolean isUpdateMetaData(Id indexLabelId) { + IndexContext context = obtainContext(indexLabelId); + return context.metaData.isUpdateFromLog(); + } + + private void handleDelete(VectorRecord record, IndexContext context) { + // now just mark the record deleted + // TODO： add the counter to save the deleted count + // can be cleanup before flush and until count meet the threshold. + if(context.builder.getGraph().containsNode(record.getVectorId())){ + context.builder.markNodeDeleted(record.getVectorId()); + } + } + + private void handleBuilding(VectorRecord record, IndexContext context) { + + if (context.vectors.getVector(record.getVectorId()) != null) { + LOG.debug("handleBuilding: vectorId={} already exists, skip", + record.getVectorId()); + return; + } + + VectorTypeSupport vectorTypeSupport = + VectorizationProvider.getInstance().getVectorTypeSupport(); + VectorFloat vector = vectorTypeSupport.createFloatVector(record.getVectorData()); + + context.vectors.addNode(record.getVectorId(), vector); + context.builder.addGraphNode(record.getVectorId(), vector); + + LOG.debug("handleBuilding: added vectorId={}, graphSize={}", + record.getVectorId(), context.builder.getGraph().size()); + } + + @Override + public IndexContext createNewContext(Id indexLabelId) { + + if (!checkPathValid(indexLabelId)) { + IndexContext ctx = getNewContext(indexLabelId, null); + vectorMap.put(indexLabelId, ctx); + return ctx; + } + // construct the dataPath to read the index and sequence + Path currentPathDir = null; + try { + currentPathDir = getOnDiskIndexDirPath(indexLabelId); + } catch (IOException e) { + throw new RuntimeException("Failed to resolve index dir for " + indexLabelId.asString(), e); + } + // get the index and json + try (ReaderSupplier rs = new SimpleMappedReader.Supplier(currentPathDir.resolve(INDEX_FILE_NAME)); + OnDiskGraphIndex index = OnDiskGraphIndex.load(rs)) { + RandomAccessVectorValues ravv = index.getView(); + IndexContext context = getNewContext(indexLabelId, ravv); + Path currentJsonPath = currentPathDir.resolve(META_FILE_NAME); + String jsonMetaData = Files.readString(currentJsonPath); + // get the metaData from disk but not update from rocksdb + IndexContext.IndexContextMetaData metaData = JsonUtilCommon.fromJson(jsonMetaData, + IndexContext.IndexContextMetaData.class); + metaData.setUpdateFromLog(false); + context.setMetaData(metaData); + vectorMap.put(indexLabelId, context); + return context; + } catch (FileNotFoundException e) { + System.err.println("Index file not found: " + currentPathDir); + IndexContext empty = getNewContext(indexLabelId, null); + vectorMap.put(indexLabelId, empty); + return empty; + } catch (IOException e) { + throw new RuntimeException("Read index failed: " + currentPathDir, e); + } + } + + @Override + public String idToString(Id id) { + return id.asString(); + } + + IndexContext getNewContext(Id vectorIndexLableId, RandomAccessVectorValues ravv) { + // if indexLabelId invalid , will throw error + IndexLabel il = graphParams.graph().indexLabel(vectorIndexLableId); + Map userData = il.userdata(); + E.checkArgument(userData.containsKey("similarityFunction"), + "The similarityFunction can't be" + " " + "empty"); + E.checkArgument(userData.containsKey("dimension"), "The dimension can't be empty"); + + int dimension = (int) userData.get("dimension"); + VectorSimilarityFunction similarityFunction = + getSimilarityFunction((String) userData.get("similarityFunction")); + /* use the magic number first + * TODO: use the config to set */ + int M = userData.containsKey("M") ? (int) userData.get("M") : 16; + int beamWidth = userData.containsKey("beamWidth") ? (int) userData.get("beamWidthM") : 100; + float neighborOverflow = userData.containsKey("neighborOverflow") ? + (float) userData.get("neighborOverflow") : (float) 1.2; + float alpha = userData.containsKey("alpha") ? (float) userData.get("alpha") : (float) 1.2; + + RandomAccessVectorValues vectorValueMap = ravv != null ? ravv: + new UpdatableRandomAccessVectorValues(new HashMap<>(), dimension); + + GraphIndexBuilder builder = new GraphIndexBuilder(vectorValueMap, similarityFunction, + M, beamWidth, neighborOverflow, alpha); + // need to test the vectorValueMap is updatable + return new IndexContext(vectorIndexLableId, (UpdatableRandomAccessVectorValues) vectorValueMap, builder,0, + dimension, similarityFunction); + } + + public VectorSimilarityFunction getSimilarityFunction(String similarityFunction) { + similarityFunction = similarityFunction.toUpperCase(); + switch (similarityFunction) { + case "EUCLIDEAN": + return VectorSimilarityFunction.EUCLIDEAN; + case "COSINE": + return VectorSimilarityFunction.COSINE; + case "DOT_PRODUCT": + return VectorSimilarityFunction.DOT_PRODUCT; + default: + throw new AssertionError( + "Unsupported similarity function: {}" + similarityFunction); + } + } + +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorScheduler.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorScheduler.java new file mode 100644 index 0000000000..4a45f88279 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorScheduler.java @@ -0,0 +1,49 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.util.concurrent.ExecutorService; + +import org.apache.hugegraph.event.Event; +import org.apache.hugegraph.event.EventHub; +import org.apache.hugegraph.event.EventListener; + +public class ServerVectorScheduler implements VectorTaskScheduler { + + private final EventHub hub; + + private static final String VECTOR_INDEX_EVENT = "vector-index-task"; + + public ServerVectorScheduler(ExecutorService executor, EventHub hub) { + this.hub = hub; + + this.hub.listen(VECTOR_INDEX_EVENT, new EventListener() { + @Override + public Object event(Event event) { + Runnable task = (Runnable) event.args()[0]; + task.run(); + return null; + } + }); + } + + @Override + public void execute(Runnable task) { + hub.notify(VECTOR_INDEX_EVENT, task); + } +} diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorStateStore.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorStateStore.java new file mode 100644 index 0000000000..19708b4fd8 --- /dev/null +++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/vector/ServerVectorStateStore.java @@ -0,0 +1,232 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; +import java.util.stream.IntStream; + +import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.query.ConditionQuery; +import org.apache.hugegraph.backend.query.IdPrefixQuery; +import org.apache.hugegraph.backend.query.Query; +import org.apache.hugegraph.backend.query.QueryResults; +import org.apache.hugegraph.backend.serializer.BytesBuffer; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.SchemaElement; +import org.apache.hugegraph.structure.HugeIndex; +import org.apache.hugegraph.structure.HugeVectorIndexMap; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.Cardinality; +import org.apache.hugegraph.type.define.DataType; +import org.apache.hugegraph.type.define.HugeKeys; +import org.apache.hugegraph.type.define.IndexVectorState; +import org.apache.hugegraph.util.E; +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; +import org.apache.tinkerpop.gremlin.structure.Vertex; + +public class ServerVectorStateStore implements VectorIndexStateStore { + + private static final Logger LOG = Log.logger(ServerVectorStateStore.class); + private HugeGraphParams graphParams = null; + + public ServerVectorStateStore(HugeGraphParams graphParams) { + E.checkNotNull(graphParams, "graphParams"); + this.graphParams = graphParams; + } + + @Override + public void stop() { + // delete the deleting record + + } + + @Override + public Iterable scanDeltas(Id indexLabelId, long fromSeq) { + + //first construct the query + // second use the store query to get result list + // third transform the result list to VectorRecord + BytesBuffer prefixBuffer = BytesBuffer.allocate(5); + prefixBuffer.write(0); + prefixBuffer.writeInt(SchemaElement.schemaId(indexLabelId)); + Id prefix = prefixBuffer.asId(); + Id start = HugeVectorIndexMap.formatSequenceId(indexLabelId, fromSeq + 1L); + + Query query = new IdPrefixQuery(HugeType.VECTOR_SEQUENCE, + null, start, true, prefix); + + QueryResults entries = this.graphParams.graphTransaction().query(query); + + // we could get the vector data in one time with this Query after we isolate the vector cf. + // Query queryVectorData = new IdPrefixQuery(HugeType.VECTOR_SEQUENCE, + // null, start, true, prefix); + return convertToVectorRecord(entries.iterator()); + } + + @Override + public Set getVertex(Id indexLabelId, Iterator vectorIds) { + Set vertexIds = new HashSet<>(); + while (vectorIds.hasNext()) { + int vectorId = vectorIds.next(); + Id id = IdGenerator.of(vectorId); + IndexLabel il = graphParams.graph().indexLabel(indexLabelId); + HugeVectorIndexMap SequenceIndex = new HugeVectorIndexMap(graphParams.graph(), il); + SequenceIndex.fieldValues(vectorId); + Query q = new IdPrefixQuery(HugeType.VECTOR_INDEX_MAP, SequenceIndex.id()); + QueryResults results = this.graphParams.graphTransaction().query(q); + ConditionQuery conditionQuery = new ConditionQuery(HugeType.VECTOR_INDEX_MAP); + conditionQuery.eq(HugeKeys.INDEX_LABEL_ID, indexLabelId); + conditionQuery.eq(HugeKeys.FIELD_VALUES, vectorId); + HugeIndex index = ConvertVectorIndex(indexLabelId, results.iterator(), conditionQuery); + if (index != null) vertexIds.add(index.elementId()); + } + return vertexIds; + } + + @Override + public int getCurrentMaxVectorId(Id indexLabelId, int currentMaxVectorId) { + + // construct the Prefix with non vectorId + // construct the start with current max vectorId BytesBuffer prefixBuffer = BytesBuffer.allocate(5); + BytesBuffer prefixBuffer = BytesBuffer.allocate(5); + prefixBuffer.write(0); + prefixBuffer.writeInt(SchemaElement.schemaId(indexLabelId)); + + Id prefix = prefixBuffer.asId(); + Id start = HugeVectorIndexMap.formatSequenceId(indexLabelId, + 1L); + + Query query = new IdPrefixQuery(HugeType.VECTOR_INDEX_MAP, + null, start, true, prefix); + // get query and fetch the max vectorId + + QueryResults resultEntries = + this.graphParams.graphTransaction().query(query); + Iterator entries = resultEntries.iterator(); + int maxVectorId = currentMaxVectorId; + + while(entries.hasNext()){ + BackendEntry entry = entries.next(); + ConditionQuery conditionQuery = new ConditionQuery(HugeType.VECTOR_INDEX_MAP); + conditionQuery.eq(HugeKeys.INDEX_LABEL_ID, indexLabelId); + HugeIndex map = + graphParams.serializer().readIndex(graphParams.graph(), conditionQuery, entry); + maxVectorId = Math.max(maxVectorId, (int)map.fieldValues()); + } + + return maxVectorId; + } + + @Override + public long getCurrentMaxSequence(Id indexLabelId, long currentMaxSeq) { + BytesBuffer prefixBuffer = BytesBuffer.allocate(5); + prefixBuffer.write(0); + prefixBuffer.writeInt(SchemaElement.schemaId(indexLabelId)); + + Id prefix = prefixBuffer.asId(); + Id start = HugeVectorIndexMap.formatSequenceId(indexLabelId, currentMaxSeq + 1L); + Query query = new IdPrefixQuery(HugeType.VECTOR_SEQUENCE, + null, start, true, prefix); + + QueryResults resultEntries = + this.graphParams.graphTransaction().query(query); + Iterator entries = resultEntries.iterator(); + long maxSequence = currentMaxSeq; + while(entries.hasNext()){ + BackendEntry entry = entries.next(); + HugeVectorIndexMap map = + graphParams.serializer().readVectorSequence(graphParams.graph(), null, + entry); + maxSequence = Math.max(maxSequence, map.sequence()); + } + + return maxSequence; + } + + HugeIndex ConvertVectorIndex(Id indexLabelId, Iterator entries, + ConditionQuery query) { + while (entries.hasNext()) { + BackendEntry entry = entries.next(); + // In the read index, columns that have been deleted are filtered out; only indexes + // in a normal status will assign a value to the element id. + HugeIndex index = graphParams.serializer().readIndex(graphParams.graph(), query, entry); + if(index.elementId() != null) { + // if the state not equal deleting, the element id would not be set + return index; + } + } + return null; + } + + + private List convertToVectorRecord(Iterator entries) { + List records = new ArrayList<>(); + while (entries.hasNext()) { + BackendEntry entry = entries.next(); + HugeVectorIndexMap map = + graphParams.serializer().readVectorSequence(graphParams.graph(), null, + entry); + LOG.debug("convertToVectorRecord: we get record in while"); + // Query VECTOR_INDEX_MAP to get the vertex id from the vector id + Query query = new IdPrefixQuery(HugeType.VECTOR_INDEX_MAP, map.id()); + Iterator vertexMapIt = + this.graphParams.graphTransaction().query(query).iterator(); + if (!vertexMapIt.hasNext()) { + LOG.debug("convertToVectorRecord: no VECTOR_INDEX_MAP found for vectorId={}", + map.fieldValues()); + continue; + } + ConditionQuery cq = new ConditionQuery(HugeType.VECTOR_INDEX_MAP); + cq.eq(HugeKeys.INDEX_LABEL_ID, map.indexLabelId()); + HugeIndex vectorIndex = graphParams.serializer().readIndex( + graphParams.graph(), cq, vertexMapIt.next()); + if (vectorIndex.elementId() == null) { + continue; + } + Vertex targetVertex = graphParams.graphTransaction().queryVertex( + vectorIndex.elementId()); + + IndexLabel il = map.indexLabel(); + PropertyKey propertyKey = graphParams.graph().propertyKey(il.indexField()); + + E.checkArgument(propertyKey.dataType() == DataType.FLOAT && + propertyKey.cardinality() == Cardinality.LIST, "the property key must" + + " be a float list"); + + Object propValue = targetVertex.property(propertyKey.name()).value(); + List floatList = (List) propValue; + float[] vectorData = new float[floatList.size()]; + IntStream.range(0, floatList.size()).forEach(i -> vectorData[i] = floatList.get(i)); + + records.add(new VectorRecord((int) map.fieldValues(), vectorData, + map.vectorState() == IndexVectorState.DELETING, + map.sequence())); + + } + + return records; + } +} diff --git a/hugegraph-server/hugegraph-dist/docker/README.md b/hugegraph-server/hugegraph-dist/docker/README.md index 6d1b6ad89b..7ee88ab1fe 100644 --- a/hugegraph-server/hugegraph-dist/docker/README.md +++ b/hugegraph-server/hugegraph-dist/docker/README.md @@ -1,52 +1,52 @@ -# Deploy Hugegraph server with docker +# Deploy HugeGraph Server with Docker > Note: > -> 1. The docker image of hugegraph is a convenience release, not official distribution artifacts from ASF. You can find more details from [ASF Release Distribution Policy](https://infra.apache.org/release-distribution.html#dockerhub). +> 1. The HugeGraph Docker image is a convenience release, not an official ASF distribution artifact. See the [ASF Release Distribution Policy](https://infra.apache.org/release-distribution.html#dockerhub) for details. > -> 2. Recommend to use `release tag` (like `1.3.0`/`1.5.0`) for the stable version. Use `latest` tag to experience the newest functions in development. +> 2. Use release tags (for example, `1.7.0`) for stable deployments. Use `latest` only for development or testing. ## 1. Deploy -We can use docker to quickly start an inner HugeGraph server with RocksDB in the background. +Use Docker to quickly start a standalone HugeGraph Server with RocksDB. -1. Using docker run +1. Using `docker run` - Use `docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph:1.3.0` to start hugegraph server. + Use `docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph:1.7.0` to start hugegraph server. -2. Using docker compose +2. Using `docker compose` - Certainly we can only deploy server without other instance. Additionally, if we want to manage other HugeGraph-related instances with `server` in a single file, we can deploy HugeGraph-related instances via `docker-compose up -d`. The `docker-compose.yaml` is as below: + To deploy only the server, use `docker compose up -d`. The compose file is as follows: ```yaml version: '3' services: graph: - image: hugegraph/hugegraph:1.3.0 + image: hugegraph/hugegraph:1.7.0 ports: - 8080:8080 ``` ## 2. Create Sample Graph on Server Startup -If you want to **preload** some (test) data or graphs in container(by default), you can set the env `PRELOAD=ture` +To preload sample data on startup, set `PRELOAD=true`. -If you want to customize the preloaded data, please mount the groovy scripts (not necessary). +To customize the preload, mount your own Groovy script. -1. Using docker run +1. Using `docker run` - Use `docker run -itd --name=graph -p 8080:8080 -e PRELOAD=true -v /path/to/script:/hugegraph-server/scripts/example.groovy hugegraph/hugegraph:1.3.0` + Use `docker run -itd --name=graph -p 8080:8080 -e PRELOAD=true -v /path/to/script:/hugegraph-server/scripts/example.groovy hugegraph/hugegraph:1.7.0` to start hugegraph server. -2. Using docker compose +2. Using `docker compose` - We can also use `docker-compose up -d` to quickly start. The `docker-compose.yaml` is below. [example.groovy](https://github.com/apache/incubator-hugegraph/blob/master/hugegraph-server/hugegraph-dist/src/assembly/static/scripts/example.groovy) is a pre-defined script. If needed, we can mount a new `example.groovy` to preload different data: + Use `docker compose up -d` to start quickly. The compose file is below. [example.groovy](https://github.com/apache/hugegraph/blob/master/hugegraph-server/hugegraph-dist/src/assembly/static/scripts/example.groovy) is a predefined script. Replace it with your own script to preload different data: ```yaml version: '3' services: graph: - image: hugegraph/hugegraph:1.3.0 + image: hugegraph/hugegraph:1.7.0 environment: - PRELOAD=true volumes: @@ -55,25 +55,25 @@ If you want to customize the preloaded data, please mount the groovy scripts (no - 8080:8080 ``` -3. Using start-hugegraph.sh +3. Using `start-hugegraph.sh` - If you deploy HugeGraph server without docker, you can also pass arguments using `-p`, like this: `bin/start-hugegraph.sh -p true`. + If you deploy HugeGraph Server without Docker, you can also pass `-p true` to `bin/start-hugegraph.sh`. ## 3. Enable Authentication -1. Using docker run +1. Using `docker run` - Use `docker run -itd --name=graph -p 8080:8080 -e AUTH=true -e PASSWORD=xxx hugegraph/hugegraph:1.3.0` to enable the authentication and set the password with `-e AUTH=true -e PASSWORD=xxx`. + Use `docker run -itd --name=graph -p 8080:8080 -e AUTH=true -e PASSWORD=xxx hugegraph/hugegraph:1.7.0` to enable authentication. -2. Using docker compose +2. Using `docker compose` - Similarly, we can set the environment variables in the docker-compose.yaml: + Set the environment variables in the compose file: ```yaml version: '3' services: server: - image: hugegraph/hugegraph:1.3.0 + image: hugegraph/hugegraph:1.7.0 container_name: graph ports: - 8080:8080 @@ -82,31 +82,31 @@ If you want to customize the preloaded data, please mount the groovy scripts (no - PASSWORD=xxx ``` -## 4. Running Open-Telemetry-Collector +## 4. Run OpenTelemetry > CAUTION: > -> The `docker-compose-trace.yaml` utilizes `Grafana` and `Grafana-Tempo`, both of them are licensed under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html), you should be aware of and use them with caution. Currently, we mainly provide this template for everyone to **test** +> The `docker-compose-trace.yaml` uses Grafana and Grafana Tempo, both of which are licensed under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html). Use this template for testing only. > -1. Start Open-Telemetry-Collector +1. Start the OpenTelemetry collector ```bash - cd hugegraph-server/hugegraph-dist/docker/example - docker-compose -f docker-compose-trace.yaml -p hugegraph-trace up -d + # Run from the repository root + docker compose -f hugegraph-server/hugegraph-dist/docker/example/docker-compose-trace.yaml -p hugegraph-trace up -d ``` -2. Active Open-Telemetry-Agent +2. Enable the OpenTelemetry agent ```bash ./start-hugegraph.sh -y true ``` -3. Stop Open-Telemetry-Collector +3. Stop the OpenTelemetry collector ```bash - cd hugegraph-server/hugegraph-dist/docker/example - docker-compose -f docker-compose-trace.yaml -p hugegraph-trace stop + # Run from the repository root + docker compose -f hugegraph-server/hugegraph-dist/docker/example/docker-compose-trace.yaml -p hugegraph-trace stop ``` 4. References @@ -114,3 +114,19 @@ If you want to customize the preloaded data, please mount the groovy scripts (no - [What is OpenTelemetry](https://opentelemetry.io/docs/what-is-opentelemetry/) - [Tempo in Grafana](https://grafana.com/docs/tempo/latest/getting-started/tempo-in-grafana/) + +## 5. Distributed Cluster (PD + Store + Server) + +For a full distributed HugeGraph cluster with PD, Store, and Server, use the +3-node compose file in the `docker/` directory at the repository root. + +**Prerequisites**: Allocate at least **12 GB** memory to Docker Desktop +(Settings → Resources → Memory). The cluster runs 9 JVM processes. + +```bash +cd docker +HUGEGRAPH_VERSION=1.7.0 docker compose -f docker-compose-3pd-3store-3server.yml up -d +``` + +See [docker/README.md](../../../docker/README.md) for the full setup guide, +environment variable reference, and troubleshooting. diff --git a/hugegraph-server/hugegraph-dist/docker/docker-entrypoint.sh b/hugegraph-server/hugegraph-dist/docker/docker-entrypoint.sh old mode 100644 new mode 100755 index 60cd4bc163..779c3eb704 --- a/hugegraph-server/hugegraph-dist/docker/docker-entrypoint.sh +++ b/hugegraph-server/hugegraph-dist/docker/docker-entrypoint.sh @@ -15,32 +15,80 @@ # See the License for the specific language governing permissions and # limitations under the License. # +set -euo pipefail -# create a folder to save the docker-related file -DOCKER_FOLDER='./docker' -mkdir -p $DOCKER_FOLDER - +DOCKER_FOLDER="./docker" INIT_FLAG_FILE="init_complete" +GRAPH_CONF="./conf/graphs/hugegraph.properties" + +mkdir -p "${DOCKER_FOLDER}" + +log() { echo "[hugegraph-server-entrypoint] $*"; } + +set_prop() { + local key="$1" val="$2" file="$3" + local esc_key esc_val + + esc_key=$(printf '%s' "$key" | sed -e 's/[][(){}.^$*+?|\\/]/\\&/g') + esc_val=$(printf '%s' "$val" | sed -e 's/[&|\\]/\\&/g') -if [ ! -f "${DOCKER_FOLDER}/${INIT_FLAG_FILE}" ]; then - # wait for storage backend - ./bin/wait-storage.sh - if [ -z "$PASSWORD" ]; then - echo "init hugegraph with non-auth mode" + if grep -qE "^[[:space:]]*${esc_key}[[:space:]]*=" "${file}"; then + sed -ri "s|^([[:space:]]*${esc_key}[[:space:]]*=).*|\\1${esc_val}|" "${file}" + else + printf '%s=%s\n' "$key" "$val" >> "${file}" + fi +} + +migrate_env() { + local old_name="$1" new_name="$2" + + if [[ -n "${!old_name:-}" && -z "${!new_name:-}" ]]; then + log "WARN: deprecated env '${old_name}' detected; mapping to '${new_name}'" + export "${new_name}=${!old_name}" + fi +} + +migrate_env "BACKEND" "HG_SERVER_BACKEND" +migrate_env "PD_PEERS" "HG_SERVER_PD_PEERS" + +# ── Map env → properties file ───────────────────────────────────────── +[[ -n "${HG_SERVER_BACKEND:-}" ]] && set_prop "backend" "${HG_SERVER_BACKEND}" "${GRAPH_CONF}" +[[ -n "${HG_SERVER_PD_PEERS:-}" ]] && set_prop "pd.peers" "${HG_SERVER_PD_PEERS}" "${GRAPH_CONF}" + +# ── Build wait-storage env ───────────────────────────────────────────── +WAIT_ENV=() +[[ -n "${HG_SERVER_BACKEND:-}" ]] && WAIT_ENV+=("hugegraph.backend=${HG_SERVER_BACKEND}") +[[ -n "${HG_SERVER_PD_PEERS:-}" ]] && WAIT_ENV+=("hugegraph.pd.peers=${HG_SERVER_PD_PEERS}") + +# ── Init store (once) ───────────────────────────────────────────────── +if [[ ! -f "${DOCKER_FOLDER}/${INIT_FLAG_FILE}" ]]; then + if (( ${#WAIT_ENV[@]} > 0 )); then + env "${WAIT_ENV[@]}" ./bin/wait-storage.sh + else + ./bin/wait-storage.sh + fi + + if [[ -z "${PASSWORD:-}" ]]; then + log "init hugegraph with non-auth mode" ./bin/init-store.sh else - echo "init hugegraph with auth mode" + log "init hugegraph with auth mode" ./bin/enable-auth.sh - echo "$PASSWORD" | ./bin/init-store.sh + echo "${PASSWORD}" | ./bin/init-store.sh fi - # create a flag file to avoid re-init when restarting - touch ${DOCKER_FOLDER}/${INIT_FLAG_FILE} + touch "${DOCKER_FOLDER}/${INIT_FLAG_FILE}" else - echo "Hugegraph Initialization already done. Skipping re-init..." + log "HugeGraph initialization already done. Skipping re-init..." fi -# start hugegraph-server -# remove "-g zgc" now, which is only available on ARM-Mac with java > 13 -./bin/start-hugegraph.sh -j "$JAVA_OPTS" +./bin/start-hugegraph.sh -j "${JAVA_OPTS:-}" -t 120 + +# Post-startup cluster stabilization check (hstore only — rocksdb has no partitions) +ACTUAL_BACKEND=$(grep -E '^[[:space:]]*backend[[:space:]]*=' "${GRAPH_CONF}" | head -n 1 | sed 's/.*=//' | tr -d '[:space:]' || true) +if [[ "${ACTUAL_BACKEND}" == "hstore" ]]; then + STORE_REST="${STORE_REST:-store:8520}" + export STORE_REST + ./bin/wait-partition.sh || log "WARN: partitions not assigned yet" +fi tail -f /dev/null diff --git a/hugegraph-server/hugegraph-dist/pom.xml b/hugegraph-server/hugegraph-dist/pom.xml index 324d253dc5..1fe20b6d9b 100644 --- a/hugegraph-server/hugegraph-dist/pom.xml +++ b/hugegraph-server/hugegraph-dist/pom.xml @@ -356,7 +356,7 @@ - + !skip-tar-package diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/hugegraph-server.sh b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/hugegraph-server.sh index 857b9b5356..c5f84d4933 100644 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/hugegraph-server.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/hugegraph-server.sh @@ -183,6 +183,11 @@ if [ "${OPEN_TELEMETRY}" == "true" ]; then fi # Turn on security check -exec ${JAVA} -Dname="HugeGraphServer" ${JVM_OPTIONS} ${JAVA_OPTIONS} -cp ${CLASSPATH}: \ - org.apache.hugegraph.dist.HugeGraphServer ${GREMLIN_SERVER_CONF} ${REST_SERVER_CONF} \ - >> ${OUTPUT} 2>&1 +if [[ "${STDOUT_MODE:-false}" == "true" ]]; then + exec ${JAVA} -Dname="HugeGraphServer" ${JVM_OPTIONS} ${JAVA_OPTIONS} -cp ${CLASSPATH}: \ + org.apache.hugegraph.dist.HugeGraphServer ${GREMLIN_SERVER_CONF} ${REST_SERVER_CONF} +else + exec ${JAVA} -Dname="HugeGraphServer" ${JVM_OPTIONS} ${JAVA_OPTIONS} -cp ${CLASSPATH}: \ + org.apache.hugegraph.dist.HugeGraphServer ${GREMLIN_SERVER_CONF} ${REST_SERVER_CONF} \ + >> ${LOGS}/hugegraph-server-stdout.log 2>&1 +fi diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/init-store.sh b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/init-store.sh index f89db7e5af..9aefd1160b 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/init-store.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/init-store.sh @@ -45,12 +45,7 @@ fi cd "${TOP}" || exit -DEFAULT_JAVA_OPTIONS="" -JAVA_VERSION=$($JAVA -version 2>&1 | awk 'NR==1{gsub(/"/,""); print $3}' | awk -F'_' '{print $1}') -# TODO: better not string number compare, use `bc` like github.com/koalaman/shellcheck/wiki/SC2072 -if [[ $? -eq 0 && $JAVA_VERSION > "1.9" ]]; then - DEFAULT_JAVA_OPTIONS="--add-exports=java.base/jdk.internal.reflect=ALL-UNNAMED" -fi +DEFAULT_JAVA_OPTIONS="--add-exports=java.base/jdk.internal.reflect=ALL-UNNAMED" echo "Initializing HugeGraph Store..." diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/start-hugegraph.sh b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/start-hugegraph.sh index 30c2764989..2c99238327 100644 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/start-hugegraph.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/start-hugegraph.sh @@ -99,36 +99,41 @@ if [[ $PRELOAD == "true" ]]; then sed -i -e '/registerBackends/d; /serverStarted/d' "${SCRIPTS}/${EXAMPLE_SCRIPT}" fi -# TODO: show the output message in hugegraph-server.sh when start the server if [[ $DAEMON == "true" ]]; then echo "Starting HugeGraphServer in daemon mode..." "${BIN}"/hugegraph-server.sh "${CONF}/${GREMLIN_SERVER_CONF}" "${CONF}"/rest-server.properties \ - "${OPEN_SECURITY_CHECK}" "${USER_OPTION}" "${GC_OPTION}" "${OPEN_TELEMETRY}" \ - >>"${LOGS}"/hugegraph-server.log 2>&1 & -else - echo "Starting HugeGraphServer in foreground mode..." - "${BIN}"/hugegraph-server.sh "${CONF}/${GREMLIN_SERVER_CONF}" "${CONF}"/rest-server.properties \ - "${OPEN_SECURITY_CHECK}" "${USER_OPTION}" "${GC_OPTION}" "${OPEN_TELEMETRY}" \ - >>"${LOGS}"/hugegraph-server.log 2>&1 -fi + "${OPEN_SECURITY_CHECK}" "${USER_OPTION}" "${GC_OPTION}" "${OPEN_TELEMETRY}" & -PID="$!" -# Write pid to file -echo "$PID" > "$PID_FILE" + PID="$!" + # Write pid to file + echo "$PID" > "$PID_FILE" -trap 'kill $PID; exit' SIGHUP SIGINT SIGQUIT SIGTERM + trap 'kill $PID; exit' SIGHUP SIGINT SIGQUIT SIGTERM -wait_for_startup ${PID} 'HugeGraphServer' "$REST_SERVER_URL/graphs" "${SERVER_STARTUP_TIMEOUT_S}" || { - echo "See $LOGS/hugegraph-server.log for HugeGraphServer log output." >&2 - if [[ $DAEMON == "true" ]]; then + wait_for_startup ${PID} 'HugeGraphServer' "$REST_SERVER_URL/graphs" "${SERVER_STARTUP_TIMEOUT_S}" || { + if [[ "${STDOUT_MODE:-false}" == "true" ]]; then + echo "See 'docker logs' for HugeGraphServer log output." >&2 + else + echo "See $LOGS/hugegraph-server.log for HugeGraphServer log output." >&2 + fi exit 1 + } + disown + + if [ "$OPEN_MONITOR" == "true" ]; then + if ! "$BIN"/start-monitor.sh; then + echo "Failed to open monitor, please start it manually" + fi + echo "An HugeGraphServer monitor task has been append to crontab" fi -} -disown - -if [ "$OPEN_MONITOR" == "true" ]; then - if ! "$BIN"/start-monitor.sh; then - echo "Failed to open monitor, please start it manually" - fi - echo "An HugeGraphServer monitor task has been append to crontab" +else + echo "Starting HugeGraphServer in foreground mode..." + "${BIN}"/hugegraph-server.sh "${CONF}/${GREMLIN_SERVER_CONF}" "${CONF}"/rest-server.properties \ + "${OPEN_SECURITY_CHECK}" "${USER_OPTION}" "${GC_OPTION}" "${OPEN_TELEMETRY}" & + PID="$!" + # Write pid to file + echo "$PID" > "$PID_FILE" + trap 'kill $PID; wait $PID; exit $?' SIGHUP SIGINT SIGQUIT SIGTERM + wait $PID + exit $? fi diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/util.sh b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/util.sh index 11979b6481..e2655c69d3 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/util.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/util.sh @@ -81,7 +81,7 @@ function process_id() { # check the port of rest server is occupied function check_port() { - local port=$(echo "$1" | awk -F':' '{print $3}') + local port=$(echo "$1" | sed 's|.*:||' | sed 's|/.*||') if ! command_available "lsof"; then echo "Required lsof but it is unavailable" exit 1 diff --git a/docker/configs/server2-conf/remote.yaml b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/wait-partition.sh old mode 100644 new mode 100755 similarity index 62% rename from docker/configs/server2-conf/remote.yaml rename to hugegraph-server/hugegraph-dist/src/assembly/static/bin/wait-partition.sh index 55f38ab97d..d14bc90244 --- a/docker/configs/server2-conf/remote.yaml +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/wait-partition.sh @@ -1,3 +1,4 @@ +#!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with @@ -6,7 +7,7 @@ # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # -# http://www.apache.org/licenses/LICENSE-2.0 +# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, @@ -14,12 +15,20 @@ # See the License for the specific language governing permissions and # limitations under the License. # -hosts: [localhost] -port: 8182 -serializer: { - className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, - config: { - serializeResultToString: false, - ioRegistries: [org.apache.hugegraph.io.HugeGraphIoRegistry] - } -} +set -euo pipefail + +: "${STORE_REST:?STORE_REST not set}" + +timeout "${WAIT_PARTITION_TIMEOUT_S:-120}s" bash -c ' +until curl -fsS "http://${STORE_REST}" 2>/dev/null | \ + grep -q "\"partitionCount\":[1-9]" +do + echo "Waiting for partition assignment..." + sleep 5 +done +' + +echo "Partitions detected:" +URL="http://${STORE_REST}/v1/partitions" +echo "$URL" +curl -v "$URL" diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/wait-storage.sh b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/wait-storage.sh old mode 100644 new mode 100755 index 556e022478..d4e9e278f0 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/bin/wait-storage.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/bin/wait-storage.sh @@ -29,11 +29,15 @@ function abs_path() { BIN=$(abs_path) TOP="$(cd "$BIN"/../ && pwd)" GRAPH_CONF="$TOP/conf/graphs/hugegraph.properties" -WAIT_STORAGE_TIMEOUT_S=120 -DETECT_STORAGE="$TOP/scripts/detect-storage.groovy" +WAIT_STORAGE_TIMEOUT_S=300 . "$BIN"/util.sh +log() { + echo "[wait-storage] $1" +} + +PD_AUTH_ARGS="-u ${PD_AUTH_USER:-store}:${PD_AUTH_PASSWORD:-admin}" function key_exists { local key=$1 @@ -70,7 +74,58 @@ done < <(env | sort -r | awk -F= '{ st = index($0, "="); print $1 " " substr($0, # wait for storage if env | grep '^hugegraph\.' > /dev/null; then if [ -n "${WAIT_STORAGE_TIMEOUT_S:-}" ]; then - timeout "${WAIT_STORAGE_TIMEOUT_S}s" bash -c \ - "until bin/gremlin-console.sh -- -e $DETECT_STORAGE > /dev/null 2>&1; do echo \"Hugegraph server are waiting for storage backend...\"; sleep 5; done" + + PD_PEERS="${hugegraph_pd_peers:-}" + if [ -z "$PD_PEERS" ]; then + PD_PEERS=$(grep -E "^\s*pd\.peers\s*=" "$GRAPH_CONF" | sed 's/.*=\s*//' | tr -d ' ') + fi + + if [ -n "$PD_PEERS" ]; then + : "${HG_SERVER_PD_REST_ENDPOINT:=}" + + if [ -n "${HG_SERVER_PD_REST_ENDPOINT}" ]; then + PD_REST_LIST="${HG_SERVER_PD_REST_ENDPOINT}" + else + PD_REST_LIST=$(echo "$PD_PEERS" | sed 's/:8686/:8620/g') + fi + + export PD_REST_LIST + log "PD REST peers = $PD_REST_LIST" + log "Timeout = ${WAIT_STORAGE_TIMEOUT_S}s" + + timeout "${WAIT_STORAGE_TIMEOUT_S}s" bash -c " + + log() { echo '[wait-storage] '\"\$1\"; } + + check_any_pd() { + for peer in \$(echo \"\$PD_REST_LIST\" | tr ',' ' '); do + if curl ${PD_AUTH_ARGS} -f -s http://\${peer}/v1/health >/dev/null 2>&1; then + echo \"\$peer\" + return 0 + fi + done + return 1 + } + + until PD_REST=\$(check_any_pd); do + log 'No PD peer ready yet, retrying in 5s' + sleep 5 + done + log \"PD health check PASSED via \$PD_REST\" + + until curl ${PD_AUTH_ARGS} -f -s \ + http://\${PD_REST}/v1/stores 2>/dev/null | \ + grep -qi '\"state\"[[:space:]]*:[[:space:]]*\"Up\"'; do + log 'No Up store yet, retrying in 5s' + sleep 5 + done + + log 'Store registration check PASSED' + log 'Storage backend is VIABLE' + " || { echo "[wait-storage] ERROR: Timeout waiting for storage backend"; exit 1; } + + else + log "No pd.peers configured, skipping storage wait" + fi fi fi diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/log4j2.xml b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/log4j2.xml index f1dd7e8395..cd2d9da569 100644 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/log4j2.xml +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/log4j2.xml @@ -104,6 +104,7 @@ + @@ -129,6 +130,7 @@ + diff --git a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/rest-server.properties b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/rest-server.properties index 1ee4e6e1ee..bbb956aafa 100644 --- a/hugegraph-server/hugegraph-dist/src/assembly/static/conf/rest-server.properties +++ b/hugegraph-server/hugegraph-dist/src/assembly/static/conf/rest-server.properties @@ -3,7 +3,7 @@ restserver.url=http://127.0.0.1:8080 #restserver.enable_graphspaces_filter=false # gremlin server url, need to be consistent with host and port in gremlin-server.yaml -#gremlinserver.url=http://127.0.0.1:8182 +#gremlinserver.url=127.0.0.1:8182 graphs=./conf/graphs @@ -18,39 +18,12 @@ arthas.ip=127.0.0.1 arthas.disabled_commands=jad # authentication configs -# choose 'org.apache.hugegraph.auth.StandardAuthenticator' or -# 'org.apache.hugegraph.auth.ConfigAuthenticator' -#auth.authenticator= +#auth.authenticator=org.apache.hugegraph.auth.StandardAuthenticator # for admin password, By default, it is pa and takes effect upon the first startup #auth.admin_pa=pa - -# for StandardAuthenticator mode #auth.graph_store=hugegraph -# auth client config -#auth.remote_url=127.0.0.1:8899,127.0.0.1:8898,127.0.0.1:8897 - -# for ConfigAuthenticator mode -#auth.admin_token= -#auth.user_tokens=[] - -# TODO: Deprecated & removed later (useless from version 1.5.0) -# rpc server configs for multi graph-servers or raft-servers -#rpc.server_host=127.0.0.1 -#rpc.server_port=8091 -#rpc.server_timeout=30 - -# rpc client configs (like enable to keep cache consistency) -#rpc.remote_url=127.0.0.1:8091,127.0.0.1:8092,127.0.0.1:8093 -#rpc.client_connect_timeout=20 -#rpc.client_reconnect_period=10 -#rpc.client_read_timeout=40 -#rpc.client_retries=3 -#rpc.client_load_balancer=consistentHash - -# raft group initial peers -#raft.group_peers=127.0.0.1:8091,127.0.0.1:8092,127.0.0.1:8093 -# lightweight load balancing (beta) +# lightweight load balancing (TODO: legacy mode, remove soon) server.id=server-1 server.role=master # use pd diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/build-report.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/build-report.sh index 0e17491dd5..920914267d 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/build-report.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/build-report.sh @@ -21,22 +21,53 @@ BACKEND=$1 JACOCO_PORT=$2 JACOCO_REPORT_FILE=$3 +TRAVIS_DIR=$(cd "$(dirname "$0")" && pwd) +REPO_ROOT=$(cd "$TRAVIS_DIR/../../../../.." && pwd) + +function command_available() { + local cmd=$1 + [[ -x "$(command -v "$cmd")" ]] +} + +function download_to_dir() { + local dir=$1 + local url=$2 + local file="$dir/$(basename "$url")" + + mkdir -p "$dir" + if command_available "curl"; then + curl -fL "$url" -o "$file" + elif command_available "wget"; then + wget -P "$dir" "$url" + else + echo "Required curl or wget but they are unavailable" + exit 1 + fi +} + OPTION_CLASS_FILES_BACKEND="--classfiles hugegraph-$BACKEND/target/classes/org/apache/hugegraph" if [ "$BACKEND" == "memory" ]; then # hugegraph-memory is the same as hugegraph-core OPTION_CLASS_FILES_BACKEND="" fi -cd hugegraph-server/hugegraph-test +case "$JACOCO_REPORT_FILE" in + /*) REPORT_FILE=$JACOCO_REPORT_FILE ;; + *) REPORT_FILE="$REPO_ROOT/$JACOCO_REPORT_FILE" ;; +esac +mkdir -p "$(dirname "$REPORT_FILE")" + +cd "$REPO_ROOT/hugegraph-server/hugegraph-test" mvn jacoco:dump@pull-test-data -Dapp.host=localhost -Dapp.port=$JACOCO_PORT -Dskip.dump=false -cd ../ +cd "$REPO_ROOT/hugegraph-server" if [[ ! -e "${TRAVIS_DIR}/jacococli.jar" ]]; then - wget -P "${TRAVIS_DIR}" https://github.com/apache/hugegraph-doc/raw/binary-1.0/dist/server/jacococli.jar + download_to_dir "${TRAVIS_DIR}" \ + "https://github.com/apache/hugegraph-doc/raw/binary-1.0/dist/server/jacococli.jar" fi java -jar $TRAVIS_DIR/jacococli.jar report hugegraph-test/target/jacoco-it.exec \ --classfiles hugegraph-dist/target/classes/org/apache/hugegraph \ --classfiles hugegraph-api/target/classes/org/apache/hugegraph \ --classfiles hugegraph-core/target/classes/org/apache/hugegraph \ - ${OPTION_CLASS_FILES_BACKEND} --xml "${JACOCO_REPORT_FILE}" + ${OPTION_CLASS_FILES_BACKEND} --xml "${REPORT_FILE}" diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/hbase-site.xml b/hugegraph-server/hugegraph-dist/src/assembly/travis/hbase-site.xml index d8a0978185..a95cbc3a3f 100644 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/hbase-site.xml +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/hbase-site.xml @@ -41,4 +41,12 @@ hbase.zookeeper.property.tickTime 6000 + + hbase.cluster.distributed + false + + + hbase.unsafe.stream.capability.enforce + false + diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/install-cassandra.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/install-cassandra.sh index 629a4779ea..86b22f2e0d 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/install-cassandra.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/install-cassandra.sh @@ -17,7 +17,7 @@ # set -ev -CASS_DOWNLOAD_ADDRESS="http://archive.apache.org/dist/cassandra" +CASS_DOWNLOAD_ADDRESS="https://archive.apache.org/dist/cassandra" CASS_VERSION="4.0.10" CASS_PACKAGE="apache-cassandra-${CASS_VERSION}" CASS_TAR="${CASS_PACKAGE}-bin.tar.gz" diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/install-hbase.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/install-hbase.sh index ae40b284ea..caadec7f81 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/install-hbase.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/install-hbase.sh @@ -18,8 +18,8 @@ set -ev TRAVIS_DIR=$(dirname $0) -HBASE_DOWNLOAD_ADDRESS="http://archive.apache.org/dist/hbase" -HBASE_VERSION="2.0.2" +HBASE_DOWNLOAD_ADDRESS="https://archive.apache.org/dist/hbase" +HBASE_VERSION="2.6.5" HBASE_PACKAGE="hbase-${HBASE_VERSION}" HBASE_TAR="${HBASE_PACKAGE}-bin.tar.gz" diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test-for-raft.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test-for-raft.sh index 2b998d57aa..a48894728e 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test-for-raft.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test-for-raft.sh @@ -23,7 +23,7 @@ REPORT_FILE=$REPORT_DIR/jacoco-api-test.xml TRAVIS_DIR=$(dirname $0) VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) -SERVER_DIR=hugegraph-server/apache-hugegraph-server-incubating-$VERSION +SERVER_DIR=hugegraph-server/apache-hugegraph-server-$VERSION RAFT1_DIR=hugegraph-raft1 RAFT2_DIR=hugegraph-raft2 RAFT3_DIR=hugegraph-raft3 diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test.sh index a9fe0671bb..2edeb9ce6c 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/run-api-test.sh @@ -21,9 +21,44 @@ BACKEND=$1 REPORT_DIR=$2 REPORT_FILE=$REPORT_DIR/jacoco-api-test-for-raft.xml -TRAVIS_DIR=$(dirname $0) +TRAVIS_DIR=$(cd "$(dirname "$0")" && pwd) +REPO_ROOT=$(cd "$TRAVIS_DIR/../../../../.." && pwd) + +function command_available() { + local cmd=$1 + [[ -x "$(command -v "$cmd")" ]] +} + +function sed_in_place() { + local expression=$1 + local file=$2 + + case "$(uname)" in + Darwin) sed -i '' "$expression" "$file" ;; + *) sed -i "$expression" "$file" ;; + esac +} + +function download_to_dir() { + local dir=$1 + local url=$2 + local file="$dir/$(basename "$url")" + + mkdir -p "$dir" + if command_available "curl"; then + curl -fL "$url" -o "$file" + elif command_available "wget"; then + wget -P "$dir" "$url" + else + echo "Required curl or wget but they are unavailable" + exit 1 + fi +} + +cd "$REPO_ROOT" + VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) -SERVER_DIR=hugegraph-server/apache-hugegraph-server-incubating-$VERSION/ +SERVER_DIR=hugegraph-server/apache-hugegraph-server-$VERSION/ CONF=$SERVER_DIR/conf/graphs/hugegraph.properties REST_SERVER_CONF=$SERVER_DIR/conf/rest-server.properties GREMLIN_SERVER_CONF=$SERVER_DIR/conf/gremlin-server.yaml @@ -32,18 +67,22 @@ JACOCO_PORT=36320 mvn package -Dmaven.test.skip=true -ntp # add mysql dependency -wget -P $SERVER_DIR/lib/ https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.28/mysql-connector-java-8.0.28.jar +download_to_dir "$SERVER_DIR/lib/" \ + "https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.28/mysql-connector-java-8.0.28.jar" -if [[ ! -e "$SERVER_DIR/ikanalyzer-2012_u6.jar" ]]; then - wget -P $SERVER_DIR/lib/ https://raw.githubusercontent.com/apache/incubator-hugegraph-doc/ik_binary/dist/server/ikanalyzer-2012_u6.jar +if [[ ! -e "$SERVER_DIR/lib/ikanalyzer-2012_u6.jar" ]]; then + download_to_dir "$SERVER_DIR/lib/" \ + "https://raw.githubusercontent.com/apache/hugegraph-doc/ik_binary/dist/server/ikanalyzer-2012_u6.jar" fi # config rest-server -sed -i 's/#auth.authenticator=/auth.authenticator=org.apache.hugegraph.auth.StandardAuthenticator/' $REST_SERVER_CONF -sed -i 's/#auth.admin_token=/auth.admin_token=pa/' $REST_SERVER_CONF +sed_in_place '/^#*auth\.authenticator=/d' "$REST_SERVER_CONF" +sed_in_place '/^#*auth\.admin_token=/d' "$REST_SERVER_CONF" +echo "auth.authenticator=org.apache.hugegraph.auth.StandardAuthenticator" >> $REST_SERVER_CONF +echo "auth.admin_token=pa" >> $REST_SERVER_CONF # config hugegraph.properties -sed -i 's/gremlin.graph=.*/gremlin.graph=org.apache.hugegraph.auth.HugeFactoryAuthProxy/' $CONF +sed_in_place 's/gremlin.graph=.*/gremlin.graph=org.apache.hugegraph.auth.HugeFactoryAuthProxy/' "$CONF" # config gremlin-server echo " diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/start-pd.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/start-pd.sh index bab4adcc8d..35e82ade40 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/start-pd.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/start-pd.sh @@ -29,7 +29,7 @@ else exit 1 fi -PD_DIR=$HOME_DIR/hugegraph-pd/apache-hugegraph-pd-incubating-$VersionInBash +PD_DIR=$HOME_DIR/hugegraph-pd/apache-hugegraph-pd-$VersionInBash pushd $PD_DIR . bin/start-hugegraph-pd.sh diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/start-server.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/start-server.sh index 7846b04512..b7b70e8cc9 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/start-server.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/start-server.sh @@ -17,13 +17,12 @@ # set -ev -HOME_DIR=$(pwd) -TRAVIS_DIR=$(dirname $0) +TRAVIS_DIR=$(cd "$(dirname "$0")" && pwd) BASE_DIR=$1 BACKEND=$2 JACOCO_PORT=$3 -JACOCO_DIR=${HOME_DIR}/${TRAVIS_DIR} +JACOCO_DIR=${TRAVIS_DIR} JACOCO_JAR=${JACOCO_DIR}/jacocoagent.jar BIN=$BASE_DIR/bin @@ -33,27 +32,46 @@ GREMLIN_CONF=$BASE_DIR/conf/gremlin-server.yaml . "${BIN}"/util.sh -declare -A backend_serializer_map=(["memory"]="text" \ - ["hbase"]="hbase" \ - ["rocksdb"]="binary" \ - ["hstore"]="binary") +function sed_in_place() { + local expression=$1 + local file=$2 -SERIALIZER=${backend_serializer_map[$BACKEND]} + case "$(uname)" in + Darwin) sed -i '' "$expression" "$file" ;; + *) sed -i "$expression" "$file" ;; + esac +} + +case "$BACKEND" in + memory) + SERIALIZER=text + ;; + hbase) + SERIALIZER=hbase + ;; + rocksdb|hstore) + SERIALIZER=binary + ;; + *) + echo "Unsupported backend: $BACKEND" + exit 1 + ;; +esac # Set backend and serializer -sed -i "s/backend=.*/backend=$BACKEND/" $CONF -sed -i "s/serializer=.*/serializer=$SERIALIZER/" $CONF +write_property "$CONF" "backend" "$BACKEND" +write_property "$CONF" "serializer" "$SERIALIZER" # Set timeout for hbase if [ "$BACKEND" == "hbase" ]; then - sed -i '$arestserver.request_timeout=200' $REST_CONF - sed -i '$agremlinserver.timeout=200' $REST_CONF - sed -i 's/evaluationTimeout.*/evaluationTimeout: 200000/' $GREMLIN_CONF + echo "restserver.request_timeout=200" >> $REST_CONF + echo "gremlinserver.timeout=200" >> $REST_CONF + sed_in_place 's/evaluationTimeout.*/evaluationTimeout: 200000/' "$GREMLIN_CONF" fi # Set usePD=true for hstore if [ "$BACKEND" == "hstore" ]; then - sed -i '$ausePD=true' $REST_CONF + echo "usePD=true" >> $REST_CONF fi # Append schema.sync_deletion=true to config file @@ -67,5 +85,14 @@ if [ -n "$JACOCO_PORT" ]; then JACOCO_OPTION="-javaagent:${JACOCO_JAR}=includes=*,port=${JACOCO_PORT},destfile=jacoco-it.exec,output=tcpserver" fi +SERVER_JAVA_OPTIONS="${SERVER_JAVA_OPTIONS:-}" +if [ -n "$SERVER_JAVA_OPTIONS" ]; then + if [ -n "$JACOCO_OPTION" ]; then + JACOCO_OPTION="${JACOCO_OPTION} ${SERVER_JAVA_OPTIONS}" + else + JACOCO_OPTION="${SERVER_JAVA_OPTIONS}" + fi +fi + echo -e "pa" | $BIN/init-store.sh $BIN/start-hugegraph.sh -j "$JACOCO_OPTION" -t 60 diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/start-store.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/start-store.sh index 8882df3a8e..3e876ce9a0 100755 --- a/hugegraph-server/hugegraph-dist/src/assembly/travis/start-store.sh +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/start-store.sh @@ -29,7 +29,7 @@ else exit 1 fi -STORE_DIR=$HOME_DIR/hugegraph-store/apache-hugegraph-store-incubating-$VersionInBash +STORE_DIR=$HOME_DIR/hugegraph-store/apache-hugegraph-store-$VersionInBash pushd $STORE_DIR . bin/start-hugegraph-store.sh diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph-pd.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph-pd.sh new file mode 100755 index 0000000000..db3428b13c --- /dev/null +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph-pd.sh @@ -0,0 +1,352 @@ +#!/bin/bash +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# test-start-hugegraph-pd.sh — Tests for start-hugegraph-pd.sh foreground mode fix +# +# Baseline (unmodified code): Tests 1 PASS — Tests 2, 3, 4 FAIL +# After chunk 2 fix: All 4 tests PASS +# +# Usage: ./test-start-hugegraph-pd.sh [path-to-pd-dist-root] +# path-to-pd-dist-root: path to extracted PD dist e.g. +# hugegraph-pd/apache-hugegraph-pd-1.7.0/ +# defaults to current directory if not provided + +set -uo pipefail + +PD_ROOT="${1:-$(pwd)}" +BIN="$PD_ROOT/bin" +START_SCRIPT="$BIN/start-hugegraph-pd.sh" +PID_FILE="$BIN/pid" +PD_URL="http://localhost:8620" +STARTUP_WAIT=60 # seconds to wait for PD HTTP to respond +SETTLE_WAIT=5 # seconds after kill before checking exit +WAIT_TIMEOUT=30 # seconds for wait_script_exit timeout + +PASS=0 +FAIL=0 +ERRORS=() + +GREEN='\033[0;32m' +RED='\033[0;31m' +YELLOW='\033[1;33m' +NC='\033[0m' + +pass() { + echo -e "${GREEN} PASS${NC} $1" + PASS=$((PASS + 1)) +} + +fail() { + echo -e "${RED} FAIL${NC} $1" + ERRORS+=("$1") + FAIL=$((FAIL + 1)) +} + +info() { + echo -e "${YELLOW} ....${NC} $1" +} + +section() { + echo "" + echo "── $1 ──" +} + +cleanup() { + info "Cleaning up..." + if [[ -s "$PID_FILE" ]]; then + kill "$(cat "$PID_FILE")" 2>/dev/null || true + fi + rm -f "$PID_FILE" + rm -rf "$PD_ROOT/logs/" + # kill anything still holding the PD port + lsof -ti :8620 | xargs kill -9 2>/dev/null || true + lsof -ti :8686 | xargs kill -9 2>/dev/null || true + sleep 3 +} + +# Wait until PD health endpoint responds or timeout +wait_for_pd() { + local elapsed=0 + while (( elapsed < STARTUP_WAIT )); do + local status + status=$(curl -s -o /dev/null -w "%{http_code}" \ + "$PD_URL/v1/health" 2>/dev/null || echo "000") + if [[ "$status" == "200" || "$status" == "401" ]]; then + return 0 + fi + sleep 2 + elapsed=$((elapsed + 2)) + done + return 1 +} + +# Wait until bin/pid is non-empty or timeout +wait_for_pid_file() { + local elapsed=0 + while [[ ! -s "$PID_FILE" ]] && (( elapsed < 30 )); do + sleep 1 + elapsed=$((elapsed + 1)) + done +} + +# Wait for a background script PID to exit with timeout +# Must be called from the same shell that spawned script_pid +wait_script_exit() { + local script_pid="$1" + ( sleep "$WAIT_TIMEOUT" && kill "$script_pid" 2>/dev/null ) & + local killer_pid=$! + wait "$script_pid" 2>/dev/null + local exit_code=$? + kill "$killer_pid" 2>/dev/null || true + wait "$killer_pid" 2>/dev/null || true + return $exit_code +} + +# ── preflight ───────────────────────────────────────────────────────────────── + +echo "" +echo "start-hugegraph-pd.sh chunk 2 test suite" +echo "root: $PD_ROOT" +echo "" + +if [[ ! -f "$START_SCRIPT" ]]; then + echo -e "${RED}ERROR:${NC} $START_SCRIPT not found." + echo " Pass the PD dist root as \$1" + exit 1 +fi + +for tool in lsof curl java; do + if ! command -v "$tool" >/dev/null 2>&1; then + echo "SKIP: required tool '$tool' not found — skipping test suite" + exit 0 + fi +done + +cleanup + +# ── test 1: daemon mode regression ─────────────────────────────────────────── + +section "Test 1 — daemon mode regression" + +info "Starting in daemon mode (no -d flag, default behavior)..." +"$START_SCRIPT" >/dev/null 2>&1 & +SCRIPT_PID=$! + +# daemon mode: script backgrounds Java and exits quickly +sleep 5 +if ! ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + pass "script exited after backgrounding Java (daemon mode)" +else + info "script still running after 5s (may still be starting)" + wait_script_exit "$SCRIPT_PID" || true +fi + +wait_for_pid_file +DAEMON_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$DAEMON_PID" ]]; then + pass "bin/pid written with PID $DAEMON_PID" +else + fail "bin/pid is empty or missing after daemon start" +fi + +if [[ -n "$DAEMON_PID" ]] && ps -p "$DAEMON_PID" >/dev/null 2>&1; then + pass "Java process is running (pid $DAEMON_PID)" +else + fail "Java process not found for pid '$DAEMON_PID'" +fi + +info "Waiting up to ${STARTUP_WAIT}s for PD health endpoint..." +if wait_for_pd; then + pass "PD health endpoint responding at $PD_URL/v1/health" +else + fail "PD health endpoint not responding after ${STARTUP_WAIT}s" +fi + +cleanup + +# ── test 2: foreground mode blocks ─────────────────────────────────────────── + +section "Test 2 — foreground mode blocks until Java exits" + +info "Starting in foreground mode (-d false)..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for PD to come up..." +if wait_for_pd; then + info "PD is up" +else + info "PD did not respond — continuing to check blocking behavior" +fi + +# foreground mode: script should still be running (blocked on Java) +if ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + pass "script is still running (blocking correctly)" +else + fail "script exited early — foreground mode is not blocking" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$FG_PID" ]]; then + info "pid file written with PID $FG_PID" +else + info "pid file not written (expected before chunk 2 fix)" +fi + +# cleanup: kill Java or the script +if [[ -n "$FG_PID" ]]; then + kill "$FG_PID" 2>/dev/null || true +else + kill "$SCRIPT_PID" 2>/dev/null || true +fi +sleep "$SETTLE_WAIT" + +if ! ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + info "script exited after Java was killed" +else + kill "$SCRIPT_PID" 2>/dev/null || true +fi + +cleanup + +# ── test 3: exit code propagates ───────────────────────────────────────────── + +section "Test 3 — exit code propagates from Java" + +info "Starting in foreground mode (-d false)..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for PD..." +if wait_for_pd; then + info "PD is up" +else + info "PD did not respond — continuing" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$FG_PID" ]]; then + pass "bin/pid written with PID $FG_PID" +else + fail "bin/pid is empty or missing in foreground mode" +fi + +if [[ -n "$FG_PID" ]] && ps -p "$FG_PID" >/dev/null 2>&1; then + pass "Java process running (pid $FG_PID)" +else + fail "Java process not found for pid '$FG_PID'" +fi + +if [[ -z "$FG_PID" ]]; then + fail "could not get PID — skipping exit code check" + kill "$SCRIPT_PID" 2>/dev/null || true +else + info "Hard-killing Java with SIGKILL (pid $FG_PID)..." + kill -9 "$FG_PID" 2>/dev/null || true + + wait_script_exit "$SCRIPT_PID" + ACTUAL_EXIT=$? + + if [[ $ACTUAL_EXIT -ne 0 ]]; then + pass "script exited non-zero ($ACTUAL_EXIT) after SIGKILL — Docker restart will fire" + else + fail "script exited 0 after SIGKILL — Docker would NOT restart (exit code lost)" + fi + + if [[ $ACTUAL_EXIT -eq 137 ]]; then + pass "exit code is 137 (128+9 for SIGKILL) — correctly propagated" + elif [[ $ACTUAL_EXIT -ne 0 ]]; then + info "exit code was $ACTUAL_EXIT (not 137 — may be shell-wrapped, acceptable if non-zero)" + fi +fi + +cleanup + +# ── test 4: SIGTERM forwarded to Java ──────────────────────────────────────── + +section "Test 4 — SIGTERM forwarded to Java in foreground mode" + +info "Starting in foreground mode (-d false)..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for PD..." +if wait_for_pd; then + info "PD is up" +else + info "PD did not respond — continuing" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -z "$FG_PID" ]]; then + fail "could not get Java PID — skipping SIGTERM check" + kill "$SCRIPT_PID" 2>/dev/null || true +else + info "Sending SIGTERM to process (pid $SCRIPT_PID)..." + # In foreground mode with exec, SCRIPT_PID == FG_PID after exec replaces the shell + # Signal goes directly to Java — no wrapper to forward through + kill -TERM "$SCRIPT_PID" 2>/dev/null || true + + wait_script_exit "$SCRIPT_PID" + ACTUAL_EXIT=$? + + if ! ps -p "$FG_PID" >/dev/null 2>&1; then + pass "Java process terminated after SIGTERM" + else + fail "Java process still running after SIGTERM — signal not delivered" + kill "$FG_PID" 2>/dev/null || true + fi + + if [[ $ACTUAL_EXIT -ne 0 ]]; then + pass "process exited non-zero ($ACTUAL_EXIT) after SIGTERM" + else + fail "process exited 0 after SIGTERM — unexpected" + fi + + if [[ $ACTUAL_EXIT -eq 143 ]]; then + pass "exit code is 143 (128+15 for SIGTERM) — correctly propagated" + elif [[ $ACTUAL_EXIT -ne 0 ]]; then + info "exit code was $ACTUAL_EXIT (not 143 — acceptable if non-zero)" + fi +fi + +cleanup + +# ── summary ─────────────────────────────────────────────────────────────────── + +echo "" +echo "════════════════════════════════" +echo -e " Results: ${GREEN}$PASS passed${NC} ${RED}$FAIL failed${NC}" +echo "════════════════════════════════" + +if [[ ${#ERRORS[@]} -gt 0 ]]; then + echo "" + echo "Failed tests:" + for err in "${ERRORS[@]}"; do + echo -e " ${RED}✗${NC} $err" + done +fi + +echo "" +[[ $FAIL -eq 0 ]] && exit 0 || exit 1 diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph-store.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph-store.sh new file mode 100755 index 0000000000..7da9323767 --- /dev/null +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph-store.sh @@ -0,0 +1,351 @@ +#!/bin/bash +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# test-start-hugegraph-store.sh — Tests for start-hugegraph-store.sh foreground mode fix +# +# Baseline (unmodified code): Test 1 PASS — Tests 2, 3, 4 FAIL +# After chunk 3 fix: All 4 tests PASS +# +# Usage: ./test-start-hugegraph-store.sh [path-to-store-dist-root] + +set -uo pipefail + +STORE_ROOT="${1:-$(pwd)}" +BIN="$STORE_ROOT/bin" +START_SCRIPT="$BIN/start-hugegraph-store.sh" +STOP_SCRIPT="$BIN/stop-hugegraph-store.sh" +PID_FILE="$BIN/pid" +STORE_URL="http://localhost:8520" +PD_URL="http://localhost:8620" +STARTUP_WAIT=60 # seconds to wait for Store HTTP to respond +SETTLE_WAIT=5 # seconds after kill before checking exit +WAIT_TIMEOUT=30 # seconds for wait_script_exit timeout + +PASS=0 +FAIL=0 +ERRORS=() + +GREEN='\033[0;32m' +RED='\033[0;31m' +YELLOW='\033[1;33m' +NC='\033[0m' + +pass() { echo -e "${GREEN} PASS${NC} $1"; PASS=$((PASS + 1)); } +fail() { echo -e "${RED} FAIL${NC} $1"; ERRORS+=("$1"); FAIL=$((FAIL + 1)); } +info() { echo -e "${YELLOW} ....${NC} $1"; } +section() { echo ""; echo "── $1 ──"; } + +cleanup() { + info "Cleaning up..." + if [[ -s "$PID_FILE" ]]; then + kill "$(cat "$PID_FILE")" 2>/dev/null || true + fi + rm -f "$PID_FILE" + rm -rf "$STORE_ROOT/logs/" + # kill anything holding Store ports (8520 REST, 8510 raft, 8500 gRPC) + lsof -ti :8520 | xargs kill -9 2>/dev/null || true + lsof -ti :8510 | xargs kill -9 2>/dev/null || true + lsof -ti :8500 | xargs kill -9 2>/dev/null || true + sleep 3 +} + +wait_for_store() { + local elapsed=0 + while (( elapsed < STARTUP_WAIT )); do + local status + status=$(curl -s -o /dev/null -w "%{http_code}" \ + "$STORE_URL/v1/health" 2>/dev/null || echo "000") + if [[ "$status" == "200" || "$status" == "401" ]]; then + return 0 + fi + sleep 2 + elapsed=$((elapsed + 2)) + done + return 1 +} + +wait_for_pid_file() { + local elapsed=0 + while [[ ! -s "$PID_FILE" ]] && (( elapsed < 30 )); do + sleep 1 + elapsed=$((elapsed + 1)) + done +} + +wait_script_exit() { + local script_pid="$1" + ( sleep "$WAIT_TIMEOUT" && kill "$script_pid" 2>/dev/null ) & + local killer_pid=$! + wait "$script_pid" 2>/dev/null + local exit_code=$? + kill "$killer_pid" 2>/dev/null || true + wait "$killer_pid" 2>/dev/null || true + return $exit_code +} + +# ── preflight ───────────────────────────────────────────────────────────────── + +echo "" +echo "start-hugegraph-store.sh chunk 3 test suite" +echo "root: $STORE_ROOT" +echo "" + +if [[ ! -f "$START_SCRIPT" ]]; then + echo -e "${RED}ERROR:${NC} $START_SCRIPT not found." + echo " Pass the Store dist root as \$1" + exit 1 +fi + +for tool in lsof curl java; do + if ! command -v "$tool" >/dev/null 2>&1; then + echo "SKIP: required tool '$tool' not found — skipping test suite" + exit 0 + fi +done + +# Store ulimit check (safely handling "unlimited" string) +LIMIT_N=$(ulimit -n) +if [[ "$LIMIT_N" != "unlimited" ]]; then + if (( LIMIT_N < 1024 )); then + echo "SKIP: ulimit -n is $LIMIT_N — store requires >= 1024. Run: ulimit -n 1024" + exit 0 + fi +fi + +# Check if PD is running, warn if not (Store depends on it for HTTP health check) +PD_RUNNING=false +PD_STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$PD_URL/v1/health" 2>/dev/null || echo "000") +if [[ "$PD_STATUS" == "200" || "$PD_STATUS" == "401" ]]; then + PD_RUNNING=true + info "PD is running — Store should become healthy" +else + info "PD is NOT running at $PD_URL — Store will start but health checks may timeout (Acceptable for this test)" +fi + +cleanup + +# ── test 1: daemon mode regression ─────────────────────────────────────────── + +section "Test 1 — daemon mode regression" + +info "Starting in daemon mode (no -d flag, default behavior)..." +"$START_SCRIPT" >/dev/null 2>&1 & +SCRIPT_PID=$! + +sleep 5 +if ! ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + pass "script exited after backgrounding Java (daemon mode)" +else + info "script still running after 5s (may still be starting)" + wait_script_exit "$SCRIPT_PID" || true +fi + +wait_for_pid_file +DAEMON_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$DAEMON_PID" ]]; then + pass "bin/pid written with PID $DAEMON_PID" +else + fail "bin/pid is empty or missing after daemon start" +fi + +if [[ -n "$DAEMON_PID" ]] && ps -p "$DAEMON_PID" >/dev/null 2>&1; then + pass "Java process is running (pid $DAEMON_PID)" +else + fail "Java process not found for pid '$DAEMON_PID'" +fi + +info "Waiting up to ${STARTUP_WAIT}s for Store health endpoint..." +if wait_for_store; then + pass "Store health endpoint responding at $STORE_URL/v1/health" +else + if [[ "$PD_RUNNING" == "true" ]]; then + fail "Store health endpoint not responding even though PD is up" + else + info "Store health endpoint not responding (Expected since PD is not running)" + fi +fi + +cleanup + +# ── test 2: foreground mode blocks ─────────────────────────────────────────── + +section "Test 2 — foreground mode blocks until Java exits" + +info "Starting in foreground mode (-d false)..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for Store to come up..." +if wait_for_store; then + info "Store is up" +else + info "Store did not respond — continuing to check blocking behavior" +fi + +if ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + pass "script is still running (blocking correctly)" +else + fail "script exited early — foreground mode is not blocking" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$FG_PID" ]]; then + info "pid file written with PID $FG_PID" +else + info "pid file not written (expected before chunk 3 fix)" +fi + +if [[ -n "$FG_PID" ]]; then + kill "$FG_PID" 2>/dev/null || true +else + kill "$SCRIPT_PID" 2>/dev/null || true +fi +sleep "$SETTLE_WAIT" + +if ! ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + info "script exited after Java was killed" +else + kill "$SCRIPT_PID" 2>/dev/null || true +fi + +cleanup + +# ── test 3: exit code propagates ───────────────────────────────────────────── + +section "Test 3 — exit code propagates from Java" + +info "Starting in foreground mode (-d false)..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for Store..." +if wait_for_store; then + info "Store is up" +else + info "Store did not respond — continuing" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$FG_PID" ]]; then + pass "bin/pid written with PID $FG_PID" +else + fail "bin/pid is empty or missing in foreground mode" +fi + +if [[ -n "$FG_PID" ]] && ps -p "$FG_PID" >/dev/null 2>&1; then + pass "Java process running (pid $FG_PID)" +else + fail "Java process not found for pid '$FG_PID'" +fi + +if [[ -z "$FG_PID" ]]; then + fail "could not get PID — skipping exit code check" + kill "$SCRIPT_PID" 2>/dev/null || true +else + info "Hard-killing Java with SIGKILL (pid $FG_PID)..." + kill -9 "$FG_PID" 2>/dev/null || true + + wait_script_exit "$SCRIPT_PID" + ACTUAL_EXIT=$? + + if [[ $ACTUAL_EXIT -ne 0 ]]; then + pass "script exited non-zero ($ACTUAL_EXIT) after SIGKILL" + else + fail "script exited 0 after SIGKILL — Docker would NOT restart" + fi + + if [[ $ACTUAL_EXIT -eq 137 ]]; then + pass "exit code is 137 (128+9 for SIGKILL) — correctly propagated" + elif [[ $ACTUAL_EXIT -ne 0 ]]; then + info "exit code was $ACTUAL_EXIT (not 137 — acceptable if non-zero)" + fi +fi + +cleanup + +# ── test 4: SIGTERM forwarded to Java ──────────────────────────────────────── + +section "Test 4 — SIGTERM forwarded to Java in foreground mode" + +info "Starting in foreground mode (-d false)..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for Store..." +if wait_for_store; then + info "Store is up" +else + info "Store did not respond — continuing" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -z "$FG_PID" ]]; then + fail "could not get Java PID — skipping SIGTERM check" + kill "$SCRIPT_PID" 2>/dev/null || true +else + info "Sending SIGTERM to process (pid $SCRIPT_PID)..." + kill -TERM "$SCRIPT_PID" 2>/dev/null || true + + wait_script_exit "$SCRIPT_PID" + ACTUAL_EXIT=$? + + if ! ps -p "$FG_PID" >/dev/null 2>&1; then + pass "Java process terminated after SIGTERM" + else + fail "Java process still running after SIGTERM — signal not delivered" + kill "$FG_PID" 2>/dev/null || true + fi + + if [[ $ACTUAL_EXIT -ne 0 ]]; then + pass "process exited non-zero ($ACTUAL_EXIT) after SIGTERM" + else + fail "process exited 0 after SIGTERM — unexpected" + fi + + if [[ $ACTUAL_EXIT -eq 143 ]]; then + pass "exit code is 143 (128+15 for SIGTERM) — correctly propagated" + elif [[ $ACTUAL_EXIT -ne 0 ]]; then + info "exit code was $ACTUAL_EXIT (not 143 — acceptable if non-zero)" + fi +fi + +cleanup + +# ── summary ─────────────────────────────────────────────────────────────────── + +echo "" +echo "════════════════════════════════" +echo -e " Results: ${GREEN}$PASS passed${NC} ${RED}$FAIL failed${NC}" +echo "════════════════════════════════" + +if [[ ${#ERRORS[@]} -gt 0 ]]; then + echo "" + echo "Failed tests:" + for err in "${ERRORS[@]}"; do + echo -e " ${RED}✗${NC} $err" + done +fi + +echo "" +[[ $FAIL -eq 0 ]] && exit 0 || exit 1 diff --git a/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph.sh b/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph.sh new file mode 100755 index 0000000000..d2dd492fc9 --- /dev/null +++ b/hugegraph-server/hugegraph-dist/src/assembly/travis/test-start-hugegraph.sh @@ -0,0 +1,437 @@ +#!/bin/bash +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# test-start-hugegraph.sh — Tests for start-hugegraph.sh foreground mode fix +# +# Baseline (unmodified code): Tests 1, 2, 4 PASS — Tests 3, 5 FAIL +# After chunk 1 fix: All 5 tests PASS +# +# Usage: ./test-start-hugegraph.sh [path-to-hugegraph-root] +# path-to-hugegraph-root: path to the extracted HugeGraph server dist directory +# defaults to current directory if not provided +# +# Note: Tests require crontab access. On macOS Catalina+ this may +# require Full Disk Access permission in System Preferences. +# Note: Assumes rocksdb backend. init-store.sh is run automatically if needed. + +set -uo pipefail + +HUGEGRAPH_ROOT="${1:-$(pwd)}" +BIN="$HUGEGRAPH_ROOT/bin" +START_SCRIPT="$BIN/start-hugegraph.sh" +STOP_SCRIPT="$BIN/stop-hugegraph.sh" +PID_FILE="$BIN/pid" +SERVER_URL="http://127.0.0.1:8080" +STARTUP_WAIT=60 # seconds to wait for server HTTP to respond +SETTLE_WAIT=5 # seconds after kill before checking process exit +WAIT_TIMEOUT=30 # seconds for timeout on wait calls +PASS=0 +FAIL=0 +ERRORS=() + +GREEN='\033[0;32m' +RED='\033[0;31m' +YELLOW='\033[1;33m' +NC='\033[0m' + +pass() { + echo -e "${GREEN} PASS${NC} $1" + PASS=$((PASS + 1)) +} + +fail() { + echo -e "${RED} FAIL${NC} $1" + ERRORS+=("$1") + FAIL=$((FAIL + 1)) +} + +info() { + echo -e "${YELLOW} ....${NC} $1" +} + +section() { + echo "" + echo "── $1 ──" +} + +# Kill server, clear pid file, kill ports, clear crontab monitor entry +cleanup() { + info "Cleaning up..." + "$STOP_SCRIPT" >/dev/null 2>&1 || true + if [[ -s "$PID_FILE" ]]; then + kill "$(cat "$PID_FILE")" 2>/dev/null || true + fi + rm -f "$PID_FILE" + # kill anything still holding server ports so check_port doesn't fail next test + lsof -ti :8080 | xargs kill -9 2>/dev/null || true + lsof -ti :8182 | xargs kill -9 2>/dev/null || true + lsof -ti :8088 | xargs kill -9 2>/dev/null || true + sleep 3 + crontab -l 2>/dev/null | grep -v monitor-hugegraph | crontab - 2>/dev/null || true +} + +# Wait until server HTTP endpoint responds (200 or 401) or timeout +wait_for_server() { + local elapsed=0 + while (( elapsed < STARTUP_WAIT )); do + local status + status=$(curl -s -o /dev/null -w "%{http_code}" \ + "$SERVER_URL/versions" 2>/dev/null || echo "000") + if [[ "$status" == "200" || "$status" == "401" ]]; then + return 0 + fi + sleep 2 + elapsed=$((elapsed + 2)) + done + return 1 +} + +# Wait until bin/pid is non-empty or timeout +wait_for_pid_file() { + local elapsed=0 + while [[ ! -s "$PID_FILE" ]] && (( elapsed < 30 )); do + sleep 1 + elapsed=$((elapsed + 1)) + done +} + +# Wait for a background script PID to exit, with timeout +# Usage: wait_script_exit +# Returns the real exit code of the process, or kills it after WAIT_TIMEOUT seconds +# NOTE: must be called from the same shell that spawned script_pid so that +# bash's built-in wait can track it as a child process +wait_script_exit() { + local script_pid="$1" + # background killer fires after timeout if process hasn't exited yet + ( sleep "$WAIT_TIMEOUT" && kill "$script_pid" 2>/dev/null ) & + local killer_pid=$! + wait "$script_pid" 2>/dev/null + local exit_code=$? + # cancel the killer if process already exited + kill "$killer_pid" 2>/dev/null || true + wait "$killer_pid" 2>/dev/null || true + return $exit_code +} + +# ── preflight ───────────────────────────────────────────────────────────────── + +echo "" +echo "start-hugegraph.sh chunk 1 test suite" +echo "root: $HUGEGRAPH_ROOT" +echo "" + +if [[ ! -f "$START_SCRIPT" ]]; then + echo -e "${RED}ERROR:${NC} $START_SCRIPT not found." + echo " Pass the HugeGraph dist root as \$1" + exit 1 +fi + +if [[ ! -f "$STOP_SCRIPT" ]]; then + echo -e "${RED}ERROR:${NC} $STOP_SCRIPT not found." + exit 1 +fi + +for tool in lsof crontab curl java; do + if ! command -v "$tool" >/dev/null 2>&1; then + echo "SKIP: required tool '$tool' not found — skipping test suite" + exit 0 + fi +done + +# start-monitor.sh requires JAVA_HOME +if [[ -z "${JAVA_HOME:-}" ]]; then + if command -v /usr/libexec/java_home >/dev/null 2>&1; then + export JAVA_HOME="$(/usr/libexec/java_home 2>/dev/null)" + fi +fi + +# Warn if JAVA_HOME could not be determined +if [[ -z "${JAVA_HOME:-}" ]]; then + echo -e "${YELLOW}WARN${NC} JAVA_HOME is not set" + echo " Test 4 may fail because start-monitor.sh requires JAVA_HOME" + echo " Export JAVA_HOME before running this script" +fi + +# Run init-store.sh once if RocksDB has not been initialized yet +if [[ ! -d "$HUGEGRAPH_ROOT/rocksdb-data" ]]; then + info "RocksDB not initialized — running init-store.sh..." + if "$BIN/init-store.sh" >/dev/null 2>&1; then + pass "init-store.sh completed successfully" + else + echo -e "${RED}ERROR:${NC} init-store.sh failed. Cannot run tests." + exit 1 + fi +else + info "RocksDB already initialized, skipping init-store.sh" +fi + +cleanup + +# ── test 1: daemon mode regression ─────────────────────────────────────────── + +section "Test 1 — daemon mode regression" + +info "Starting in daemon mode (waiting up to ${STARTUP_WAIT}s for HTTP)..." +"$START_SCRIPT" -d true -t "$STARTUP_WAIT" >/dev/null 2>&1 +EXIT_CODE=$? + +if [[ $EXIT_CODE -eq 0 ]]; then + pass "script returned exit 0 in daemon mode" +else + fail "script returned non-zero exit $EXIT_CODE in daemon mode" +fi + +wait_for_pid_file +DAEMON_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$DAEMON_PID" ]]; then + pass "bin/pid written with PID $DAEMON_PID" +else + fail "bin/pid is empty or missing after daemon start" +fi + +if [[ -n "$DAEMON_PID" ]] && ps -p "$DAEMON_PID" >/dev/null 2>&1; then + pass "Java process is running (pid $DAEMON_PID)" +else + fail "Java process not found for pid '$DAEMON_PID'" +fi + +if wait_for_server; then + pass "server HTTP endpoint responding at $SERVER_URL" +else + fail "server HTTP endpoint not responding after ${STARTUP_WAIT}s" +fi + +info "Stopping server..." +"$STOP_SCRIPT" >/dev/null 2>&1 +sleep 3 + +if [[ -n "$DAEMON_PID" ]] && ! ps -p "$DAEMON_PID" >/dev/null 2>&1; then + pass "stop-hugegraph.sh successfully killed the process" +else + fail "process still running after stop-hugegraph.sh" +fi + +cleanup + +# ── test 2: foreground mode blocks ─────────────────────────────────────────── + +section "Test 2 — foreground mode blocks until Java exits" + +info "Starting in foreground mode (backgrounded for observation)..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for server to come up..." +if wait_for_server; then + info "Server is up" +else + info "Server did not respond — continuing to check blocking behavior" +fi + +# Primary assertion: script must still be running while Java is alive +if ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + pass "script is still running (blocking correctly)" +else + fail "script exited early — foreground mode is not blocking" +fi + +# Secondary observations only (the actual bug is tested in Test 3) +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$FG_PID" ]]; then + info "pid file written with PID $FG_PID" +else + info "pid file not written in foreground mode (expected before chunk 1 fix)" +fi + +if [[ -n "$FG_PID" ]] && ps -p "$FG_PID" >/dev/null 2>&1; then + info "Java process running (pid $FG_PID)" +else + info "Java PID not available (expected before chunk 1 fix)" +fi + +if [[ -n "$FG_PID" ]]; then + info "Killing Java process..." + kill "$FG_PID" 2>/dev/null || true + sleep "$SETTLE_WAIT" + + if ! ps -p "$SCRIPT_PID" >/dev/null 2>&1; then + info "script exited after Java was killed" + else + info "script still running after Java was killed" + kill "$SCRIPT_PID" 2>/dev/null || true + fi +else + kill "$SCRIPT_PID" 2>/dev/null || true +fi + +cleanup + +# ── test 3: exit code propagates ───────────────────────────────────────────── + +section "Test 3 — foreground PID tracking and exit propagation" + +info "Starting in foreground mode..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for server..." +if wait_for_server; then + info "Server is up" +else + info "Server did not respond — continuing" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -n "$FG_PID" ]]; then + pass "bin/pid written with PID $FG_PID" +else + fail "bin/pid is empty or missing in foreground mode" +fi + +if [[ -n "$FG_PID" ]] && ps -p "$FG_PID" >/dev/null 2>&1; then + pass "Java process running (pid $FG_PID)" +else + fail "Java process not found for pid '$FG_PID'" +fi + +if [[ -z "$FG_PID" ]]; then + fail "could not get PID from pid file — skipping exit code check" + kill "$SCRIPT_PID" 2>/dev/null || true +else + info "Hard-killing Java with SIGKILL (pid $FG_PID)..." + kill -9 "$FG_PID" 2>/dev/null || true + + wait_script_exit "$SCRIPT_PID" + ACTUAL_EXIT=$? + + if [[ $ACTUAL_EXIT -ne 0 ]]; then + pass "script exited non-zero ($ACTUAL_EXIT) after SIGKILL — Docker restart will fire" + else + fail "script exited 0 after SIGKILL — Docker would NOT restart (exit code lost)" + fi + + if [[ $ACTUAL_EXIT -eq 137 ]]; then + pass "exit code is 137 (128+9 for SIGKILL) — correctly propagated" + elif [[ $ACTUAL_EXIT -ne 0 ]]; then + info "exit code was $ACTUAL_EXIT (not 137 — may be shell-wrapped, acceptable if non-zero)" + fi +fi + +cleanup + +# ── test 4: monitor registers in daemon mode ────────────────────────────────── + +section "Test 4 — -m true registers cron job in daemon mode" + +info "Clearing crontab..." +crontab -l 2>/dev/null | grep -v monitor-hugegraph | crontab - 2>/dev/null || true + +info "Starting in daemon mode with -m true (waiting up to ${STARTUP_WAIT}s)..." +"$START_SCRIPT" -d true -m true -t "$STARTUP_WAIT" >/dev/null 2>&1 +EXIT_CODE=$? + +if [[ $EXIT_CODE -eq 0 ]]; then + pass "daemon started successfully with -m true" +else + fail "daemon start failed with exit $EXIT_CODE — monitor may not have registered" +fi + +if crontab -l 2>/dev/null | grep -q "monitor-hugegraph"; then + pass "cron job registered for monitor-hugegraph.sh" +else + fail "cron job NOT registered — OPEN_MONITOR block broken in daemon mode" +fi + +info "Stopping server..." +"$STOP_SCRIPT" -m false >/dev/null 2>&1 || true + +cleanup + +# ── test 5: SIGTERM forwarded to Java in foreground mode ───────────────────── + +section "Test 5 — SIGTERM forwarded to Java in foreground mode" + +info "Starting in foreground mode..." +"$START_SCRIPT" -d false >/dev/null 2>&1 & +SCRIPT_PID=$! + +info "Waiting up to ${STARTUP_WAIT}s for server..." +if wait_for_server; then + info "Server is up" +else + info "Server did not respond — continuing" +fi + +wait_for_pid_file +FG_PID=$(cat "$PID_FILE" 2>/dev/null || echo "") + +if [[ -z "$FG_PID" ]]; then + fail "could not get Java PID — skipping signal forwarding check" + kill "$SCRIPT_PID" 2>/dev/null || true +else + info "Sending SIGTERM to wrapper script (pid $SCRIPT_PID)..." + kill -TERM "$SCRIPT_PID" 2>/dev/null || true + + wait_script_exit "$SCRIPT_PID" + ACTUAL_EXIT=$? + + # If the trap fired correctly, the wrapper's `wait $PID` already reaped Java. + # If wait_script_exit timed out (killer fired), Java may still be running — also a failure. + if ! ps -p "$FG_PID" >/dev/null 2>&1; then + pass "Java process terminated after SIGTERM sent to wrapper" + else + fail "Java process still running after SIGTERM — signal not forwarded" + kill "$FG_PID" 2>/dev/null || true + fi + + if [[ $ACTUAL_EXIT -ne 0 ]]; then + pass "wrapper script exited non-zero ($ACTUAL_EXIT) after SIGTERM" + else + fail "wrapper script exited 0 after SIGTERM — exit code not propagated" + fi + + if [[ $ACTUAL_EXIT -eq 143 ]]; then + pass "exit code is 143 (128+15 for SIGTERM) — correctly propagated" + elif [[ $ACTUAL_EXIT -ne 0 ]]; then + info "exit code was $ACTUAL_EXIT (not 143 — may be shell-wrapped, acceptable if non-zero)" + fi +fi + +cleanup + +# ── summary ─────────────────────────────────────────────────────────────────── + +echo "" +echo "════════════════════════════════" +echo -e " Results: ${GREEN}$PASS passed${NC} ${RED}$FAIL failed${NC}" +echo "════════════════════════════════" + +if [[ ${#ERRORS[@]} -gt 0 ]]; then + echo "" + echo "Failed tests:" + for err in "${ERRORS[@]}"; do + echo -e " ${RED}✗${NC} $err" + done +fi + +echo "" +[[ $FAIL -eq 0 ]] && exit 0 || exit 1 diff --git a/hugegraph-server/hugegraph-hbase/pom.xml b/hugegraph-server/hugegraph-hbase/pom.xml index 2ce0dd0d31..283f115a13 100644 --- a/hugegraph-server/hugegraph-hbase/pom.xml +++ b/hugegraph-server/hugegraph-hbase/pom.xml @@ -27,22 +27,107 @@ 4.0.0 hugegraph-hbase - + + 2.6.5 + org.apache.hugegraph hugegraph-core ${revision} + - com.baidu.hugegraph - hbase-shaded-endpoint - 2.0.6 + org.apache.hbase + hbase-endpoint + ${hbase.version} + + + org.apache.hbase + hbase-server + + + + org.apache.hbase + hbase-mapreduce + + + + org.apache.hadoop + hadoop-auth + + + + org.apache.hadoop + hadoop-client + + + + org.slf4j + slf4j-api + + + + org.xerial.snappy + snappy-java + + log4j log4j + + log4j + apache-log4j-extras + + + org.slf4j + slf4j-log4j12 + + + + org.apache.hadoop + hadoop-common + + + org.apache.hadoop + hadoop-hdfs + + + org.apache.hadoop + hadoop-mapreduce-client-core + + + + + org.apache.hbase + hbase-shaded-client + ${hbase.version} + + + + org.slf4j + slf4j-api + diff --git a/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlSerializer.java b/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlSerializer.java index 595ab609bd..bee704087c 100644 --- a/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlSerializer.java +++ b/hugegraph-server/hugegraph-mysql/src/main/java/org/apache/hugegraph/backend/store/mysql/MysqlSerializer.java @@ -23,9 +23,11 @@ import java.util.Set; import org.apache.commons.lang.NotImplementedException; +import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.backend.BackendException; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.query.ConditionQuery; import org.apache.hugegraph.backend.serializer.TableBackendEntry; import org.apache.hugegraph.backend.serializer.TableSerializerV2; import org.apache.hugegraph.backend.store.BackendEntry; @@ -33,6 +35,7 @@ import org.apache.hugegraph.schema.SchemaElement; import org.apache.hugegraph.structure.HugeElement; import org.apache.hugegraph.structure.HugeProperty; +import org.apache.hugegraph.structure.HugeVectorIndexMap; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.type.HugeType; import org.apache.hugegraph.type.define.HugeKeys; @@ -172,4 +175,15 @@ protected void readUserdata(SchemaElement schema, public BackendEntry writeOlapVertex(HugeVertex vertex) { throw new NotImplementedException("Unsupported writeOlapVertex()"); } + + @Override + public BackendEntry writeVectorSequence(HugeVectorIndexMap indexMap) { + throw new NotImplementedException("Unsupported writeVectorSequence()"); + } + + @Override + public HugeVectorIndexMap readVectorSequence(HugeGraph graph, ConditionQuery query, + BackendEntry entry) { + throw new NotImplementedException("Unsupported readVectorSequence()"); + } } diff --git a/hugegraph-server/hugegraph-rocksdb/pom.xml b/hugegraph-server/hugegraph-rocksdb/pom.xml index 3cf448c9cb..845cf40f9c 100644 --- a/hugegraph-server/hugegraph-rocksdb/pom.xml +++ b/hugegraph-server/hugegraph-rocksdb/pom.xml @@ -37,7 +37,7 @@ org.rocksdb rocksdbjni - 7.2.2 + 8.10.2 diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java index 3b6b54eadb..ccfecb063d 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBStore.java @@ -1012,6 +1012,11 @@ public RocksDBGraphStore(BackendStoreProvider provider, new RocksDBTables.ShardIndex(database)); registerTableManager(HugeType.UNIQUE_INDEX, new RocksDBTables.UniqueIndex(database)); + registerTableManager(HugeType.VECTOR_INDEX_MAP, + new RocksDBTables.VectorIndexMap(database)); + registerTableManager(HugeType.VECTOR_SEQUENCE, + new RocksDBTables.VectorSequence(database)); + registerTableManager(this.olapTableName(HugeType.SECONDARY_INDEX), new RocksDBTables.OlapSecondaryIndex(store)); diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTable.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTable.java index 824986d22c..23e88def9b 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTable.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTable.java @@ -21,6 +21,7 @@ import java.util.Collection; import java.util.Collections; import java.util.Iterator; + import java.util.List; import java.util.Set; @@ -215,6 +216,16 @@ protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, )); } + protected BackendColumnIterator queryByIdsWithGet(RocksDBSessions.Session session, + Collection ids) { + E.checkState(!session.hasChanges(), + "Can't queryByIds() when RocksDB session has pending changes"); + if (ids.isEmpty()) { + return BackendColumnIterator.empty(); + } + return this.getByIds(session, ids); + } + protected BackendColumnIterator getById(RocksDBSessions.Session session, Id id) { byte[] value = session.get(this.table(), id.asBytes()); if (value == null) { @@ -224,7 +235,8 @@ protected BackendColumnIterator getById(RocksDBSessions.Session session, Id id) return BackendColumnIterator.iterator(col); } - protected BackendColumnIterator getByIds(RocksDBSessions.Session session, Set ids) { + protected BackendColumnIterator getByIds(RocksDBSessions.Session session, + Collection ids) { if (ids.size() == 1) { return this.getById(session, ids.iterator().next()); } @@ -309,7 +321,7 @@ protected static BackendEntryIterator newEntryIterator(BackendColumnIterator col } protected static BackendEntryIterator newEntryIteratorOlap( - BackendColumnIterator cols, Query query, boolean isOlap) { + BackendColumnIterator cols, Query query, boolean isOlap) { return new BinaryEntryIterator<>(cols, query, (entry, col) -> { if (entry == null || !entry.belongToMe(col)) { HugeType type = query.resultType(); diff --git a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java index 37cc2f151c..30d8dff3c1 100644 --- a/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java +++ b/hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTables.java @@ -182,8 +182,7 @@ protected BackendColumnIterator queryById(RocksDBSessions.Session session, Id id @Override protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, Collection ids) { - // TODO: use getByIds() after batch version multi-get is ready - return super.queryByIds(session, ids); + return this.queryByIdsWithGet(session, ids); } } @@ -208,6 +207,12 @@ public static Edge in(String database) { protected BackendColumnIterator queryById(RocksDBSessions.Session session, Id id) { return this.getById(session, id); } + + @Override + protected BackendColumnIterator queryByIds(RocksDBSessions.Session session, + Collection ids) { + return this.queryByIdsWithGet(session, ids); + } } public static class IndexTable extends RocksDBTable { @@ -389,6 +394,18 @@ public ShardIndex(String database) { } } + public static class VectorIndexMap extends IndexTable { + public static final String TABLE = HugeType.VECTOR_INDEX_MAP.string(); + + public VectorIndexMap(String database) { super(database, TABLE); } + } + + public static class VectorSequence extends IndexTable { + public static final String TABLE = HugeType.VECTOR_SEQUENCE.string(); + + public VectorSequence(String database) { super(database, TABLE); } + } + public static class OlapTable extends RocksDBTable { public static final String TABLE = HugeType.OLAP.string(); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ApiTestSuite.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ApiTestSuite.java index 07eb608adf..1fe8fc45fa 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ApiTestSuite.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ApiTestSuite.java @@ -42,6 +42,8 @@ CypherApiTest.class, ArthasApiTest.class, GraphSpaceApiTest.class, + GraphSpaceApiStandaloneTest.class, + ManagerApiStandaloneTest.class, }) public class ApiTestSuite { diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java index 45fceafc78..a6f84de33e 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java @@ -39,6 +39,7 @@ import org.junit.After; import org.junit.AfterClass; import org.junit.Assert; +import org.junit.Assume; import org.junit.BeforeClass; import com.fasterxml.jackson.databind.JavaType; @@ -61,9 +62,9 @@ public class BaseApiTest { protected static final String BASE_URL = "http://127.0.0.1:8080"; private static final String GRAPH = "hugegraph"; private static final String GRAPHSPACE = "DEFAULT"; - private static final String USERNAME = "admin"; protected static final String URL_PREFIX = "graphspaces/" + GRAPHSPACE + "/graphs/" + GRAPH; protected static final String TRAVERSERS_API = URL_PREFIX + "/traversers"; + private static final String USERNAME = "admin"; private static final String PASSWORD = "pa"; private static final int NO_LIMIT = -1; private static final String SCHEMA_PKS = "/schema/propertykeys"; @@ -73,10 +74,19 @@ public class BaseApiTest { private static final String GRAPH_VERTEX = "/graph/vertices"; private static final String GRAPH_EDGE = "/graph/edges"; private static final String BATCH = "/batch"; - - protected static RestClient client; - + static final String STANDALONE_ERROR = + "GraphSpace management is not supported in standalone mode"; + + private static final String ROCKSDB_CONFIG_TEMPLATE = + "{ \"gremlin.graph\": \"org.apache.hugegraph.HugeFactory\"," + + "\"backend\": \"rocksdb\", \"serializer\": \"binary\"," + + "\"store\": \"%s\", \"nickname\": \"%s\"," + + "\"rocksdb.data_path\": \"rocksdbtest-data-%s\"," + + "\"rocksdb.wal_path\": \"rocksdbtest-data-%s\"," + + "\"search.text_analyzer\": \"jieba\"," + + "\"search.text_analyzer_mode\": \"INDEX\" }"; private static final ObjectMapper MAPPER = new ObjectMapper(); + protected static RestClient client; @BeforeClass public static void init() { @@ -90,19 +100,10 @@ public static void clear() throws Exception { client = null; } - @After - public void teardown() throws Exception { - BaseApiTest.clearData(); - } - public static String baseUrl() { return BASE_URL; } - public RestClient client() { - return client; - } - public static RestClient newClient() { return new RestClient(BASE_URL); } @@ -184,7 +185,8 @@ protected static void waitTaskStatus(int task, Set expectedStatus) { Assert.fail(String.format("Failed to wait for task %s " + "due to timeout", task)); } - } while (!expectedStatus.contains(status)); + } + while (!expectedStatus.contains(status)); } protected static void initVertexLabel() { @@ -661,6 +663,17 @@ public static Response createGraph(String graphSpace, String name) { return createGraph(graphSpace, name, name); } + public static Response createGraphInRocksDB(String graphSpace, String name) { + return createGraphInRocksDB(graphSpace, name, name); + } + + public static Response createGraphInRocksDB(String graphSpace, String name, + String nickname) { + String path = String.format("graphspaces/%s/graphs/%s", graphSpace, name); + String config = String.format(ROCKSDB_CONFIG_TEMPLATE, name, nickname, name, name); + return client.post(path, Entity.json(config)); + } + public static Response createGraph(String graphSpace, String name, String nickname) { String config = "{\n" + @@ -728,6 +741,30 @@ public static RestClient analystClient(String graphSpace, String username) { return analystClient; } + /** + * Skips the current test when the server backend is not known to be in + * standalone mode. Treats both {@code "hstore"} and {@code null} + * (i.e. the backend property is not provided/unknown) as PD/distributed + * mode and skips the test for safety. + * Call this from a {@code @Before} method in standalone-only test classes. + */ + public static void assumeStandaloneMode() { + String backend = System.getProperty("backend"); + boolean isPdMode = backend == null || "hstore".equals(backend); + Assume.assumeFalse( + "Skip when backend is hstore (PD/distributed) or not specified", + isPdMode); + } + + @After + public void teardown() throws Exception { + BaseApiTest.clearData(); + } + + public RestClient client() { + return client; + } + public static class RestClient { private final Client client; diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphSpaceApiStandaloneTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphSpaceApiStandaloneTest.java new file mode 100644 index 0000000000..21e3975a21 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphSpaceApiStandaloneTest.java @@ -0,0 +1,91 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.api; + +import com.google.common.collect.ImmutableMap; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import jakarta.ws.rs.core.Response; + +/** + * Tests that GraphSpaceAPI returns a friendly HTTP 400 error in standalone + * mode (i.e. when the server is started without PD / hstore backend). + *

      + * This class intentionally does NOT have a class-level Assume guard so that + * the tests are actually executed in non-hstore CI runs. + */ +public class GraphSpaceApiStandaloneTest extends BaseApiTest { + + private static final String PATH = "graphspaces"; + + @Before + public void skipForPdMode() { + assumeStandaloneMode(); + } + + @Test + public void testProfileReturnsFriendlyError() { + Response r = this.client().get(PATH + "/profile"); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testListReturnsFriendlyError() { + Response r = this.client().get(PATH); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testGetReturnsFriendlyError() { + Response r = this.client().get(PATH, "DEFAULT"); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testCreateReturnsFriendlyError() { + String body = "{\"name\":\"test_standalone\",\"nickname\":\"test\"," + + "\"description\":\"test\",\"cpu_limit\":10," + + "\"memory_limit\":10,\"storage_limit\":10," + + "\"max_graph_number\":10,\"max_role_number\":10," + + "\"auth\":false,\"configs\":{}}"; + Response r = this.client().post(PATH, body); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testManageReturnsFriendlyError() { + String body = "{\"action\":\"update\",\"update\":{\"name\":\"DEFAULT\"}}"; + Response r = this.client().put(PATH, "DEFAULT", body, ImmutableMap.of()); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testDeleteReturnsFriendlyError() { + Response r = this.client().delete(PATH, "nonexistent"); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphSpaceApiTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphSpaceApiTest.java index d18409ff2f..1c3eb77995 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphSpaceApiTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphSpaceApiTest.java @@ -22,10 +22,13 @@ import java.util.Objects; import org.apache.hugegraph.util.JsonUtil; +import org.junit.Assert; import org.junit.Assume; import org.junit.Before; import org.junit.Test; +import com.google.common.collect.ImmutableMap; + import jakarta.ws.rs.core.Response; public class GraphSpaceApiTest extends BaseApiTest { @@ -39,7 +42,7 @@ public void removeSpaces() { Response r = this.client().get(PATH); String result = r.readEntity(String.class); Map resultMap = JsonUtil.fromJson(result, Map.class); - List spaces = (List) resultMap.get("graphSpaces"); + List spaces = (List)resultMap.get("graphSpaces"); for (String space : spaces) { if (!"DEFAULT".equals(space)) { this.client().delete(PATH, space); @@ -51,8 +54,8 @@ public void removeSpaces() { public void testAddSpaceNamespace() { String body = "{\n" + " \"name\": \"test_add_no_ns\",\n" + - " \"nickname\":\"Test No Namespace\",\n" + - " \"description\": \"no namespace\",\n" + + " \"nickname\":\"TestNoNamespace\",\n" + + " \"description\": \"nonamespace\",\n" + " \"cpu_limit\": 1000,\n" + " \"memory_limit\": 1024,\n" + " \"storage_limit\": 1000,\n" + @@ -73,8 +76,8 @@ public void testAddSpaceNamespace() { String body2 = "{\n" + " \"name\": \"test_add_has_ns\",\n" + - " \"nickname\":\"Test With Namespace\",\n" + - " \"description\": \"has namespace\",\n" + + " \"nickname\":\"TestWithNamespace\",\n" + + " \"description\": \"hasnamespace\",\n" + " \"cpu_limit\": 1000,\n" + " \"memory_limit\": 1024,\n" + " \"storage_limit\": 1000,\n" + @@ -105,8 +108,8 @@ public void testDeleteSpace() { String spaceName = "test_delete_space"; String body = "{" + "\"name\":\"" + spaceName + "\"," - + "\"nickname\":\"Test Delete Space\"," - + "\"description\":\"Test delete space\"," + + "\"nickname\":\"TestDeleteSpace\"," + + "\"description\":\"Testdeletespace\"," + "\"cpu_limit\":1000," + "\"memory_limit\":1024," + "\"storage_limit\":1000," @@ -145,8 +148,8 @@ public void testCreateSpaceWithSameName() { String spaceName = "duplicate_space"; String body = "{" + "\"name\":\"" + spaceName + "\"," - + "\"nickname\":\"Duplicate Test Space\"," - + "\"description\":\"Test duplicate space\"," + + "\"nickname\":\"DuplicateTestSpace\"," + + "\"description\":\"Testduplicatespace\"," + "\"cpu_limit\":1000," + "\"memory_limit\":1024," + "\"storage_limit\":1000," @@ -179,8 +182,8 @@ public void testSpaceResourceLimits() { // Test minimum limits String minLimitsBody = "{" + "\"name\":\"" + spaceName + "_min\"," - + "\"nickname\":\"Minimum Limits Test\"," - + "\"description\":\"Test minimum limits\"," + + "\"nickname\":\"MinimumLimitsTest\"," + + "\"description\":\"Testminimumlimits\"," + "\"cpu_limit\":1," + "\"memory_limit\":1," + "\"storage_limit\":1," @@ -203,8 +206,8 @@ public void testSpaceResourceLimits() { // Test maximum limits String maxLimitsBody = "{" + "\"name\":\"" + spaceName + "_max\"," - + "\"nickname\":\"Maximum Limits Test\"," - + "\"description\":\"Test maximum limits\"," + + "\"nickname\":\"MaximumLimitsTest\"," + + "\"description\":\"Testmaximumlimits\"," + "\"cpu_limit\":999999," + "\"memory_limit\":999999," + "\"storage_limit\":999999," @@ -275,4 +278,157 @@ public void testInvalidSpaceCreation() { r = this.client().post(PATH, negativeLimitsBody); assertResponseStatus(400, r); } + + @Test + public void testListProfile() { + // Get profile list without prefix + Response r = this.client().get(PATH + "/profile"); + String result = assertResponseStatus(200, r); + + @SuppressWarnings("unchecked") + List> profiles = JsonUtil.fromJson(result, List.class); + + // Should contain at least the DEFAULT space + Assert.assertTrue("Expected at least one profile", profiles.size() >= 1); + + // Verify profile structure + for (Map profile : profiles) { + Assert.assertTrue("Profile should contain 'name'", + profile.containsKey("name")); + Assert.assertTrue("Profile should contain 'authed'", + profile.containsKey("authed")); + Assert.assertTrue("Profile should contain 'create_time'", + profile.containsKey("create_time")); + Assert.assertTrue("Profile should contain 'update_time'", + profile.containsKey("update_time")); + Assert.assertTrue("Profile should contain 'default'", + profile.containsKey("default")); + } + } + + @Test + public void testListProfileWithPrefix() { + // Create test spaces with different names + String space1 = "{" + + "\"name\":\"test_profile_space1\"," + + "\"nickname\":\"TestProfileSpace\"," + + "\"description\":\"Testprofilelisting\"," + + "\"cpu_limit\":1000," + + "\"memory_limit\":1024," + + "\"storage_limit\":1000," + + "\"compute_cpu_limit\":0," + + "\"compute_memory_limit\":0," + + "\"oltp_namespace\":null," + + "\"olap_namespace\":null," + + "\"storage_namespace\":null," + + "\"operator_image_path\":\"test\"," + + "\"internal_algorithm_image_url\":\"test\"," + + "\"max_graph_number\":100," + + "\"max_role_number\":100," + + "\"auth\":false," + + "\"configs\":{}" + + "}"; + + // Create a space that should NOT match the prefix filter + String space2 = "{" + + "\"name\":\"other_profile_space\"," + + "\"nickname\":\"OtherProfileSpace\"," + + "\"description\":\"Other profile listing\"," + + "\"cpu_limit\":1000," + + "\"memory_limit\":1024," + + "\"storage_limit\":1000," + + "\"compute_cpu_limit\":0," + + "\"compute_memory_limit\":0," + + "\"oltp_namespace\":null," + + "\"olap_namespace\":null," + + "\"storage_namespace\":null," + + "\"operator_image_path\":\"test\"," + + "\"internal_algorithm_image_url\":\"test\"," + + "\"max_graph_number\":100," + + "\"max_role_number\":100," + + "\"auth\":false," + + "\"configs\":{}" + + "}"; + + // Create spaces + Response r = this.client().post(PATH, space1); + assertResponseStatus(201, r); + r = this.client().post(PATH, space2); + assertResponseStatus(201, r); + + // Test with prefix filter + r = this.client().get(PATH + "/profile", + ImmutableMap.of("prefix", "test")); + String result = assertResponseStatus(200, r); + + @SuppressWarnings("unchecked") + List> profiles = JsonUtil.fromJson(result, List.class); + Assert.assertFalse("Expected non-empty profile list with prefix filter", + profiles.isEmpty()); + + // Verify all returned profiles match the prefix + for (Map profile : profiles) { + String name = Objects.toString(profile.get("name"), ""); + String nickname = Objects.toString(profile.get("nickname"), ""); + boolean matchesPrefix = name.startsWith("test") || + nickname.startsWith("test") || + nickname.startsWith("Test"); + Assert.assertTrue( + "Profile should match prefix 'test': " + profile, + matchesPrefix); + + // Ensure the non-matching space is excluded + Assert.assertNotEquals("Non-matching space should be filtered out", + "other_profile_space", name); + } + } + + @Test + public void testListProfileWithAuth() { + // Create a space with auth enabled + String authSpace = "{" + + "\"name\":\"auth_test_space\"," + + "\"nickname\":\"AuthTestSpace\"," + + "\"description\":\"Test auth in profile\"," + + "\"cpu_limit\":1000," + + "\"memory_limit\":1024," + + "\"storage_limit\":1000," + + "\"compute_cpu_limit\":0," + + "\"compute_memory_limit\":0," + + "\"oltp_namespace\":null," + + "\"olap_namespace\":null," + + "\"storage_namespace\":null," + + "\"operator_image_path\":\"test\"," + + "\"internal_algorithm_image_url\":\"test\"," + + "\"max_graph_number\":100," + + "\"max_role_number\":100," + + "\"auth\":true," + + "\"configs\":{}" + + "}"; + + Response r = this.client().post(PATH, authSpace); + assertResponseStatus(201, r); + + // Get profile list + r = this.client().get(PATH + "/profile"); + String result = assertResponseStatus(200, r); + + @SuppressWarnings("unchecked") + List> profiles = JsonUtil.fromJson(result, List.class); + + // Find the auth_test_space and verify authed field + boolean found = false; + for (Map profile : profiles) { + if ("auth_test_space".equals(profile.get("name"))) { + found = true; + // Admin user should be authed + Assert.assertTrue("Profile should contain 'authed' field", + profile.containsKey("authed")); + Assert.assertEquals("Admin user should be authorized", + true, profile.get("authed")); + break; + } + } + Assert.assertTrue("auth_test_space not found in profile list", found); + } } diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java index 469a83e510..efd7c3e766 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java @@ -18,42 +18,335 @@ package org.apache.hugegraph.api; import java.util.HashMap; +import java.util.List; import java.util.Map; -import org.junit.AfterClass; -import org.junit.BeforeClass; +import org.apache.hugegraph.util.JsonUtil; +import org.junit.Assert; import org.junit.Test; +import com.google.common.collect.ImmutableMap; + +import jakarta.ws.rs.client.Entity; import jakarta.ws.rs.core.Response; public class GraphsApiTest extends BaseApiTest { - private static final String TEMP_SPACE = "graph_test"; - private static final String TEMP_AUTH_SPACE = "graph_auth_test"; - private static final String PATH = "graphspaces/graph_test/graphs"; - private static final String PATH_AUTH = "graphspaces/graph_auth_test" + - "/graphs"; + private static final String TEMP_SPACE = "DEFAULT"; + private static final String PATH = "graphspaces/DEFAULT/graphs"; + + @Test + public void testListGraphs() { + try { + // Create multiple graphs + Response r1 = createGraphInRocksDB(TEMP_SPACE, "listtest1"); + assertResponseStatus(201, r1); + + Response r2 = createGraphInRocksDB(TEMP_SPACE, "listtest2"); + assertResponseStatus(201, r2); + + // List all graphs + Response r = client().get(PATH); + String content = assertResponseStatus(200, r); + + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertTrue(result.containsKey("graphs")); + + @SuppressWarnings("unchecked") + List graphs = (List) result.get("graphs"); + Assert.assertTrue(graphs.contains("listtest1")); + Assert.assertTrue(graphs.contains("listtest2")); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/listtest1", params); + client().delete(PATH + "/listtest2", params); + } + } + + @Test + public void testGetGraph() { + try { + // Create a graph + Response r = createGraphInRocksDB(TEMP_SPACE, "get_test", "GetTestGraph"); + assertResponseStatus(201, r); + + // Get the graph + Response getResponse = client().get(PATH + "/get_test"); + String content = assertResponseStatus(200, getResponse); + + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertTrue(result.containsKey("name")); + Assert.assertTrue(result.containsKey("backend")); + Assert.assertEquals("get_test", result.get("name")); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/get_test", params); + } + } + + @Test + public void testcreateGraphInRocksDB() { + try { + String config = "{\n" + + " \"gremlin.graph\": \"org.apache.hugegraph.HugeFactory\",\n" + + " \"backend\": \"rocksdb\",\n" + + " \"serializer\": \"binary\",\n" + + " \"store\": \"create_test\",\n" + + " \"nickname\": \"CreateTestGraph\",\n" + + " \"description\": \"Test graph creation\",\n" + + " \"rocksdb.data_path\": \"rocksdbtest-data-create_test\",\n" + + " \"rocksdb.wal_path\": \"rocksdbtest-data-create_test\"\n" + + "}"; + + Response r = client().post(PATH + "/create_test", + Entity.json(config)); + String content = assertResponseStatus(201, r); + + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertEquals("create_test", result.get("name")); + Assert.assertEquals("CreateTestGraph", result.get("nickname")); + Assert.assertEquals("rocksdb", result.get("backend")); + Assert.assertEquals("Test graph creation", result.get("description")); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/create_test", params); + } + } + + @Test + public void testcreateGraphInRocksDBWithMissingRequiredParams() { + // Missing 'backend' parameter + String config = "{\n" + + " \"serializer\": \"binary\",\n" + + " \"store\": \"invalid_test\"\n" + + "}"; - @BeforeClass - public static void prepareSpace() { - createSpace(TEMP_SPACE, false); - createSpace(TEMP_AUTH_SPACE, true); + Response r = client().post(PATH + "/invalid_test", + Entity.json(config)); + Assert.assertTrue(r.getStatus() >= 400); } - @AfterClass - public static void tearDown() { - clearSpaces(); + @Test + public void testCloneGraph() { + try { + // Create source graph + Response r1 = createGraphInRocksDB(TEMP_SPACE, "clone_source", "SourceGraph"); + assertResponseStatus(201, r1); + + // Clone the graph + String config = "{\n" + + " \"gremlin.graph\": \"org.apache.hugegraph.HugeFactory\",\n" + + " \"backend\": \"rocksdb\",\n" + + " \"serializer\": \"binary\",\n" + + " \"store\": \"clone_target\",\n" + + " \"nickname\": \"ClonedGraph\",\n" + + " \"rocksdb.data_path\": \"rocksdbtest-data-clone_target\",\n" + + " \"rocksdb.wal_path\": \"rocksdbtest-data-clone_target\"\n" + + "}"; + + Map params = ImmutableMap.of( + "clone_graph_name", "clone_source"); + + String path = PATH + "/clone_target"; + Response r = client().target(baseUrl()) + .path(path) + .queryParam("clone_graph_name", "clone_source") + .request() + .post(Entity.json(config)); + + String content = assertResponseStatus(201, r); + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertEquals("clone_target", result.get("name")); + } finally { + // Clean up + Map deleteParams = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/clone_source", deleteParams); + client().delete(PATH + "/clone_target", deleteParams); + } } @Test public void testDeleteGraph() { - Response r = createGraph(TEMP_SPACE, "delete"); + Response r = createGraphInRocksDB(TEMP_SPACE, "delete_test"); assertResponseStatus(201, r); Map params = new HashMap<>(); params.put("confirm_message", "I'm sure to drop the graph"); - r = client().delete(PATH + "/delete", params); + r = client().delete(PATH + "/delete_test", params); assertResponseStatus(204, r); + + // Verify graph is deleted + Response getResponse = client().get(PATH + "/delete_test"); + Assert.assertTrue(getResponse.getStatus() >= 400); + } + + @Test + public void testDeleteGraphWithoutConfirmMessage() { + try { + Response r = createGraphInRocksDB(TEMP_SPACE, "delete_no_confirm"); + assertResponseStatus(201, r); + + // Try to delete without confirmation + Response deleteResponse = client().delete(PATH + "/delete_no_confirm", + new HashMap<>()); + Assert.assertTrue(deleteResponse.getStatus() >= 400); + } finally { + // Clean up properly + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/delete_no_confirm", params); + } + } + + @Test + public void testClearGraph() { + try { + Response r = createGraphInRocksDB(TEMP_SPACE, "clear_test"); + assertResponseStatus(201, r); + + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to delete all data"); + + Response clearResponse = client().delete(PATH + "/clear_test/clear", + params); + assertResponseStatus(204, clearResponse); + } finally { + // Clean up + Map deleteParams = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/clear_test", deleteParams); + } + } + + @Test + public void testClearGraphWithoutConfirmMessage() { + try { + Response r = createGraphInRocksDB(TEMP_SPACE, "clear_no_confirm"); + assertResponseStatus(201, r); + + // Try to clear without confirmation + Response clearResponse = client().delete(PATH + "/clear_no_confirm/clear", + new HashMap<>()); + Assert.assertTrue(clearResponse.getStatus() >= 400); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/clear_no_confirm", params); + } + } + + @Test + public void testSetGraphMode() { + try { + Response r = createGraphInRocksDB(TEMP_SPACE, "mode_test"); + assertResponseStatus(201, r); + + // Set mode to RESTORING + String modeJson = "\"RESTORING\""; + Response modeResponse = client().target(baseUrl()) + .path(PATH + "/mode_test/mode") + .request() + .put(Entity.json(modeJson)); + + String content = assertResponseStatus(200, modeResponse); + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertEquals("RESTORING", result.get("mode")); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/mode_test", params); + } + } + + @Test + public void testGetGraphMode() { + try { + Response r = createGraphInRocksDB(TEMP_SPACE, "get_mode_test"); + assertResponseStatus(201, r); + + Response modeResponse = client().get(PATH + "/get_mode_test/mode"); + String content = assertResponseStatus(200, modeResponse); + + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertTrue(result.containsKey("mode")); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/get_mode_test", params); + } + } + + @Test + public void testSetGraphReadMode() { + try { + Response r = createGraphInRocksDB(TEMP_SPACE, "read_mode_test"); + assertResponseStatus(201, r); + + // Set read mode to OLTP_ONLY + String readModeJson = "\"OLTP_ONLY\""; + Response readModeResponse = client().target(baseUrl()) + .path(PATH + "/read_mode_test/graph_read_mode") + .request() + .put(Entity.json(readModeJson)); + + String content = assertResponseStatus(200, readModeResponse); + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertEquals("OLTP_ONLY", result.get("graph_read_mode")); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/read_mode_test", params); + } + } + + @Test + public void testGetGraphReadMode() { + try { + Response r = createGraphInRocksDB(TEMP_SPACE, "get_read_mode_test"); + assertResponseStatus(201, r); + + Response readModeResponse = client().get(PATH + "/get_read_mode_test/graph_read_mode"); + String content = assertResponseStatus(200, readModeResponse); + + Map result = JsonUtil.fromJson(content, Map.class); + Assert.assertTrue(result.containsKey("graph_read_mode")); + } finally { + // Clean up + Map params = ImmutableMap.of( + "confirm_message", "I'm sure to drop the graph"); + client().delete(PATH + "/get_read_mode_test", params); + } + } + + @Test + public void testReloadGraphsWithInvalidAction() { + String actionJson = "{\n" + + " \"action\": \"invalid_action\"\n" + + "}"; + + Response r = client().target(baseUrl()) + .path(PATH + "/manage") + .request() + .put(Entity.json(actionJson)); + + Assert.assertTrue(r.getStatus() >= 400); + } + + @Test + public void testGraphNotExist() { + Response r = client().get(PATH + "/non_existent_graph"); + Assert.assertTrue(r.getStatus() >= 400); } } diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/LoginApiTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/LoginApiTest.java index 3721d37cdd..0b6df93438 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/LoginApiTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/LoginApiTest.java @@ -35,8 +35,8 @@ public class LoginApiTest extends BaseApiTest { - private static final String PATH = "graphspaces/DEFAULT/graphs/hugegraph/auth"; - private static final String USER_PATH = "graphspaces/DEFAULT/graphs/hugegraph/auth/users"; + private static final String PATH = "/auth"; + private static final String USER_PATH = "graphspaces/DEFAULT/auth/users"; private String userId4Test; @Before diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ManagerApiStandaloneTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ManagerApiStandaloneTest.java new file mode 100644 index 0000000000..4c0e17815b --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ManagerApiStandaloneTest.java @@ -0,0 +1,128 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.api; + +import java.util.Map; + +import org.apache.hugegraph.auth.HugePermission; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import jakarta.ws.rs.core.Response; + +/** + * Tests that ManagerAPI returns a friendly HTTP 400 error in standalone mode + * (i.e. when the server is started without PD / hstore backend). + *

      + * This class intentionally does NOT have a class-level Assume guard so that + * the tests are actually executed in non-hstore CI runs. + */ +public class ManagerApiStandaloneTest extends BaseApiTest { + + private static String managerPath(String graphSpace) { + return String.format("graphspaces/%s/auth/managers", graphSpace); + } + + @Before + public void skipForPdMode() { + assumeStandaloneMode(); + } + + @Test + public void testCreateManagerReturnsFriendlyError() { + String body = "{\"user\":\"admin\",\"type\":\"ADMIN\"}"; + Response r = this.client().post(managerPath("DEFAULT"), body); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testDeleteManagerReturnsFriendlyError() { + Response r = this.client().delete(managerPath("DEFAULT"), + Map.of("user", "admin", + "type", HugePermission.ADMIN)); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testListManagerReturnsFriendlyError() { + Response r = this.client().get(managerPath("DEFAULT"), + Map.of("type", (Object)HugePermission.ADMIN)); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testCheckRoleReturnsFriendlyError() { + Response r = this.client().get(managerPath("DEFAULT") + "/check", + Map.of("type", (Object)HugePermission.ADMIN)); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testGetRolesInGsReturnsFriendlyError() { + Response r = this.client().get(managerPath("DEFAULT") + "/role", + Map.of("user", (Object)"admin")); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testCreateSpaceManagerReturnsFriendlyError() { + String body = "{\"user\":\"admin\",\"type\":\"SPACE\"}"; + Response r = this.client().post(managerPath("nonexistent"), body); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testDeleteSpaceManagerReturnsFriendlyError() { + Response r = this.client().delete(managerPath("nonexistent"), + Map.of("user", "admin", + "type", HugePermission.SPACE)); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testListSpaceManagerReturnsFriendlyError() { + Response r = this.client().get(managerPath("nonexistent"), + Map.of("type", (Object) HugePermission.SPACE)); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testCheckRoleSpaceReturnsFriendlyError() { + Response r = this.client().get(managerPath("nonexistent") + "/check", + Map.of("type", (Object) HugePermission.SPACE)); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } + + @Test + public void testGetRolesInGsNonExistentReturnsFriendlyError() { + Response r = this.client().get(managerPath("nonexistent") + "/role", + Map.of("user", (Object) "admin")); + String content = assertResponseStatus(400, r); + Assert.assertTrue(content.contains(STANDALONE_ERROR)); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ManagerApiTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ManagerApiTest.java index 9c4d6eda87..095361f43e 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ManagerApiTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ManagerApiTest.java @@ -38,7 +38,7 @@ public class ManagerApiTest extends BaseApiTest { - private static final String USER_PATH = "graphspaces/DEFAULT/graphs/hugegraph/auth/users"; + private static final String USER_PATH = "graphspaces/DEFAULT/auth/users"; private static final int NO_LIMIT = -1; // Helper method to build manager path with graphspace @@ -68,13 +68,13 @@ private void deleteSpaceMembers() { Response r1 = this.client().get("/graphspaces"); String result = r1.readEntity(String.class); Map resultMap = JsonUtil.fromJson(result, Map.class); - List spaces = (List) resultMap.get("graphSpaces"); + List spaces = (List)resultMap.get("graphSpaces"); for (String space : spaces) { Response r = this.client().get(managerPath(space), ImmutableMap.of("type", HugePermission.SPACE_MEMBER)); result = r.readEntity(String.class); resultMap = JsonUtil.fromJson(result, Map.class); - List spaceAdmins = (List) resultMap.get("admins"); + List spaceAdmins = (List)resultMap.get("admins"); for (String user : spaceAdmins) { this.client().delete(managerPath(space), ImmutableMap.of("user", user, @@ -89,7 +89,7 @@ public void deleteAdmins() { ImmutableMap.of("type", HugePermission.ADMIN)); String result = r.readEntity(String.class); Map resultMap = JsonUtil.fromJson(result, Map.class); - List admins = (List) resultMap.get("admins"); + List admins = (List)resultMap.get("admins"); for (String user : admins) { if ("admin".equals(user)) { continue; @@ -103,13 +103,13 @@ public void deleteSpaceAdmins() { Response r1 = this.client().get("/graphspaces"); String result = r1.readEntity(String.class); Map resultMap = JsonUtil.fromJson(result, Map.class); - List spaces = (List) resultMap.get("graphSpaces"); + List spaces = (List)resultMap.get("graphSpaces"); for (String space : spaces) { Response r = this.client().get(managerPath(space), ImmutableMap.of("type", HugePermission.SPACE)); result = r.readEntity(String.class); resultMap = JsonUtil.fromJson(result, Map.class); - List spaceAdmins = (List) resultMap.get("admins"); + List spaceAdmins = (List)resultMap.get("admins"); for (String user : spaceAdmins) { this.client().delete(managerPath(space), ImmutableMap.of("user", user, @@ -124,7 +124,7 @@ public void deleteUsers() { if (user.get("user_name").equals("admin")) { continue; } - this.client().delete(USER_PATH, (String) user.get("id")); + this.client().delete(USER_PATH, (String)user.get("id")); } } @@ -153,10 +153,8 @@ public void testSpaceMemberCRUD() { client().get(managerPath("testspace") + "/check", ImmutableMap.of("type", HugePermission.SPACE_MEMBER)); - RestClient member1Client = - new RestClient(baseUrl(), "test_member1", "password1"); - RestClient member2Client = - new RestClient(baseUrl(), "test_member2", "password1"); + RestClient member1Client = new RestClient(baseUrl(), "test_member1", "password1"); + RestClient member2Client = new RestClient(baseUrl(), "test_member2", "password1"); String res1 = member1Client.get(managerPath("testspace") + "/check", ImmutableMap.of("type", @@ -214,10 +212,8 @@ public void testPermission() { r = client().post(managerPath("testspace"), spaceManager); assertResponseStatus(201, r); - RestClient spaceMemberClient = - new RestClient(baseUrl(), "perm_member", "password1"); - RestClient spaceManagerClient = - new RestClient(baseUrl(), "perm_manager", "password1"); + RestClient spaceMemberClient = new RestClient(baseUrl(), "perm_member", "password1"); + RestClient spaceManagerClient = new RestClient(baseUrl(), "perm_manager", "password1"); String userPath = "graphspaces/testspace/graphs/testgraph/auth/users"; String user = "{\"user_name\":\"" + "test_perm_user" + @@ -326,15 +322,17 @@ protected List> listUsers(String graphSpace, String graph) { Response r = this.client().get(userPath, ImmutableMap.of("limit", NO_LIMIT)); String result = assertResponseStatus(200, r); - Map>> resultMap = - JsonUtil.fromJson(result, new TypeReference>>>() { - }); + TypeReference>>> typeRef = + new TypeReference>>>() { + }; + Map>> resultMap = JsonUtil.fromJson(result, + typeRef); return resultMap.get("users"); } /** - * Test space manager boundary: SpaceA's manager cannot operate SpaceB's resources + * Test space manager boundary: SpaceA's manager cannot operate SpaceB's + * resources */ @Test public void testSpaceManagerBoundary() { @@ -491,9 +489,11 @@ public void testSpaceManagerCannotPromoteUsersInOtherSpaces() { response.contains("no permission")); // Verify: manageralpha CAN promote usertest to be spacealpha's member - // But this will fail because manageralpha doesn't have permission to read user from + // But this will fail because manageralpha doesn't have permission to read user + // from // DEFAULT space - // This is expected behavior - space managers should only manage users already in their + // This is expected behavior - space managers should only manage users already + // in their // space // or admin should assign users to spaces first @@ -640,7 +640,8 @@ public void testSpaceManagerAndMemberResourcePermissions() { String vertexJson = "{\"label\":\"person\",\"properties\":{\"age\":30}}"; r = managerClient.post(vertexPath, vertexJson); String response2 = r.readEntity(String.class); - // Note: Vertex write might require specific permissions depending on configuration + // Note: Vertex write might require specific permissions depending on + // configuration // We check if it's either allowed (201) or forbidden (403) int status = r.getStatus(); Assert.assertTrue("Status should be 201 or 403, but was: " + status, @@ -659,7 +660,8 @@ public void testSpaceManagerAndMemberResourcePermissions() { r = outsiderClient.post(vertexPath, vertexJson3); Assert.assertEquals(403, r.getStatus()); - // Test 7: Space manager can manage space members (already tested in other tests) + // Test 7: Space manager can manage space members (already tested in other + // tests) // Test 8: Space member cannot manage space members this.createUser("newuser"); String addMemberJson = "{\"user\":\"newuser\",\"type\":\"SPACE_MEMBER\"}"; diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ProjectApiTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ProjectApiTest.java index 6f7ffe821f..90e6fc5a11 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ProjectApiTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/ProjectApiTest.java @@ -37,7 +37,7 @@ public class ProjectApiTest extends BaseApiTest { - private static final String PATH = "graphspaces/DEFAULT/graphs/hugegraph/auth/projects"; + private static final String PATH = "graphspaces/DEFAULT/auth/projects"; @BeforeClass public static void setUpClass() { diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/UserApiTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/UserApiTest.java index dd4534b065..9200026d4e 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/UserApiTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/UserApiTest.java @@ -32,7 +32,7 @@ public class UserApiTest extends BaseApiTest { - private static final String PATH = "graphspaces/DEFAULT/graphs/hugegraph/auth/users"; + private static final String PATH = "graphspaces/DEFAULT/auth/users"; private static final int NO_LIMIT = -1; @Override diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CoreTestSuite.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CoreTestSuite.java index 2ff62b06ef..6c02324dc8 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CoreTestSuite.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CoreTestSuite.java @@ -26,7 +26,6 @@ import org.apache.hugegraph.testutil.Utils; import org.apache.hugegraph.util.Log; import org.junit.AfterClass; -import org.junit.Assert; import org.junit.BeforeClass; import org.junit.runner.RunWith; import org.junit.runners.Suite; @@ -40,6 +39,7 @@ IndexLabelCoreTest.class, VertexCoreTest.class, EdgeCoreTest.class, + CountStrategyCoreTest.class, ParentAndSubEdgeCoreTest.class, PropertyCoreTest.VertexPropertyCoreTest.class, PropertyCoreTest.EdgePropertyCoreTest.class, @@ -47,16 +47,35 @@ TaskCoreTest.class, AuthTest.class, MultiGraphsTest.class, - RamTableTest.class + RamTableTest.class, + VectorIndexEndToEndIntegrationTest.class }) public class CoreTestSuite { private static boolean registered = false; - private static HugeGraph graph = null; + private static volatile HugeGraph graph = null; public static HugeGraph graph() { - Assert.assertNotNull(graph); - //Assert.assertFalse(graph.closed()); + if (graph == null) { + synchronized (CoreTestSuite.class) { + if (graph == null) { + try { + initEnv(); + init(); + } catch (Throwable e) { + LOG.error("Failed to initialize HugeGraph instance", e); + graph = null; + throw new RuntimeException("Failed to initialize HugeGraph instance", e); + } + if (graph == null) { + String msg = "HugeGraph instance is null after initialization. " + + "Please check Utils.open() configuration."; + LOG.error(msg); + throw new IllegalStateException(msg); + } + } + } + } return graph; } diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CountStrategyCoreTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CountStrategyCoreTest.java new file mode 100644 index 0000000000..58a0d992f0 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CountStrategyCoreTest.java @@ -0,0 +1,513 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.core; + +import org.apache.hugegraph.schema.SchemaManager; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.traversal.optimize.HugeGraphStep; +import org.apache.tinkerpop.gremlin.process.traversal.P; +import org.apache.tinkerpop.gremlin.process.traversal.Step; +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal; +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__; +import org.apache.tinkerpop.gremlin.process.traversal.step.HasContainerHolder; +import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.T; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.junit.Test; + +public class CountStrategyCoreTest extends BaseCoreTest { + + private void initSchema() { + SchemaManager schema = graph().schema(); + schema.propertyKey("name").asText().create(); + schema.vertexLabel("person").properties("name") + .nullableKeys("name").create(); + schema.vertexLabel("software").properties("name") + .nullableKeys("name").create(); + schema.edgeLabel("knows").link("person", "person").create(); + schema.edgeLabel("created").link("person", "software").create(); + } + + private void initGraph() { + Vertex marko = graph().addVertex(T.label, "person", "name", "marko"); + Vertex josh = graph().addVertex(T.label, "person", "name", "josh"); + Vertex lop = graph().addVertex(T.label, "software", "name", "lop"); + + marko.addEdge("knows", josh); + marko.addEdge("created", lop); + commitTx(); + } + + private void initMatchNoIndexSchema() { + SchemaManager schema = graph().schema(); + schema.propertyKey("vp2").asBoolean().create(); + schema.propertyKey("vp3").asLong().create(); + schema.propertyKey("vp4").asText().create(); + schema.propertyKey("ep2").asBoolean().create(); + schema.vertexLabel("vl1").properties("vp2", "vp4") + .nullableKeys("vp2", "vp4").create(); + schema.vertexLabel("vl0").properties("vp3") + .nullableKeys("vp3").create(); + schema.edgeLabel("el1").link("vl1", "vl0") + .properties("ep2").nullableKeys("ep2").create(); + } + + private void initMatchNoIndexGraph() { + Vertex v1 = graph().addVertex(T.label, "vl1", "vp2", true, + "vp4", "foo"); + Vertex v2 = graph().addVertex(T.label, "vl1", "vp2", false, + "vp4", "J2O"); + Vertex v3 = graph().addVertex(T.label, "vl0", + "vp3", 4592737712018141719L); + Vertex v4 = graph().addVertex(T.label, "vl0", + "vp3", 4592737712018141717L); + + v1.addEdge("el1", v3, "ep2", true); + v2.addEdge("el1", v4, "ep2", false); + commitTx(); + } + + private static HugeGraphStep applyAndGetGraphStep( + GraphTraversal traversal) { + traversal.asAdmin().applyStrategies(); + return (HugeGraphStep) traversal.asAdmin().getStartStep(); + } + + private static boolean hasRemainingHasStep(GraphTraversal traversal, + String key) { + for (Step step : traversal.asAdmin().getSteps()) { + if (!(step instanceof HasStep)) { + continue; + } + HasContainerHolder holder = (HasContainerHolder) step; + for (HasContainer has : holder.getHasContainers()) { + if (key.equals(has.getKey())) { + return true; + } + } + } + return false; + } + + private void initTextRangeSchema(boolean withEdge) { + SchemaManager schema = graph().schema(); + schema.propertyKey("vp4").asText().create(); + schema.propertyKey("ep4").asText().create(); + schema.propertyKey("age").asInt().create(); + schema.vertexLabel("vl1").properties("vp4", "age") + .nullableKeys("vp4", "age").create(); + if (withEdge) { + schema.edgeLabel("el2").properties("ep4") + .nullableKeys("ep4").link("vl1", "vl1").create(); + } + } + + @Test + public void testWhereCountLtNegativeIsAlwaysFalse() { + this.initSchema(); + this.initGraph(); + + long count = graph().traversal().E().outV() + .repeat(__.both()).times(1) + .where(__.outE().count().is(P.lt(-3))) + .count().next(); + + Assert.assertEquals(0L, count); + } + + @Test + public void testWhereCountOutsideNegativeKeepsOriginalSemantics() { + this.initSchema(); + this.initGraph(); + + long direct = graph().traversal().V() + .both("created") + .inE("created") + .where(__.bothV().count().is(P.outside(-3, -5))) + .count().next(); + long viaMatch = graph().traversal().V() + .repeat(__.both("created")).times(1) + .inE("created") + .match(__.as("start") + .where(__.bothV().count() + .is(P.outside(-3, -5))) + .as("end")) + .select("end") + .count().next(); + + Assert.assertEquals(1L, direct); + Assert.assertEquals(direct, viaMatch); + } + + @Test + public void testRepeatUntilCountLtNegativeIsAlwaysFalse() { + this.initSchema(); + this.initGraph(); + + long count = graph().traversal().E() + .hasLabel("knows") + .outV() + .repeat(__.out()) + .until(__.outE().count().is(P.lt(-1))) + .count().next(); + + Assert.assertEquals(0L, count); + } + + @Test + public void testWhereCountWithinNegativeCollectionIsAlwaysFalse() { + this.initSchema(); + this.initGraph(); + + long count = graph().traversal().V() + .where(__.outE().count().is(P.within(-3, -5))) + .count().next(); + + Assert.assertEquals(0L, count); + } + + @Test + public void testWhereCountGteNegativeDoesNotBuildInvalidRange() { + this.initSchema(); + this.initGraph(); + + long count = graph().traversal().E() + .bothV() + .where(__.out("knows", "created") + .count().is(P.gte(-3))) + .count().next(); + + Assert.assertEquals(4L, count); + } + + @Test + public void testRepeatAfterTextRangeFilterWithEmptyResult() { + this.initTextRangeSchema(true); + + Vertex v1 = graph().addVertex(T.label, "vl1", "vp4", "a", "age", 1); + Vertex v2 = graph().addVertex(T.label, "vl1", "vp4", "b", "age", 2); + v1.addEdge("el2", v2); + commitTx(); + + long direct = graph().traversal().V().has("vp4", P.lt("")) + .repeat(__.out("el2")).emit().times(1) + .count().next(); + long viaMatch = graph().traversal().V() + .match(__.as("start").has("vp4", P.lt("")) + .out("el2").as("m")) + .select("m").count().next(); + + Assert.assertEquals(0L, direct); + Assert.assertEquals(direct, viaMatch); + } + + @Test + public void testTextRangeFilterKeepsMixedGraphHasStep() { + this.initTextRangeSchema(false); + + graph().addVertex(T.label, "vl1", "vp4", "a", "age", 1); + graph().addVertex(T.label, "vl1", "vp4", "b", "age", 2); + commitTx(); + + long direct = graph().traversal().V() + .hasLabel("vl1") + .has("vp4", P.lt("")) + .has("age", 1) + .count().next(); + long viaMatch = graph().traversal().V() + .match(__.as("v").hasLabel("vl1") + .has("vp4", P.lt("")) + .has("age", 1)) + .select("v").count().next(); + + Assert.assertEquals(0L, direct); + Assert.assertEquals(direct, viaMatch); + } + + @Test + public void testTextRangeFilterKeepsMixedVertexHasStep() { + this.initTextRangeSchema(true); + + Vertex v1 = graph().addVertex(T.label, "vl1", "vp4", "a", "age", 1); + Vertex v2 = graph().addVertex(T.label, "vl1", "vp4", "b", "age", 2); + v1.addEdge("el2", v2); + commitTx(); + + long direct = graph().traversal().V(v1.id()).out("el2") + .hasLabel("vl1") + .has("vp4", P.lt("")) + .has("age", 2) + .count().next(); + long viaMatch = graph().traversal().V(v1.id()).out("el2") + .match(__.as("v").hasLabel("vl1") + .has("vp4", P.lt("")) + .has("age", 2)) + .select("v").count().next(); + + Assert.assertEquals(0L, direct); + Assert.assertEquals(direct, viaMatch); + } + + @Test + public void testTextRangeFilterKeepsEdgeGraphHasStep() { + this.initTextRangeSchema(true); + + Vertex v1 = graph().addVertex(T.label, "vl1", "vp4", "a", "age", 1); + Vertex v2 = graph().addVertex(T.label, "vl1", "vp4", "b", "age", 2); + v1.addEdge("el2", v2, "ep4", "a"); + commitTx(); + + long direct = graph().traversal().E() + .has("ep4", P.lt("")) + .count().next(); + long viaMatch = graph().traversal().E() + .match(__.as("e").has("ep4", P.lt(""))) + .select("e").count().next(); + + Assert.assertEquals(0L, direct); + Assert.assertEquals(direct, viaMatch); + } + + @Test + public void testMatchWithNoIndexConditionMatchesDirectTraversal() { + this.initMatchNoIndexSchema(); + this.initMatchNoIndexGraph(); + + long direct = graph().traversal().V() + .has("vp4", P.neq("J2O")) + .has("vl1", "vp2", P.gte(false)) + .has("vp2") + .has("vl0", "vp3", P.gt(4592737712018141718L)) + .out("el1") + .count().next(); + long viaMatch = graph().traversal().V() + .has("vp4", P.neq("J2O")) + .has("vl1", "vp2", P.gte(false)) + .match(__.as("start0") + .has("vp2") + .has("vl0", "vp3", + P.gt(4592737712018141718L)) + .repeat(__.out("el1")) + .times(1) + .as("m0")) + .select("m0").count().next(); + + Assert.assertEquals(0L, direct); + Assert.assertEquals(direct, viaMatch); + } + + @Test + public void testMatchWithIndexedRangeConditionStillExtractsHas() { + this.initMatchNoIndexSchema(); + graph().schema().indexLabel("vl1ByVp2").onV("vl1") + .by("vp2").secondary().create(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().V() + .has("vp2", P.lt(true)) + .match(__.as("s") + .has("vp2") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(1, graphStep.getHasContainers().size()); + Assert.assertEquals("vp2", graphStep.getHasContainers().get(0).getKey()); + Assert.assertEquals(1L, traversal.next()); + } + + @Test + public void testMatchWithNoIndexConditionKeepsExtractingNextHas() { + this.initMatchNoIndexSchema(); + graph().schema().indexLabel("vl1ByVp2").onV("vl1") + .by("vp2").secondary().create(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().V() + .has("vp4", P.neq("J2O")) + .has("vp2", true) + .match(__.as("s") + .has("vp2") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(1, graphStep.getHasContainers().size()); + Assert.assertEquals("vp2", graphStep.getHasContainers().get(0).getKey()); + Assert.assertTrue(hasRemainingHasStep(traversal, "vp4")); + Assert.assertFalse(hasRemainingHasStep(traversal, "vp2")); + Assert.assertEquals(1L, traversal.next()); + } + + @Test + public void testMatchWithBooleanExistsConditionKeepsHas() { + this.initMatchNoIndexSchema(); + graph().schema().indexLabel("vl1ByVp2").onV("vl1") + .by("vp2").secondary().create(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().V() + .has("vp2", P.neq(null)) + .match(__.as("s") + .has("vp2", true) + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(0, graphStep.getHasContainers().size()); + Assert.assertEquals(1L, traversal.next()); + } + + @Test + public void testMatchWithIdentityKeepsNoIndexConditionLocal() { + this.initMatchNoIndexSchema(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().V() + .has("vp4", P.neq("J2O")) + .identity() + .match(__.as("s") + .has("vp2") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(0, graphStep.getHasContainers().size()); + Assert.assertTrue(hasRemainingHasStep(traversal, "vp4")); + Assert.assertEquals(1L, traversal.next()); + } + + @Test + public void testMatchWithIndexedEdgeRangeConditionStillExtractsHas() { + this.initMatchNoIndexSchema(); + graph().schema().indexLabel("el1ByEp2").onE("el1") + .by("ep2").secondary().create(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().E() + .has("ep2", P.lt(true)) + .match(__.as("s") + .has("ep2") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(1, graphStep.getHasContainers().size()); + Assert.assertEquals("ep2", graphStep.getHasContainers().get(0).getKey()); + Assert.assertEquals(1L, traversal.next()); + } + + @Test + public void testMatchWithIndexedNumericRangeConditionStillExtractsHas() { + this.initMatchNoIndexSchema(); + graph().schema().indexLabel("vl0ByVp3").onV("vl0") + .by("vp3").range().create(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().V() + .has("vp3", + P.gt(4592737712018141718L)) + .match(__.as("s") + .has("vp3") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(1, graphStep.getHasContainers().size()); + Assert.assertEquals("vp3", graphStep.getHasContainers().get(0).getKey()); + Assert.assertFalse(hasRemainingHasStep(traversal, "vp3")); + Assert.assertEquals(1L, traversal.next()); + } + + @Test + public void testMatchWithIndexedNumericNeqConditionKeepsHas() { + this.initMatchNoIndexSchema(); + graph().schema().indexLabel("vl0ByVp3").onV("vl0") + .by("vp3").range().create(); + graph().schema().indexLabel("vl1ByVp2").onV("vl1") + .by("vp2").secondary().create(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().V() + .has("vp3", + P.neq(4592737712018141719L)) + .has("vp2", true) + .match(__.as("s") + .has("vp2") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(1, graphStep.getHasContainers().size()); + Assert.assertEquals("vp2", graphStep.getHasContainers().get(0).getKey()); + Assert.assertTrue(hasRemainingHasStep(traversal, "vp3")); + Assert.assertEquals(0L, traversal.next()); + } + + @Test + public void testMatchWithSystemRangeConditionMatchesDirectTraversal() { + this.initMatchNoIndexSchema(); + this.initMatchNoIndexGraph(); + + long direct = graph().traversal().V() + .hasLabel("vl1") + .has("vp2") + .count().next(); + GraphTraversal traversal = graph().traversal().V() + .hasLabel(P.neq("vl0")) + .match(__.as("s") + .has("vp2") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertTrue(hasRemainingHasStep(traversal, T.label.getAccessor())); + Assert.assertEquals(direct, traversal.next().longValue()); + } + + @Test + public void testMatchWithUniqueBooleanRangeConditionKeepsHas() { + this.initMatchNoIndexSchema(); + graph().schema().indexLabel("vl1ByUniqueVp2").onV("vl1") + .by("vp2").unique().create(); + this.initMatchNoIndexGraph(); + + GraphTraversal traversal = graph().traversal().V() + .has("vp2", P.lt(true)) + .match(__.as("s") + .has("vp2") + .as("m")) + .select("m") + .count(); + + HugeGraphStep graphStep = applyAndGetGraphStep(traversal); + Assert.assertEquals(0, graphStep.getHasContainers().size()); + Assert.assertTrue(hasRemainingHasStep(traversal, "vp2")); + Assert.assertEquals(1L, traversal.next()); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeCoreTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeCoreTest.java index 265d408742..bbf7db6562 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeCoreTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeCoreTest.java @@ -2683,6 +2683,25 @@ public void testQueryEdgesByIdWithGraphAPI() { Assert.assertEquals(2, edges.size()); } + @Test + public void testQueryEdgesByNonConsecutiveDuplicateIds() { + HugeGraph graph = graph(); + init18Edges(); + + List allEdges = graph.traversal().E().toList(); + Assert.assertTrue("need at least 2 edges", allEdges.size() >= 2); + + Object id1 = allEdges.get(0).id(); + Object id2 = allEdges.get(1).id(); + + // Graph API does not guarantee duplicate results for duplicate ids + List edges = ImmutableList.copyOf(graph.edges(id1, id2, id1)); + Assert.assertEquals(3, edges.size()); + Assert.assertEquals(id1, edges.get(0).id()); + Assert.assertEquals(id2, edges.get(1).id()); + Assert.assertEquals(id1, edges.get(2).id()); + } + @Test public void testQueryEdgesByIdWithGraphAPIAndNotCommittedUpdate() { HugeGraph graph = graph(); @@ -4646,6 +4665,29 @@ public void testQueryInEdgesOfVertexByLabels() { Assert.assertEquals(3L, size); } + @Test + public void testQueryInEdgesOfVertexByConflictingLabels() { + HugeGraph graph = graph(); + init18Edges(); + + long direct = graph.traversal().V().inE("created") + .hasLabel("created", "look") + .hasLabel("authored") + .count().next(); + Assert.assertEquals(0L, direct); + + long matched = graph.traversal().V() + .match(__.as("start1") + .inE("created") + .as("m1")) + .select("m1") + .hasLabel("created", "look") + .hasLabel("authored") + .count().next(); + Assert.assertEquals(0L, matched); + Assert.assertEquals(matched, direct); + } + @Test public void testQueryInEdgesOfVertexBySortkey() { HugeGraph graph = graph(); @@ -7117,6 +7159,165 @@ public void testQueryEdgeWithNullablePropertyInCompositeIndex() { Assert.assertEquals(1, (int) el.get(0).value("id")); } + @Test + public void testQueryEdgeByBooleanRangePredicate() { + HugeGraph graph = graph(); + initStrikeIndex(); + graph.schema().indexLabel("strikeByArrested").onE("strike").secondary() + .by("arrested").create(); + + Vertex louise = graph.addVertex(T.label, "person", "name", "Louise", + "city", "Beijing", "age", 21); + Vertex sean = graph.addVertex(T.label, "person", "name", "Sean", + "city", "Beijing", "age", 23); + long current = System.currentTimeMillis(); + louise.addEdge("strike", sean, "id", 1, + "timestamp", current, "place", "park", + "tool", "shovel", "reason", "jeer", + "arrested", false); + louise.addEdge("strike", sean, "id", 2, + "timestamp", current + 1, "place", "street", + "tool", "shovel", "reason", "jeer", + "arrested", true); + + List hasLtEdges = graph.traversal().E() + .has("arrested", P.lt(true)) + .toList(); + Assert.assertEquals(1, hasLtEdges.size()); + Assert.assertEquals(1, (int) hasLtEdges.get(0).value("id")); + + List whereEdges = graph.traversal().E() + .where(__.has("arrested", P.lt(true))) + .toList(); + Assert.assertEquals(1, whereEdges.size()); + Assert.assertEquals(1, (int) whereEdges.get(0).value("id")); + + List matchEdges = graph.traversal().E() + .match(__.as("start") + .where(__.has("arrested", + P.lt(true))) + .as("matched")) + .select("matched") + .toList(); + Assert.assertEquals(1, matchEdges.size()); + Assert.assertEquals(1, (int) matchEdges.get(0).value("id")); + + List hasNeqTrueEdges = graph.traversal().E() + .has("arrested", P.neq(true)) + .toList(); + Assert.assertEquals(1, hasNeqTrueEdges.size()); + Assert.assertEquals(1, (int) hasNeqTrueEdges.get(0).value("id")); + + List hasNeqFalseEdges = graph.traversal().E() + .has("arrested", P.neq(false)) + .toList(); + Assert.assertEquals(1, hasNeqFalseEdges.size()); + Assert.assertEquals(2, (int) hasNeqFalseEdges.get(0).value("id")); + + List hasLteFalseEdges = graph.traversal().E() + .has("arrested", P.lte(false)) + .toList(); + Assert.assertEquals(1, hasLteFalseEdges.size()); + Assert.assertEquals(1, (int) hasLteFalseEdges.get(0).value("id")); + + List hasGtFalseEdges = graph.traversal().E() + .has("arrested", P.gt(false)) + .toList(); + Assert.assertEquals(1, hasGtFalseEdges.size()); + Assert.assertEquals(2, (int) hasGtFalseEdges.get(0).value("id")); + + List hasGteTrueEdges = graph.traversal().E() + .has("arrested", P.gte(true)) + .toList(); + Assert.assertEquals(1, hasGteTrueEdges.size()); + Assert.assertEquals(2, (int) hasGteTrueEdges.get(0).value("id")); + + List hasGteFalseEdges = graph.traversal().E() + .has("arrested", P.gte(false)) + .toList(); + Assert.assertEquals(2, hasGteFalseEdges.size()); + Set gteFalseIds = new HashSet<>(); + for (Edge edge : hasGteFalseEdges) { + gteFalseIds.add(edge.value("id")); + } + Assert.assertEquals(ImmutableSet.of(1, 2), gteFalseIds); + + List hasLteTrueEdges = graph.traversal().E() + .has("arrested", P.lte(true)) + .toList(); + Assert.assertEquals(2, hasLteTrueEdges.size()); + Set lteTrueIds = new HashSet<>(); + for (Edge edge : hasLteTrueEdges) { + lteTrueIds.add(edge.value("id")); + } + Assert.assertEquals(ImmutableSet.of(1, 2), lteTrueIds); + + Assert.assertEquals(0, graph.traversal().E() + .has("arrested", P.lt(false)) + .toList().size()); + Assert.assertEquals(0, graph.traversal().E() + .has("arrested", P.gt(true)) + .toList().size()); + } + + @Test + public void testQueryEdgeByBooleanRangePredicateWithoutNullableProperty() { + HugeGraph graph = graph(); + initStrikeIndex(); + graph.schema().indexLabel("strikeByHurt").onE("strike").secondary() + .by("hurt").create(); + + Vertex louise = graph.addVertex(T.label, "person", "name", "Louise", + "city", "Beijing", "age", 21); + Vertex sean = graph.addVertex(T.label, "person", "name", "Sean", + "city", "Beijing", "age", 23); + long current = System.currentTimeMillis(); + louise.addEdge("strike", sean, "id", 1, + "timestamp", current, "place", "park", + "tool", "shovel", "reason", "jeer", + "hurt", false, "arrested", false); + louise.addEdge("strike", sean, "id", 2, + "timestamp", current + 1, "place", "street", + "tool", "shovel", "reason", "jeer", + "hurt", true, "arrested", true); + louise.addEdge("strike", sean, "id", 3, + "timestamp", current + 2, "place", "mall", + "tool", "shovel", "reason", "jeer", + "arrested", false); + + List gteFalseEdges = graph.traversal().E() + .has("hurt", P.gte(false)) + .toList(); + Assert.assertEquals(2, gteFalseEdges.size()); + Set gteFalseIds = new HashSet<>(); + for (Edge edge : gteFalseEdges) { + gteFalseIds.add(edge.value("id")); + } + Assert.assertEquals(ImmutableSet.of(1, 2), gteFalseIds); + + List lteTrueEdges = graph.traversal().E() + .has("hurt", P.lte(true)) + .toList(); + Assert.assertEquals(2, lteTrueEdges.size()); + Set lteTrueIds = new HashSet<>(); + for (Edge edge : lteTrueEdges) { + lteTrueIds.add(edge.value("id")); + } + Assert.assertEquals(ImmutableSet.of(1, 2), lteTrueIds); + + List lteFalseEdges = graph.traversal().E() + .has("hurt", P.lte(false)) + .toList(); + Assert.assertEquals(1, lteFalseEdges.size()); + Assert.assertEquals(1, (int) lteFalseEdges.get(0).value("id")); + + List neqTrueEdges = graph.traversal().E() + .has("hurt", P.neq(true)) + .toList(); + Assert.assertEquals(1, neqTrueEdges.size()); + Assert.assertEquals(1, (int) neqTrueEdges.get(0).value("id")); + } + @Test public void testQueryEdgeByPage() { Assume.assumeTrue("Not support paging", diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeLabelCoreTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeLabelCoreTest.java index 3b81c2f16e..8629f78b3e 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeLabelCoreTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/EdgeLabelCoreTest.java @@ -480,7 +480,7 @@ public void testAddEdgeLabelWithDisableLabelIndex() { } @Test - public void testAddEdgeLabelWithTtl() { + public void testAddEdgeLabelWithTTL() { super.initPropertyKeys(); SchemaManager schema = graph().schema(); @@ -561,6 +561,124 @@ public void testAddEdgeLabelWithTtl() { assertContainsPk(ImmutableSet.of(write.ttlStartTime()), "date"); } + @Test + public void testAppendEdgeLabelWithTTL() { + super.initPropertyKeys(); + + SchemaManager schema = graph().schema(); + + schema.propertyKey("date").asDate().ifNotExist().create(); + + schema.vertexLabel("person") + .properties("name", "age", "city") + .primaryKeys("name") + .nullableKeys("city") + .create(); + + schema.vertexLabel("book") + .properties("name") + .primaryKeys("name") + .create(); + + // Create an edge label without TTL + EdgeLabel read = schema.edgeLabel("read").link("person", "book") + .properties("date", "weight") + .create(); + + Assert.assertNotNull(read); + Assert.assertEquals("read", read.name()); + Assert.assertEquals(0L, read.ttl()); + + // Update the edge label with TTL via append + read = schema.edgeLabel("read") + .ttl(86400L) + .append(); + + Assert.assertNotNull(read); + Assert.assertEquals("read", read.name()); + Assert.assertEquals(86400L, read.ttl()); + } + + @Test + public void testAppendEdgeLabelResetTTL() { + super.initPropertyKeys(); + + SchemaManager schema = graph().schema(); + + schema.vertexLabel("person") + .properties("name", "age", "city") + .primaryKeys("name") + .nullableKeys("city") + .create(); + + schema.vertexLabel("book") + .properties("name") + .primaryKeys("name") + .create(); + + // Create an edge label with TTL + EdgeLabel read = schema.edgeLabel("read").link("person", "book") + .properties("time", "weight") + .ttl(86400L) + .create(); + + Assert.assertNotNull(read); + Assert.assertEquals("read", read.name()); + Assert.assertEquals(86400L, read.ttl()); + + // Reset TTL to 0 via append + read = schema.edgeLabel("read") + .ttl(0L) + .append(); + + Assert.assertNotNull(read); + Assert.assertEquals("read", read.name()); + Assert.assertEquals(0L, read.ttl()); + } + + @Test + public void testAppendEdgeLabelWithoutTTLShouldNotClearExistingTTL() { + super.initPropertyKeys(); + + SchemaManager schema = graph().schema(); + + schema.propertyKey("date").asDate().ifNotExist().create(); + + schema.vertexLabel("person") + .properties("name", "age", "city") + .primaryKeys("name") + .nullableKeys("city") + .create(); + + schema.vertexLabel("book") + .properties("name") + .primaryKeys("name") + .create(); + + // Create edge label with TTL and ttlStartTime + EdgeLabel read = schema.edgeLabel("read").link("person", "book") + .properties("date", "weight") + .ttl(86400L) + .ttlStartTime("date") + .create(); + + Assert.assertNotNull(read); + Assert.assertEquals(86400L, read.ttl()); + Assert.assertNotNull(read.ttlStartTime()); + assertContainsPk(ImmutableSet.of(read.ttlStartTime()), "date"); + + // Append property WITHOUT specifying ttl + read = schema.edgeLabel("read") + .nullableKeys("weight") + .append(); + + // Both TTL and ttlStartTime should remain unchanged + Assert.assertNotNull(read); + Assert.assertEquals(86400L, read.ttl()); + Assert.assertNotNull(read.ttlStartTime()); + assertContainsPk(ImmutableSet.of(read.ttlStartTime()), "date"); + } + @Test public void testAppendEdgeLabelWithUndefinedNullableKeys() { super.initPropertyKeys(); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/PropertyKeyCoreTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/PropertyKeyCoreTest.java index 5cd1193fc3..0609f607ba 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/PropertyKeyCoreTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/PropertyKeyCoreTest.java @@ -631,6 +631,26 @@ public void testEliminatePropertyKeyWithUserdata() { Assert.assertEquals(0, age.userdata().get("min")); } + @Test + public void testEliminatePropertyKeyCreateTimeUserdata() { + SchemaManager schema = graph().schema(); + + PropertyKey age = schema.propertyKey("age") + .userdata("min", 0) + .create(); + Assert.assertEquals(2, age.userdata().size()); + Assert.assertTrue(age.userdata().containsKey(Userdata.CREATE_TIME)); + + // "" is a key-only placeholder for eliminate; it must not be parsed + // as a date (regression: normalization on Userdata.put()). + age = schema.propertyKey("age") + .userdata(Userdata.CREATE_TIME, "") + .eliminate(); + Assert.assertEquals(1, age.userdata().size()); + Assert.assertFalse(age.userdata().containsKey(Userdata.CREATE_TIME)); + Assert.assertEquals(0, age.userdata().get("min")); + } + @Test public void testUpdatePropertyKeyWithoutUserdata() { SchemaManager schema = graph().schema(); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VectorIndexEndToEndIntegrationTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VectorIndexEndToEndIntegrationTest.java new file mode 100644 index 0000000000..3d8cf3722c --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VectorIndexEndToEndIntegrationTest.java @@ -0,0 +1,289 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.core; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.io.File; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Random; +import java.util.Set; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import org.apache.commons.configuration2.PropertiesConfiguration; +import org.apache.commons.configuration2.builder.fluent.Configurations; +import org.apache.hugegraph.HugeFactory; +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.BackendException; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.dist.RegisterUtil; +import org.apache.hugegraph.masterelection.GlobalMasterInfo; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.testutil.Whitebox; +import org.apache.hugegraph.type.define.Cardinality; +import org.apache.hugegraph.type.define.DataType; +import org.apache.hugegraph.type.define.IndexType; +import org.apache.hugegraph.vector.ServerVectorRuntime; +import org.apache.hugegraph.vector.ServerVectorScheduler; +import org.apache.hugegraph.vector.ServerVectorStateStore; +import org.apache.hugegraph.vector.VectorIndexManager; +import org.apache.hugegraph.vector.VectorIndexRuntime; +import org.apache.hugegraph.vector.VectorIndexStateStore; +import org.apache.hugegraph.vector.VectorTaskScheduler; +import org.apache.tinkerpop.gremlin.structure.T; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * End-to-end integration test for the vector index feature. + * + * This test creates its OWN HugeGraph instance with RocksDB backend + + * BinarySerializer at an ISOLATED temporary data directory. + * It does NOT conflict with CoreTestSuite's graph. + * + * Run from the PROJECT ROOT directory: + * mvn test -pl hugegraph-server/hugegraph-test -am -P rocksdb \ + * -Dtest=VectorIndexEndToEndIntegrationTest + * + * Test flow: + * 1. Register backends, create isolated temp RocksDB dir + * 2. Open HugeGraph (RocksDB+binary), clear+init + * 3. Start server as master (for schema ops) + * 4. Inject VectorIndexManager into StandardHugeGraph + * 5. Create schema: PropertyKey(FLOAT,LIST), VertexLabel, VECTOR IndexLabel + * 6. Add vertices → auto signal → processIndex → JVector HNSW build + * 7. Search nearest neighbors and verify + */ +public class VectorIndexEndToEndIntegrationTest { + + private static final int DIMENSION = 128; + private static final String INDEX_LABEL_NAME = "productByEmbedding"; + private static final String PROPERTY_KEY_NAME = "embedding"; + private static final String VERTEX_LABEL_NAME = "product"; + + private static HugeGraph graph; + private static HugeGraphParams params; + private static VectorIndexManager vectorIndexManager; + private static Path rocksdbDir; + private static Path jvectorDir; + private static ExecutorService schedulerExecutor; + + @BeforeClass + public static void setup() throws Exception { + // 1. Register backend providers (must happen before opening) + try { + RegisterUtil.registerBackends(); + } catch (BackendException e) { + if (!e.getMessage().contains("Exists BackendStoreProvider")) { + throw e; + } + // Already registered by suite, skip + } + + // 2. Create ISOLATED temp directories (unique absolute paths) + rocksdbDir = Files.createTempDirectory("vector_e2e_rocksdb_"); + jvectorDir = Files.createTempDirectory("vector_e2e_jvector_"); + + // 3. Load filtered hugegraph.properties and override paths + PropertiesConfiguration config = loadProperties(); + config.setProperty("store", "vector_integration_test"); + config.setProperty("rocksdb.data_path", rocksdbDir.toString()); + config.setProperty("rocksdb.wal_path", rocksdbDir.toString()); + + // 4. Open HugeGraph + graph = HugeFactory.open(config); + graph.clearBackend(); + graph.initBackend(); + graph.serverStarted(GlobalMasterInfo.master("server-test")); + + // 5. Get params and inject VectorIndexManager + params = Whitebox.getInternalState(graph, "params"); + initVectorIndexManager(); + + // 6. Create vector schema + createVectorSchema(); + } + + @AfterClass + public static void cleanup() throws Exception { + Exception ex = null; + if (vectorIndexManager != null) { + try { vectorIndexManager.stop(); } catch (Exception e) { ex = e; } + } + if (schedulerExecutor != null) schedulerExecutor.shutdownNow(); + if (graph != null) { + try { graph.clearBackend(); } catch (Exception ignored) { } + try { graph.close(); } catch (Exception ignored) { } + } + // Remove temp directories + for (Path dir : new Path[]{rocksdbDir, jvectorDir}) { + if (dir != null && Files.exists(dir)) { + try { Files.walk(dir).sorted(Comparator.reverseOrder()) + .forEach(p -> { try { Files.delete(p); } catch (Exception ignored) { } }); + } catch (Exception ignored) { } + } + } + if (ex != null) throw ex; + } + + private static PropertiesConfiguration loadProperties() throws Exception { + String confPath = System.getProperty("config_path", "hugegraph.properties"); + java.net.URL url = VectorIndexEndToEndIntegrationTest.class + .getClassLoader().getResource(confPath); + assertNotNull("Config not found: " + confPath, url); + return new Configurations().properties(new File(url.toURI())); + } + + private static void initVectorIndexManager() { + VectorIndexStateStore stateStore = new ServerVectorStateStore(params); + VectorIndexRuntime runtime = new ServerVectorRuntime( + jvectorDir.toString(), params); + schedulerExecutor = Executors.newSingleThreadExecutor(r -> { + Thread t = new Thread(r, "vector-scheduler"); + t.setDaemon(true); + return t; + }); + VectorTaskScheduler scheduler = new ServerVectorScheduler( + schedulerExecutor, params.graphEventHub()); + vectorIndexManager = new VectorIndexManager<>(stateStore, runtime, scheduler); + vectorIndexManager.init(); + Whitebox.setInternalState(graph, "vectorIndexManager", vectorIndexManager); + } + + private static void createVectorSchema() { + graph.schema().propertyKey(PROPERTY_KEY_NAME) + .dataType(DataType.FLOAT).cardinality(Cardinality.LIST).create(); + graph.schema().propertyKey("name") + .dataType(DataType.TEXT).cardinality(Cardinality.SINGLE).create(); + graph.schema().vertexLabel(VERTEX_LABEL_NAME) + .properties("name", PROPERTY_KEY_NAME) + .useCustomizeNumberId().enableLabelIndex(true).create(); + // VECTOR IndexLabel: must use rebuild(false) since VECTOR indexes + // cannot use the standard async rebuild task. + graph.schema().indexLabel(INDEX_LABEL_NAME) + .onV(VERTEX_LABEL_NAME).by(PROPERTY_KEY_NAME).vector() + .userdata("dimension", DIMENSION) + .userdata("similarityFunction", "COSINE") + .rebuild(false).create(); + } + + // ══════════════════════ Tests ══════════════════════ + + @Test + public void testCompleteWorkflow() throws Exception { + for (int i = 0; i < 10; i++) { + graph.addVertex(T.label, VERTEX_LABEL_NAME, T.id, 1000L + i, + "name", "p-" + i, PROPERTY_KEY_NAME, + toFloatList(generateRandomVector(DIMENSION, i))); + } + graph.tx().commit(); + Thread.sleep(1_000); // Wait for async EventHub signal processing + + Id ilId = graph.schema().getIndexLabel(INDEX_LABEL_NAME).id(); + Set results = vectorIndexManager.searchVector( + ilId, generateRandomVector(DIMENSION, 0), 5); + + assertNotNull(results); + assertTrue("≥1 result, got " + results.size(), results.size() > 0); + assertTrue("≤topK=5, got " + results.size(), results.size() <= 5); + } + + @Test + public void testSelfSearchReturnsSelf() throws Exception { + // Add 10 vectors, then search for a specific one + long targetVid = 2005L; + float[] targetVec = generateRandomVector(DIMENSION, 105); + + for (int i = 0; i < 10; i++) { + float[] vec = i == 5 ? targetVec : generateRandomVector(DIMENSION, 100 + i); + graph.addVertex(T.label, VERTEX_LABEL_NAME, T.id, 2000L + i, + "name", "bulk-" + i, PROPERTY_KEY_NAME, + toFloatList(vec)); + } + graph.tx().commit(); + Thread.sleep(1_000); + + Id ilId = graph.schema().getIndexLabel(INDEX_LABEL_NAME).id(); + Set results = vectorIndexManager.searchVector(ilId, targetVec, 5); + assertNotNull(results); + assertTrue("≥1 result, got " + results.size(), results.size() > 0); + assertTrue("Expected target vertex " + targetVid + " in results: " + results, + results.contains(IdGenerator.of(targetVid))); + } + + @Test + public void testIncrementalAddAndSearch() throws Exception { + long c = 8000L; + for (int i = 0; i < 5; i++) + graph.addVertex(T.label, VERTEX_LABEL_NAME, T.id, c++, + "name", "b1-" + i, PROPERTY_KEY_NAME, + toFloatList(generateRandomVector(DIMENSION, 100 + i))); + graph.tx().commit(); + Thread.sleep(500); + + for (int i = 0; i < 5; i++) + graph.addVertex(T.label, VERTEX_LABEL_NAME, T.id, c++, + "name", "b2-" + i, PROPERTY_KEY_NAME, + toFloatList(generateRandomVector(DIMENSION, 200 + i))); + graph.tx().commit(); + Thread.sleep(500); + + Id ilId = graph.schema().getIndexLabel(INDEX_LABEL_NAME).id(); + Set results = vectorIndexManager.searchVector( + ilId, generateRandomVector(DIMENSION, 100), 10); + assertNotNull(results); + assertTrue("≥1 result", results.size() >= 1); + } + + @Test + public void testVectorIndexLabelCreated() { + IndexLabel il = graph.schema().getIndexLabel(INDEX_LABEL_NAME); + assertNotNull(il); + assertEquals(IndexType.VECTOR, il.indexType()); + assertEquals(DIMENSION, il.userdata().get("dimension")); + assertEquals("COSINE", il.userdata().get("similarityFunction")); + } + + // ══════════════════════ Helpers ══════════════════════ + + private static float[] generateRandomVector(int dim, long seed) { + Random rng = new Random(seed); + float[] v = new float[dim]; + float sum = 0f; + for (int i = 0; i < dim; i++) { v[i] = rng.nextFloat(); sum += v[i] * v[i]; } + float norm = (float) Math.sqrt(sum); + for (int i = 0; i < dim; i++) v[i] /= norm; + return v; + } + + private static List toFloatList(float[] arr) { + List list = new ArrayList<>(arr.length); + for (float v : arr) list.add(v); + return list; + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexCoreTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexCoreTest.java index a329de3afb..d33f9bb07d 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexCoreTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexCoreTest.java @@ -19,6 +19,7 @@ import java.math.BigDecimal; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.Date; import java.util.HashSet; @@ -69,6 +70,7 @@ import org.apache.hugegraph.type.define.WriteType; import org.apache.hugegraph.util.Blob; import org.apache.hugegraph.util.CollectionUtil; +import org.apache.hugegraph.util.DateUtil; import org.apache.hugegraph.util.LongEncoding; import org.apache.tinkerpop.gremlin.process.traversal.P; import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal; @@ -826,6 +828,63 @@ public void testAddVertexWithDefaultPropertyValue() { Assert.assertFalse(vertex.values("age").hasNext()); } + @Test + public void testAddVertexWithDateDefaultValue() { + SchemaManager schema = graph().schema(); + + Date joined = DateUtil.parse("2026-05-14 10:11:12.345"); + schema.propertyKey("joinDate").asDate() + .userdata(Userdata.DEFAULT_VALUE, joined).create(); + schema.vertexLabel("person") + .properties("joinDate") + .nullableKeys("joinDate").append(); + + // No 'joinDate' supplied + Vertex vertex = graph().addVertex(T.label, "person", + "name", "Baby", "city", "Shanghai"); + + this.commitTx(); + + // Reload from backend then query: the typed default must survive the + // JSON serialize/reload round-trip as a Date, not a String (#3028). + vertex = graph().vertex(vertex.id()); + Object value = vertex.value("joinDate"); + Assert.assertTrue("default 'joinDate' should be a Date, was " + + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(joined, value); + } + + @Test + public void testAddVertexWithDateSetDefaultValue() { + SchemaManager schema = graph().schema(); + + String dateStr = "2026-05-14 10:11:12.345"; + Date expected = DateUtil.parse(dateStr); + + // Simulate JSON-deserialized default: ArrayList of Strings with duplicates + schema.propertyKey("joinDates").asDate().valueSet() + .userdata(Userdata.DEFAULT_VALUE, Arrays.asList(dateStr, dateStr)) + .create(); + schema.vertexLabel("person") + .properties("joinDates") + .nullableKeys("joinDates").append(); + + Vertex vertex = graph().addVertex(T.label, "person", + "name", "Baby", "city", "Shanghai"); + this.commitTx(); + + vertex = graph().vertex(vertex.id()); + Object raw = vertex.value("joinDates"); + + Assert.assertTrue("joinDates should be a Set, was " + + (raw == null ? "null" : raw.getClass()), + raw instanceof Set); + Set values = (Set) raw; + Assert.assertEquals("duplicates must be collapsed", 1, values.size()); + Assert.assertTrue(values.contains(expected)); + } + @Test public void testAddVertexWithNotExistsVertexPropKey() { HugeGraph graph = graph(); @@ -6470,6 +6529,87 @@ public void testQueryVertexByPropertyWithEmptyString() { Assert.assertEquals("", vertex.value("city")); } + @Test + public void testQueryVertexByBooleanPredicate() { + HugeGraph graph = graph(); + Assume.assumeFalse("skip this test for hstore", + Objects.equals("hstore", graph.backend())); + + graph.schema().indexLabel("languageByDynamic").onV("language") + .secondary().by("dynamic").create(); + + graph.addVertex(T.label, "language", "name", "java", + "dynamic", true); + graph.addVertex(T.label, "language", "name", "rust", + "dynamic", false); + graph.addVertex(T.label, "language", "name", "c"); + this.commitTx(); + + List neqTrueVertices = graph.traversal().V() + .hasLabel("language") + .has("dynamic", P.neq(true)) + .toList(); + Assert.assertEquals(1, neqTrueVertices.size()); + Assert.assertEquals("rust", neqTrueVertices.get(0).value("name")); + + List neqFalseVertices = graph.traversal().V() + .hasLabel("language") + .has("dynamic", P.neq(false)) + .toList(); + Assert.assertEquals(1, neqFalseVertices.size()); + Assert.assertEquals("java", neqFalseVertices.get(0).value("name")); + + List hasLtVertices = graph.traversal().V() + .hasLabel("language") + .has("dynamic", P.lt(true)) + .toList(); + Assert.assertEquals(1, hasLtVertices.size()); + Assert.assertEquals("rust", hasLtVertices.get(0).value("name")); + + List whereLtVertices = graph.traversal().V() + .hasLabel("language") + .where(__.has("dynamic", + P.lt(true))) + .toList(); + Assert.assertEquals(1, whereLtVertices.size()); + Assert.assertEquals("rust", whereLtVertices.get(0).value("name")); + + List matchLtVertices = graph.traversal().V() + .hasLabel("language") + .match(__.as("start") + .where(__.has("dynamic", + P.lt(true))) + .as("matched")) + .select("matched") + .toList(); + Assert.assertEquals(1, matchLtVertices.size()); + Assert.assertEquals("rust", matchLtVertices.get(0).value("name")); + + List compoundOrVertices = graph.traversal().V() + .hasLabel("language") + .has("dynamic", + P.gt(true).or(P.eq(true))) + .toList(); + Assert.assertEquals(1, compoundOrVertices.size()); + Assert.assertEquals("java", compoundOrVertices.get(0).value("name")); + + Assert.assertEquals(0, graph.traversal().V() + .hasLabel("language") + .has("dynamic", P.lt(false)) + .toList().size()); + + List gteFalseVertices = graph.traversal().V() + .hasLabel("language") + .has("dynamic", P.gte(false)) + .toList(); + Assert.assertEquals(2, gteFalseVertices.size()); + Set gteFalseNames = new HashSet<>(); + for (Vertex vertex : gteFalseVertices) { + gteFalseNames.add(vertex.value("name")); + } + Assert.assertEquals(ImmutableSet.of("java", "rust"), gteFalseNames); + } + @Test public void testQueryVertexBeforeAfterUpdateMultiPropertyWithIndex() { HugeGraph graph = graph(); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexLabelCoreTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexLabelCoreTest.java index 8dafcc5953..a43731f235 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexLabelCoreTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/VertexLabelCoreTest.java @@ -566,7 +566,7 @@ public void testAddVertexLabelWithDisableLabelIndex() { } @Test - public void testAddVertexLabelWithTtl() { + public void testAddVertexLabelWithTTL() { super.initPropertyKeys(); SchemaManager schema = graph().schema(); @@ -633,6 +633,91 @@ public void testAddVertexLabelWithTtl() { assertContainsPk(ImmutableSet.of(student.ttlStartTime()), "born"); } + @Test + public void testAppendVertexLabelWithTTL() { + super.initPropertyKeys(); + + SchemaManager schema = graph().schema(); + + schema.propertyKey("born").asDate().ifNotExist().create(); + + // Create a vertex label without TTL + VertexLabel person = schema.vertexLabel("person") + .properties("name", "age", "city", "born") + .create(); + + Assert.assertNotNull(person); + Assert.assertEquals("person", person.name()); + Assert.assertEquals(0L, person.ttl()); + + // Update the vertex label with TTL via append + person = schema.vertexLabel("person") + .ttl(86400L) + .append(); + + Assert.assertNotNull(person); + Assert.assertEquals("person", person.name()); + Assert.assertEquals(86400L, person.ttl()); + } + + @Test + public void testAppendVertexLabelResetTTL() { + super.initPropertyKeys(); + + SchemaManager schema = graph().schema(); + + // Create a vertex label with TTL + VertexLabel person = schema.vertexLabel("person") + .properties("name", "age", "city") + .ttl(86400L) + .create(); + + Assert.assertNotNull(person); + Assert.assertEquals("person", person.name()); + Assert.assertEquals(86400L, person.ttl()); + + // Reset TTL to 0 via append + person = schema.vertexLabel("person") + .ttl(0L) + .append(); + + Assert.assertNotNull(person); + Assert.assertEquals("person", person.name()); + Assert.assertEquals(0L, person.ttl()); + } + + @Test + public void testAppendVertexLabelWithoutTTLShouldNotClearExistingTTL() { + super.initPropertyKeys(); + + SchemaManager schema = graph().schema(); + + schema.propertyKey("born").asDate().ifNotExist().create(); + + // Create label with TTL and ttlStartTime + VertexLabel person = schema.vertexLabel("person") + .properties("name", "age", "city", "born") + .ttl(86400L) + .ttlStartTime("born") + .create(); + + Assert.assertNotNull(person); + Assert.assertEquals(86400L, person.ttl()); + Assert.assertNotNull(person.ttlStartTime()); + assertContainsPk(ImmutableSet.of(person.ttlStartTime()), "born"); + + // Append property WITHOUT specifying ttl + person = schema.vertexLabel("person") + .nullableKeys("city") + .append(); + + // Both TTL and ttlStartTime should remain unchanged + Assert.assertNotNull(person); + Assert.assertEquals(86400L, person.ttl()); + Assert.assertNotNull(person.ttlStartTime()); + assertContainsPk(ImmutableSet.of(person.ttlStartTime()), "born"); + } + @Test public void testAppendVertexLabelWithUndefinedNullableKeys() { super.initPropertyKeys(); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/meta/MetaManagerSchemaCacheClearEventTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/meta/MetaManagerSchemaCacheClearEventTest.java new file mode 100644 index 0000000000..852d4eae0d --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/meta/MetaManagerSchemaCacheClearEventTest.java @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with this + * work for additional information regarding copyright ownership. The ASF + * licenses this file to You under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hugegraph.meta; + +import org.apache.hugegraph.meta.MetaManager.SchemaCacheClearEvent; +import org.apache.hugegraph.testutil.Assert; +import org.junit.Test; + +public class MetaManagerSchemaCacheClearEventTest { + + @Test + public void testFromValueReturnsNullForEmptyPayload() { + Assert.assertNull(SchemaCacheClearEvent.fromValue(null)); + Assert.assertNull(SchemaCacheClearEvent.fromValue("")); + } + + @Test + public void testFromValueParsesLegacyPlainGraphName() { + SchemaCacheClearEvent event = + SchemaCacheClearEvent.fromValue("DEFAULT-graph1"); + + assertEvent(event, "DEFAULT-graph1", null); + } + + @Test + public void testFromValueIgnoresMalformedJson() { + Assert.assertNull(SchemaCacheClearEvent.fromValue("{not-json")); + } + + @Test + public void testFromValueParsesJsonWithSource() { + String value = MetaManager.schemaCacheClearEventValue("g", "u"); + SchemaCacheClearEvent event = SchemaCacheClearEvent.fromValue(value); + + assertEvent(event, "g", "u"); + } + + @Test + public void testFromValueParsesJsonWithoutSource() { + SchemaCacheClearEvent event = + SchemaCacheClearEvent.fromValue("{\"graph\":\"g\"}"); + + assertEvent(event, "g", null); + } + + @Test + public void testFromValueIgnoresJsonWithoutGraph() { + Assert.assertNull( + SchemaCacheClearEvent.fromValue("{\"source\":\"u\"}")); + } + + private static void assertEvent(SchemaCacheClearEvent event, + String graph, + String source) { + Assert.assertNotNull(event); + Assert.assertEquals(graph, event.graph()); + Assert.assertEquals(source, event.source()); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/tinkerpop/ProcessStandardTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/tinkerpop/ProcessStandardTest.java index 46fa348a58..d157d124c2 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/tinkerpop/ProcessStandardTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/tinkerpop/ProcessStandardTest.java @@ -23,5 +23,4 @@ @RunWith(ProcessBasicSuite.class) @GraphProviderClass(provider = ProcessTestGraphProvider.class, graph = TestGraph.class) public class ProcessStandardTest { - } diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtilOptimizeTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtilOptimizeTest.java new file mode 100644 index 0000000000..c3208a0b99 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/traversal/optimize/TraversalUtilOptimizeTest.java @@ -0,0 +1,261 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.traversal.optimize; + +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.exception.NotFoundException; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.type.define.DataType; +import org.apache.tinkerpop.gremlin.process.traversal.P; +import org.apache.tinkerpop.gremlin.process.traversal.Step; +import org.apache.tinkerpop.gremlin.process.traversal.Traversal; +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal; +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__; +import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStep; +import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer; +import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.junit.Test; +import org.mockito.Mockito; + +public class TraversalUtilOptimizeTest { + + @Test + public void testCanExtractHasContainerWithoutGraph() { + Assert.assertTrue(TraversalUtil.canExtractHasContainer( + null, new HasContainer("~label", P.eq("person")))); + Assert.assertTrue(TraversalUtil.canExtractHasContainer( + null, new HasContainer("~id", P.eq("1")))); + Assert.assertFalse(TraversalUtil.canExtractHasContainer( + null, new HasContainer("name", P.eq("marko")))); + } + + @Test + public void testCanExtractHasContainerWithMissingPropertyKey() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + Mockito.when(graph.propertyKey("missing")) + .thenThrow(new NotFoundException("missing")); + + Assert.assertFalse(TraversalUtil.canExtractHasContainer( + graph, new HasContainer("missing", P.eq("marko")))); + } + + @Test + public void testIndexLabelOrNullWithMissingIndexLabel() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + Id id = IdGenerator.of(1L); + Mockito.when(graph.indexLabel(id)) + .thenThrow(new IllegalArgumentException("missing")); + + Assert.assertNull(TraversalUtil.indexLabelOrNull(graph, id)); + } + + @Test + public void testCanExtractHasContainerWithNonTextProperty() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + PropertyKey age = propertyKey(1L, "age", DataType.INT); + Mockito.when(graph.propertyKey("age")).thenReturn(age); + + Assert.assertTrue(TraversalUtil.canExtractHasContainer( + graph, new HasContainer("age", P.eq(1)))); + } + + @Test + public void testCanExtractHasContainerWithTextRangePredicate() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + PropertyKey name = propertyKey(1L, "name", DataType.TEXT); + Mockito.when(graph.propertyKey("name")).thenReturn(name); + + Assert.assertFalse(TraversalUtil.canExtractHasContainer( + graph, new HasContainer("name", P.lt("")))); + Assert.assertFalse(TraversalUtil.canExtractHasContainer( + graph, new HasContainer("name", P.gte("marko")))); + Assert.assertFalse(TraversalUtil.canExtractHasContainer( + graph, new HasContainer("name", P.between("josh", "marko")))); + Assert.assertTrue(TraversalUtil.canExtractHasContainer( + graph, new HasContainer("name", P.eq("marko")))); + } + + @Test + public void testExtractHasContainerKeepsTextRangeGraphHasStep() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + PropertyKey name = propertyKey(1L, "name", DataType.TEXT); + Mockito.when(graph.propertyKey("name")).thenReturn(name); + + Traversal.Admin traversal = traversal(__.V() + .has("name", P.lt("marko")), + graph); + HugeGraphStep newStep = replaceGraphStep(traversal); + + TraversalUtil.extractHasContainer(newStep, traversal); + + Assert.assertTrue(newStep.getHasContainers().isEmpty()); + Assert.assertTrue(hasStepExists(traversal)); + } + + @Test + public void testExtractHasContainerKeepsTextRangeWithoutGraph() { + Traversal.Admin traversal = __.V() + .has("name", P.lt("marko")) + .asAdmin(); + HugeGraphStep newStep = replaceGraphStep(traversal); + + TraversalUtil.extractHasContainer(newStep, traversal); + + Assert.assertTrue(newStep.getHasContainers().isEmpty()); + Assert.assertTrue(hasStepExists(traversal)); + } + + @Test + public void testExtractHasContainerKeepsMatchRangeWithoutGraph() { + Traversal.Admin traversal = __.V() + .has("age", P.gt(18)) + .match(__.as("v").identity().as("m")) + .asAdmin(); + HugeGraphStep newStep = replaceGraphStep(traversal); + + TraversalUtil.extractHasContainer(newStep, traversal); + + Assert.assertTrue(newStep.getHasContainers().isEmpty()); + Assert.assertTrue(hasStepExists(traversal)); + } + + @Test + public void testExtractHasContainerKeepsTextBetweenGraphHasStep() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + PropertyKey name = propertyKey(1L, "name", DataType.TEXT); + Mockito.when(graph.propertyKey("name")).thenReturn(name); + + Traversal.Admin traversal = traversal(__.V() + .has("name", P.between( + "josh", "marko")), + graph); + HugeGraphStep newStep = replaceGraphStep(traversal); + + TraversalUtil.extractHasContainer(newStep, traversal); + + Assert.assertTrue(newStep.getHasContainers().isEmpty()); + Assert.assertTrue(hasStepExists(traversal)); + } + + @Test + public void testExtractHasContainerRemovesSafeGraphHasStep() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + PropertyKey age = propertyKey(1L, "age", DataType.INT); + Mockito.when(graph.propertyKey("age")).thenReturn(age); + + Traversal.Admin traversal = traversal(__.V().has("age", 18), + graph); + HugeGraphStep newStep = replaceGraphStep(traversal); + + TraversalUtil.extractHasContainer(newStep, traversal); + + Assert.assertEquals(1, newStep.getHasContainers().size()); + Assert.assertFalse(hasStepExists(traversal)); + } + + @Test + public void testExtractHasContainerKeepsTextRangeVertexHasStep() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + PropertyKey name = propertyKey(1L, "name", DataType.TEXT); + Mockito.when(graph.propertyKey("name")).thenReturn(name); + + Traversal.Admin traversal = traversal(__.V().out() + .has("name", P.lt("marko")), + graph); + HugeVertexStep newStep = replaceVertexStep(traversal); + + TraversalUtil.extractHasContainer(newStep, traversal); + + Assert.assertTrue(newStep.getHasContainers().isEmpty()); + Assert.assertTrue(hasStepExists(traversal)); + } + + @Test + public void testExtractHasContainerRemovesSafeVertexHasStep() { + HugeGraph graph = Mockito.mock(HugeGraph.class); + PropertyKey age = propertyKey(1L, "age", DataType.INT); + Mockito.when(graph.propertyKey("age")).thenReturn(age); + + Traversal.Admin traversal = traversal(__.V().out().has("age", 18), + graph); + HugeVertexStep newStep = replaceVertexStep(traversal); + + TraversalUtil.extractHasContainer(newStep, traversal); + + Assert.assertEquals(1, newStep.getHasContainers().size()); + Assert.assertFalse(hasStepExists(traversal)); + } + + private static PropertyKey propertyKey(long id, String name, + DataType dataType) { + Id keyId = IdGenerator.of(id); + PropertyKey key = new PropertyKey(null, keyId, name); + key.dataType(dataType); + return key; + } + + private static Traversal.Admin traversal(GraphTraversal traversal, + HugeGraph graph) { + Traversal.Admin admin = traversal.asAdmin(); + admin.setGraph(graph); + return admin; + } + + private static HugeGraphStep replaceGraphStep(Traversal.Admin traversal) { + GraphStep origin = (GraphStep) traversal.getStartStep(); + HugeGraphStep newStep = new HugeGraphStep<>(origin); + replaceStep(origin, newStep, traversal); + return newStep; + } + + @SuppressWarnings({"rawtypes", "unchecked"}) + private static HugeVertexStep replaceVertexStep(Traversal.Admin traversal) { + VertexStep origin = null; + for (Step step : traversal.getSteps()) { + if (step instanceof VertexStep) { + origin = (VertexStep) step; + break; + } + } + Assert.assertNotNull(origin); + HugeVertexStep newStep = new HugeVertexStep<>(origin); + replaceStep(origin, newStep, traversal); + return newStep; + } + + @SuppressWarnings({"rawtypes", "unchecked"}) + private static void replaceStep(Step origin, Step newStep, + Traversal.Admin traversal) { + TraversalHelper.replaceStep((Step) origin, (Step) newStep, traversal); + } + + private static boolean hasStepExists(Traversal.Admin traversal) { + for (Step step : traversal.getSteps()) { + if (step instanceof HasStep) { + return true; + } + } + return false; + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java index 03d3479494..021bdb684c 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java @@ -18,6 +18,12 @@ package org.apache.hugegraph.unit; import org.apache.hugegraph.core.RoleElectionStateMachineTest; +import org.apache.hugegraph.meta.MetaManagerSchemaCacheClearEventTest; +import org.apache.hugegraph.traversal.optimize.TraversalUtilOptimizeTest; +import org.apache.hugegraph.unit.api.filter.LoadDetectFilterTest; +import org.apache.hugegraph.unit.api.filter.PathFilterTest; +import org.apache.hugegraph.unit.api.gremlin.GremlinQueryAPITest; +import org.apache.hugegraph.unit.auth.HugeGraphAuthProxyTest; import org.apache.hugegraph.unit.cache.CacheManagerTest; import org.apache.hugegraph.unit.cache.CacheTest; import org.apache.hugegraph.unit.cache.CachedGraphTransactionTest; @@ -38,8 +44,10 @@ import org.apache.hugegraph.unit.core.RangeTest; import org.apache.hugegraph.unit.core.RolePermissionTest; import org.apache.hugegraph.unit.core.RowLockTest; +import org.apache.hugegraph.unit.core.SchemaElementTest; import org.apache.hugegraph.unit.core.SecurityManagerTest; import org.apache.hugegraph.unit.core.SerialEnumTest; +import org.apache.hugegraph.unit.core.ServerInfoManagerTest; import org.apache.hugegraph.unit.core.SystemSchemaStoreTest; import org.apache.hugegraph.unit.core.TraversalUtilTest; import org.apache.hugegraph.unit.id.EdgeIdTest; @@ -51,6 +59,7 @@ import org.apache.hugegraph.unit.rocksdb.RocksDBCountersTest; import org.apache.hugegraph.unit.rocksdb.RocksDBSessionTest; import org.apache.hugegraph.unit.rocksdb.RocksDBSessionsTest; +import org.apache.hugegraph.unit.rocksdb.RocksDBTableQueryByIdsTest; import org.apache.hugegraph.unit.serializer.BinaryBackendEntryTest; import org.apache.hugegraph.unit.serializer.BinaryScatterSerializerTest; import org.apache.hugegraph.unit.serializer.BinarySerializerTest; @@ -59,6 +68,7 @@ import org.apache.hugegraph.unit.serializer.StoreSerializerTest; import org.apache.hugegraph.unit.serializer.TableBackendEntryTest; import org.apache.hugegraph.unit.serializer.TextBackendEntryTest; +import org.apache.hugegraph.unit.serializer.TextSerializerTest; import org.apache.hugegraph.unit.store.RamIntObjectMapTest; import org.apache.hugegraph.unit.util.CompressUtilTest; import org.apache.hugegraph.unit.util.JsonUtilTest; @@ -71,16 +81,27 @@ import org.apache.hugegraph.unit.util.collection.IntMapTest; import org.apache.hugegraph.unit.util.collection.IntSetTest; import org.apache.hugegraph.unit.util.collection.ObjectIntMappingTest; +import org.apache.hugegraph.unit.vectorIndex.AbstractVectorRuntimeTest; +import org.apache.hugegraph.unit.vectorIndex.VectorIndexManagerTest; +import org.apache.hugegraph.unit.vectorIndex.VectorRecordTest; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Suite.class) @Suite.SuiteClasses({ + /* api filter */ + LoadDetectFilterTest.class, + PathFilterTest.class, + + /* api gremlin */ + GremlinQueryAPITest.class, + /* cache */ CacheTest.RamCacheTest.class, CacheTest.OffheapCacheTest.class, CacheTest.LevelCacheTest.class, CachedSchemaTransactionTest.class, + MetaManagerSchemaCacheClearEventTest.class, CachedGraphTransactionTest.class, CacheManagerTest.class, RamTableTest.class, @@ -110,9 +131,13 @@ ExceptionTest.class, BackendStoreInfoTest.class, TraversalUtilTest.class, + TraversalUtilOptimizeTest.class, PageStateTest.class, SystemSchemaStoreTest.class, + ServerInfoManagerTest.class, RoleElectionStateMachineTest.class, + HugeGraphAuthProxyTest.class, + SchemaElementTest.class, /* serializer */ BytesBufferTest.class, @@ -123,6 +148,7 @@ BinarySerializerTest.class, BinaryScatterSerializerTest.class, StoreSerializerTest.class, + TextSerializerTest.class, /* cassandra */ CassandraTest.class, @@ -135,6 +161,7 @@ RocksDBSessionsTest.class, RocksDBSessionTest.class, RocksDBCountersTest.class, + RocksDBTableQueryByIdsTest.class, /* utils */ VersionTest.class, @@ -153,7 +180,11 @@ IntSetTest.class, /* store */ - RamIntObjectMapTest.class + RamIntObjectMapTest.class, + /* vectorindex */ + VectorRecordTest.class, + VectorIndexManagerTest.class, + AbstractVectorRuntimeTest.class, }) public class UnitTestSuite { diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/filter/LoadDetectFilterTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/filter/LoadDetectFilterTest.java new file mode 100644 index 0000000000..5be5b64a92 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/filter/LoadDetectFilterTest.java @@ -0,0 +1,399 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.api.filter; + +import java.io.Serializable; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; +import java.util.function.BooleanSupplier; +import java.util.function.LongSupplier; +import java.util.stream.Collectors; + +import org.apache.commons.configuration2.Configuration; +import org.apache.commons.configuration2.PropertiesConfiguration; +import org.apache.hugegraph.api.filter.LoadDetectFilter; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.config.ServerOptions; +import org.apache.hugegraph.define.WorkLoad; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.testutil.Whitebox; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.core.Filter; +import org.apache.logging.log4j.core.Layout; +import org.apache.logging.log4j.core.LogEvent; +import org.apache.logging.log4j.core.LoggerContext; +import org.apache.logging.log4j.core.appender.AbstractAppender; +import org.apache.logging.log4j.core.config.LoggerConfig; +import org.apache.logging.log4j.core.config.Property; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; + +import jakarta.inject.Provider; +import jakarta.ws.rs.ServiceUnavailableException; +import jakarta.ws.rs.container.ContainerRequestContext; +import jakarta.ws.rs.core.PathSegment; +import jakarta.ws.rs.core.UriInfo; + +public class LoadDetectFilterTest extends BaseUnitTest { + + private static final String TEST_LOGGER_NAME = LoadDetectFilter.class.getName(); + + private LoadDetectFilter loadDetectFilter; + private ContainerRequestContext requestContext; + private UriInfo uriInfo; + private WorkLoad workLoad; + private TestAppender testAppender; + private LoggerContext loggerContext; + private org.apache.logging.log4j.core.config.Configuration loggerConfiguration; + private LoggerConfig loggerConfig; + + @Before + public void setup() { + this.requestContext = Mockito.mock(ContainerRequestContext.class); + this.uriInfo = Mockito.mock(UriInfo.class); + this.workLoad = new WorkLoad(); + this.testAppender = new TestAppender(); + this.testAppender.start(); + this.loggerContext = (LoggerContext) LogManager.getContext(false); + this.loggerConfiguration = this.loggerContext.getConfiguration(); + this.loggerConfig = new LoggerConfig(TEST_LOGGER_NAME, Level.WARN, false); + this.loggerConfig.addAppender(this.testAppender, Level.WARN, null); + this.loggerConfiguration.addLogger(TEST_LOGGER_NAME, this.loggerConfig); + this.loggerContext.updateLoggers(); + + Mockito.when(this.requestContext.getUriInfo()).thenReturn(this.uriInfo); + Mockito.when(this.requestContext.getMethod()).thenReturn("GET"); + + this.loadDetectFilter = new LoadDetectFilter(); + this.setLoadProvider(this.workLoad); + this.setConfigProvider(createConfig(8, 0)); + this.setGcResults(false); + this.setBusyLogPermits(true); + this.setMemoryLogPermits(true); + this.setFreeMemorySamples(1024L, 1024L); + } + + @After + public void teardown() { + this.loggerConfiguration.removeLogger(TEST_LOGGER_NAME); + this.loggerContext.updateLoggers(); + this.testAppender.stop(); + } + + @Test + public void testFilter_WhiteListPathIgnored() { + setupPath("", List.of("")); + this.workLoad.incrementAndGet(); + + this.loadDetectFilter.filter(this.requestContext); + + Assert.assertEquals(1, this.workLoad.get().get()); + Assert.assertTrue(this.testAppender.events().isEmpty()); + } + + @Test + public void testFilter_RejectsWhenWorkerLoadIsTooHigh() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(2, 0)); + this.workLoad.incrementAndGet(); + + ServiceUnavailableException exception = (ServiceUnavailableException) Assert.assertThrows( + ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + Assert.assertContains("The server is too busy to process the request", + exception.getMessage()); + Assert.assertContains(ServerOptions.MAX_WORKER_THREADS.name(), + exception.getMessage()); + Assert.assertEquals(1, this.testAppender.events().size()); + this.assertWarnLogContains("Rejected request due to high worker load"); + this.assertWarnLogContains("method=GET"); + this.assertWarnLogContains("path=graphs/hugegraph/vertices"); + this.assertWarnLogContains("currentLoad=2"); + } + + @Test + public void testFilter_RejectsWhenFreeMemoryIsTooLow() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(8, 512)); + this.setFreeMemorySamples(256L); + this.setGcResults(false); + + ServiceUnavailableException exception = (ServiceUnavailableException) Assert.assertThrows( + ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + Assert.assertContains("The server available memory 256(MB) is below than threshold 512(MB)", + exception.getMessage()); + Assert.assertEquals(1, this.testAppender.events().size()); + this.assertWarnLogContains("Rejected request due to low free memory"); + this.assertWarnLogContains("method=GET"); + this.assertWarnLogContains("path=graphs/hugegraph/vertices"); + this.assertWarnLogContains("presumableFreeMemMB=256"); + this.assertWarnLogContains("minFreeMemoryMB=512"); + this.assertWarnLogNotContains("recheckedFreeMemMB"); + } + + @Test + public void testFilter_RejectsWhenFreeMemoryIsStillLowAfterGc() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(8, 512)); + this.setFreeMemorySamples(256L, 128L); + this.setGcResults(true); + + ServiceUnavailableException exception = (ServiceUnavailableException) Assert.assertThrows( + ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + Assert.assertContains("The server available memory 128(MB) is below than threshold 512(MB)", + exception.getMessage()); + Assert.assertEquals(1, this.testAppender.events().size()); + this.assertWarnLogContains("Rejected request due to low free memory after GC"); + this.assertWarnLogContains("presumableFreeMemMB=256"); + this.assertWarnLogContains("recheckedFreeMemMB=128"); + this.assertWarnLogContains("minFreeMemoryMB=512"); + } + + @Test + public void testFilter_AllowsRequestWhenFreeMemoryRecoversAfterGc() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(8, 512)); + this.setFreeMemorySamples(256L, 1024L); + this.setGcResults(true); + + this.loadDetectFilter.filter(this.requestContext); + + Assert.assertEquals(1, this.workLoad.get().get()); + Assert.assertEquals(1, this.testAppender.events().size()); + this.assertWarnLogContains("Low free memory recovered after GC"); + this.assertWarnLogContains("presumableFreeMemMB=256"); + this.assertWarnLogContains("recheckedFreeMemMB=1024"); + this.assertWarnLogContains("minFreeMemoryMB=512"); + } + + @Test + public void testFilter_RejectsWhenFreeMemoryIsTooLowWithoutLogging() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(8, 512)); + this.setFreeMemorySamples(256L); + this.setGcResults(false); + this.setMemoryLogPermits(false); + + ServiceUnavailableException exception = (ServiceUnavailableException) Assert.assertThrows( + ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + Assert.assertContains("The server available memory 256(MB) is below than threshold 512(MB)", + exception.getMessage()); + Assert.assertTrue(this.testAppender.events().isEmpty()); + } + + @Test + public void testFilter_AllowsRequestWhenLoadAndMemoryAreHealthy() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(8, 0)); + + this.loadDetectFilter.filter(this.requestContext); + + Assert.assertEquals(1, this.workLoad.get().get()); + Assert.assertTrue(this.testAppender.events().isEmpty()); + } + + @Test + public void testFilter_RejectLogIsRateLimited() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(2, 0)); + this.setBusyLogPermits(true, false); + + this.workLoad.incrementAndGet(); + Assert.assertThrows(ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + this.workLoad.get().set(1); + Assert.assertThrows(ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + Assert.assertEquals(1, this.testAppender.events().size()); + this.assertWarnLogContains("Rejected request due to high worker load"); + } + + @Test + public void testFilter_BusyRejectLogPermitDoesNotAffectMemoryRejectLog() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(2, 0)); + this.setBusyLogPermits(false); + this.workLoad.incrementAndGet(); + + Assert.assertThrows(ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + Assert.assertTrue(this.testAppender.events().isEmpty()); + + this.workLoad.get().set(0); + this.setConfigProvider(createConfig(8, 512)); + this.setFreeMemorySamples(256L); + this.setGcResults(false); + this.setMemoryLogPermits(true); + + Assert.assertThrows(ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + Assert.assertEquals(1, this.testAppender.events().size()); + this.assertWarnLogContains("Rejected request due to low free memory"); + } + + @Test + public void testFilter_MemoryRejectLogPermitDoesNotAffectBusyRejectLog() { + setupPath("graphs/hugegraph/vertices", + List.of("graphs", "hugegraph", "vertices")); + this.setConfigProvider(createConfig(8, 512)); + this.setFreeMemorySamples(256L); + this.setGcResults(false); + this.setMemoryLogPermits(false); + + Assert.assertThrows(ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + Assert.assertTrue(this.testAppender.events().isEmpty()); + + this.workLoad.get().set(1); + this.setConfigProvider(createConfig(2, 0)); + this.setBusyLogPermits(true); + + Assert.assertThrows(ServiceUnavailableException.class, + () -> this.loadDetectFilter.filter(this.requestContext)); + + Assert.assertEquals(1, this.testAppender.events().size()); + this.assertWarnLogContains("Rejected request due to high worker load"); + } + + private HugeConfig createConfig(int maxWorkerThreads, int minFreeMemory) { + Configuration conf = new PropertiesConfiguration(); + conf.setProperty(ServerOptions.MAX_WORKER_THREADS.name(), maxWorkerThreads); + conf.setProperty(ServerOptions.MIN_FREE_MEMORY.name(), minFreeMemory); + return new HugeConfig(conf); + } + + private void setupPath(String path, List segments) { + List pathSegments = segments.stream() + .map(this::createPathSegment) + .collect(Collectors.toList()); + Mockito.when(this.uriInfo.getPath()).thenReturn(path); + Mockito.when(this.uriInfo.getPathSegments()).thenReturn(pathSegments); + } + + private PathSegment createPathSegment(String path) { + PathSegment segment = Mockito.mock(PathSegment.class); + Mockito.when(segment.getPath()).thenReturn(path); + return segment; + } + + private void setLoadProvider(WorkLoad workLoad) { + Whitebox.setInternalState(this.loadDetectFilter, "loadProvider", + (Provider) () -> workLoad); + } + + private void setConfigProvider(HugeConfig config) { + Whitebox.setInternalState(this.loadDetectFilter, "configProvider", + (Provider) () -> config); + } + + private void setGcResults(boolean... gcResults) { + this.setBooleanSupplier("gcTrigger", false, gcResults); + } + + private void setBusyLogPermits(boolean... permits) { + this.setBooleanSupplier("busyRejectLogPermit", true, permits); + } + + private void setMemoryLogPermits(boolean... permits) { + this.setBooleanSupplier("memoryRejectLogPermit", true, permits); + } + + private void setFreeMemorySamples(long... freeMemorySamples) { + Assert.assertTrue(freeMemorySamples.length > 0); + Deque samples = new ArrayDeque<>(); + for (long freeMemorySample : freeMemorySamples) { + samples.addLast(freeMemorySample); + } + long fallback = freeMemorySamples[freeMemorySamples.length - 1]; + Whitebox.setInternalState(this.loadDetectFilter, "freeMemorySupplier", + (LongSupplier) () -> samples.isEmpty() ? fallback : + samples.removeFirst()); + } + + private void setBooleanSupplier(String fieldName, boolean fallback, + boolean... values) { + Deque results = new ArrayDeque<>(); + for (boolean value : values) { + results.addLast(value); + } + Whitebox.setInternalState(this.loadDetectFilter, fieldName, + (BooleanSupplier) () -> results.isEmpty() ? + fallback : + results.removeFirst()); + } + + private void assertWarnLogContains(String expectedContent) { + Assert.assertFalse(this.testAppender.events().isEmpty()); + LogEvent event = this.testAppender.events().get(0); + Assert.assertEquals(Level.WARN, event.getLevel()); + Assert.assertContains(expectedContent, + event.getMessage().getFormattedMessage()); + } + + private void assertWarnLogNotContains(String unexpectedContent) { + Assert.assertFalse(this.testAppender.events().isEmpty()); + LogEvent event = this.testAppender.events().get(0); + Assert.assertFalse(event.getMessage().getFormattedMessage() + .contains(unexpectedContent)); + } + + private static class TestAppender extends AbstractAppender { + + private final List events; + + protected TestAppender() { + super("LoadDetectFilterTestAppender", (Filter) null, + (Layout) null, false, + Property.EMPTY_ARRAY); + this.events = new ArrayList<>(); + } + + @Override + public void append(LogEvent event) { + this.events.add(event.toImmutable()); + } + + public List events() { + return this.events; + } + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/filter/PathFilterTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/filter/PathFilterTest.java new file mode 100644 index 0000000000..8bfdb8752e --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/filter/PathFilterTest.java @@ -0,0 +1,431 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.api.filter; + +import java.io.IOException; +import java.net.URI; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.apache.commons.configuration2.Configuration; +import org.apache.commons.configuration2.PropertiesConfiguration; +import org.apache.hugegraph.api.filter.PathFilter; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.config.ServerOptions; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mockito; + +import jakarta.inject.Provider; +import jakarta.ws.rs.container.ContainerRequestContext; +import jakarta.ws.rs.core.PathSegment; +import jakarta.ws.rs.core.UriBuilder; +import jakarta.ws.rs.core.UriInfo; + +/** + * Unit tests for PathFilter + * Test scenarios: + * 1. Whitelist paths are not redirected + * 2. Normal paths are correctly prefixed with graphspace + * 3. Query parameters are preserved + * 4. Special characters and encoding handling + * 5. Edge cases (empty path, root path, etc.) + */ +public class PathFilterTest extends BaseUnitTest { + + private PathFilter pathFilter; + private Provider configProvider; + private HugeConfig config; + private ContainerRequestContext requestContext; + private UriInfo uriInfo; + + @Before + public void setup() { + // Create configuration + Configuration conf = new PropertiesConfiguration(); + conf.setProperty(ServerOptions.PATH_GRAPH_SPACE.name(), "DEFAULT"); + this.config = new HugeConfig(conf); + + // Create Provider + this.configProvider = () -> config; + + // Create PathFilter and inject Provider + this.pathFilter = new PathFilter(); + injectProvider(this.pathFilter, this.configProvider); + + // Mock request context and uriInfo + this.requestContext = Mockito.mock(ContainerRequestContext.class); + this.uriInfo = Mockito.mock(UriInfo.class); + Mockito.when(this.requestContext.getUriInfo()).thenReturn(this.uriInfo); + } + + /** + * Inject configProvider using reflection + */ + private void injectProvider(PathFilter filter, Provider provider) { + try { + java.lang.reflect.Field field = PathFilter.class.getDeclaredField("configProvider"); + field.setAccessible(true); + field.set(filter, provider); + } catch (Exception e) { + throw new RuntimeException("Failed to inject configProvider", e); + } + } + + /** + * Create PathSegment mock + */ + private PathSegment createPathSegment(String path) { + PathSegment segment = Mockito.mock(PathSegment.class); + Mockito.when(segment.getPath()).thenReturn(path); + return segment; + } + + /** + * Setup URI information + */ + private void setupUriInfo(String basePath, String requestPath, List segments, + String query) { + URI baseUri = URI.create("http://localhost:8080" + basePath); + URI requestUri = + query != null ? URI.create("http://localhost:8080" + requestPath + "?" + query) : + URI.create("http://localhost:8080" + requestPath); + + Mockito.when(uriInfo.getBaseUri()).thenReturn(baseUri); + Mockito.when(uriInfo.getRequestUri()).thenReturn(requestUri); + + List pathSegments = new ArrayList<>(); + for (String segment : segments) { + pathSegments.add(createPathSegment(segment)); + } + Mockito.when(uriInfo.getPathSegments()).thenReturn(pathSegments); + Mockito.when(uriInfo.getPath()).thenReturn(String.join("/", segments)); + + // Mock UriBuilder - capture the path passed to uri() method + final String[] capturedPath = new String[1]; + UriBuilder uriBuilder = Mockito.mock(UriBuilder.class); + Mockito.when(uriInfo.getRequestUriBuilder()).thenReturn(uriBuilder); + Mockito.when(uriBuilder.uri(Mockito.anyString())).thenAnswer(invocation -> { + capturedPath[0] = invocation.getArgument(0); + return uriBuilder; + }); + Mockito.when(uriBuilder.build()).thenAnswer(invocation -> { + // Build URI based on captured path and preserve query parameters + String path = capturedPath[0] != null ? capturedPath[0] : requestPath; + return URI.create("http://localhost:8080" + path + (query != null ? "?" + query : "")); + }); + } + + /** + * Test whitelist API - empty path + */ + @Test + public void testWhiteListApi_EmptyPath() throws IOException { + setupUriInfo("/", "/", List.of(""), null); + + pathFilter.filter(requestContext); + + // Verify whitelist API does not trigger setRequestUri + Mockito.verify(requestContext, Mockito.never()).setRequestUri( + Mockito.any(URI.class), Mockito.any(URI.class)); + // Verify request timestamp is set + Mockito.verify(requestContext).setProperty( + Mockito.eq(PathFilter.REQUEST_TIME), Mockito.anyLong()); + } + + /** + * Test whitelist API - /apis + */ + @Test + public void testWhiteListApi_Apis() throws IOException { + setupUriInfo("/", "/apis", List.of("apis"), null); + + pathFilter.filter(requestContext); + + Mockito.verify(requestContext, Mockito.never()).setRequestUri( + Mockito.any(URI.class), Mockito.any(URI.class)); + } + + /** + * Test whitelist API - /gremlin + */ + @Test + public void testWhiteListApi_Gremlin() throws IOException { + setupUriInfo("/", "/gremlin", List.of("gremlin"), null); + + pathFilter.filter(requestContext); + + Mockito.verify(requestContext, Mockito.never()).setRequestUri( + Mockito.any(URI.class), Mockito.any(URI.class)); + } + + /** + * Test whitelist API - /auth (single segment) + */ + @Test + public void testWhiteListApi_Auth() throws IOException { + setupUriInfo("/", "/auth", List.of("auth"), null); + + pathFilter.filter(requestContext); + + Mockito.verify(requestContext, Mockito.never()) + .setRequestUri(Mockito.any(URI.class), Mockito.any(URI.class)); + } + + /** + * Test whitelist API - /auth/users (multi-segment path) + */ + @Test + public void testWhiteListApi_AuthUsers_MultiSegment() throws IOException { + // Test complete /auth/users path with all segments + setupUriInfo("/", "/auth/users", Arrays.asList("auth", "users"), null); + + pathFilter.filter(requestContext); + + // Should not be redirected (first segment "auth" matches whitelist) + Mockito.verify(requestContext, Mockito.never()).setRequestUri( + Mockito.any(URI.class), Mockito.any(URI.class)); + } + + /** + * Test graphspaces path is not redirected + */ + @Test + public void testGraphSpacePath_NotRedirected() throws IOException { + setupUriInfo("/", "/graphspaces/space1/graphs", + Arrays.asList("graphspaces", "space1", "graphs"), null); + + pathFilter.filter(requestContext); + + Mockito.verify(requestContext, Mockito.never()).setRequestUri( + Mockito.any(URI.class), Mockito.any(URI.class)); + } + + /** + * Test arthas path is not redirected + */ + @Test + public void testArthasPath_NotRedirected() throws IOException { + setupUriInfo("/", "/arthas/api", Arrays.asList("arthas", "api"), null); + + pathFilter.filter(requestContext); + + Mockito.verify(requestContext, Mockito.never()).setRequestUri( + Mockito.any(URI.class), Mockito.any(URI.class)); + } + + /** + * Test normal path is correctly redirected - single segment + */ + @Test + public void testNormalPath_SingleSegment() throws IOException { + setupUriInfo("/", "/graphs", List.of("graphs"), null); + + pathFilter.filter(requestContext); + + // Verify redirect is called with correct path + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + Mockito.verify(requestContext).setRequestUri(Mockito.any(URI.class), uriCaptor.capture()); + + URI capturedUri = uriCaptor.getValue(); + Assert.assertTrue("Redirect URI should contain graphspaces/DEFAULT prefix", + capturedUri.getPath().startsWith("/graphspaces/DEFAULT/graphs")); + Assert.assertEquals("/graphspaces/DEFAULT/graphs", capturedUri.getPath()); + } + + /** + * Test normal path is correctly redirected - multiple segments + */ + @Test + public void testNormalPath_MultipleSegments() throws IOException { + setupUriInfo("/", "/graphs/hugegraph/vertices", + Arrays.asList("graphs", "hugegraph", "vertices"), null); + + pathFilter.filter(requestContext); + + // Verify redirect is called with correct path + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + Mockito.verify(requestContext).setRequestUri(Mockito.any(URI.class), uriCaptor.capture()); + + URI capturedUri = uriCaptor.getValue(); + Assert.assertEquals("/graphspaces/DEFAULT/graphs/hugegraph/vertices", + capturedUri.getPath()); + } + + /** + * Test query parameters are preserved + */ + @Test + public void testQueryParameters_Preserved() throws IOException { + String queryString = "limit=10&offset=20&label=person"; + setupUriInfo("/", "/graphs/hugegraph/vertices", + Arrays.asList("graphs", "hugegraph", "vertices"), queryString); + + URI originalRequestUri = uriInfo.getRequestUri(); + Assert.assertTrue("Original URI should contain query string", + originalRequestUri.toString().contains(queryString)); + + pathFilter.filter(requestContext); + + // Use ArgumentCaptor to capture the actual URI passed to setRequestUri + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + Mockito.verify(requestContext).setRequestUri(Mockito.any(URI.class), uriCaptor.capture()); + + URI capturedUri = uriCaptor.getValue(); + // Verify query parameters are indeed preserved + Assert.assertNotNull("Query parameters should be preserved", capturedUri.getQuery()); + Assert.assertTrue("Query should contain limit parameter", + capturedUri.getQuery().contains("limit=10")); + Assert.assertTrue("Query should contain offset parameter", + capturedUri.getQuery().contains("offset=20")); + Assert.assertTrue("Query should contain label parameter", + capturedUri.getQuery().contains("label=person")); + } + + /** + * Test special characters in path handling + */ + @Test + public void testSpecialCharacters_InPath() throws IOException { + setupUriInfo("/", "/schema/vertexlabels/person-label", + Arrays.asList("schema", "vertexlabels", "person-label"), null); + + pathFilter.filter(requestContext); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + Mockito.verify(requestContext).setRequestUri(Mockito.any(URI.class), uriCaptor.capture()); + + URI capturedUri = uriCaptor.getValue(); + Assert.assertEquals("/graphspaces/DEFAULT/schema/vertexlabels/person-label", + capturedUri.getPath()); + } + + /** + * Test URL encoded characters handling + */ + @Test + public void testUrlEncoded_Characters() throws IOException { + // Path contains encoded space %20 + setupUriInfo("/", "/schema/propertykeys/my%20key", + Arrays.asList("schema", "propertykeys", "my%20key"), null); + + pathFilter.filter(requestContext); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + Mockito.verify(requestContext).setRequestUri(Mockito.any(URI.class), uriCaptor.capture()); + + URI capturedUri = uriCaptor.getValue(); + // URI automatically decodes %20 to space + Assert.assertEquals("/graphspaces/DEFAULT/schema/propertykeys/my key", + capturedUri.getPath()); + } + + /** + * Test custom graph space configuration + */ + @Test + public void testCustomGraphSpace_Configuration() throws IOException { + // Modify configuration to custom graph space + Configuration customConf = new PropertiesConfiguration(); + customConf.setProperty(ServerOptions.PATH_GRAPH_SPACE.name(), "CUSTOM_SPACE"); + HugeConfig customConfig = new HugeConfig(customConf); + + Provider customProvider = () -> customConfig; + injectProvider(this.pathFilter, customProvider); + + setupUriInfo("/", "/graphs/test", Arrays.asList("graphs", "test"), null); + + pathFilter.filter(requestContext); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + Mockito.verify(requestContext).setRequestUri(Mockito.any(URI.class), uriCaptor.capture()); + + URI capturedUri = uriCaptor.getValue(); + Assert.assertEquals("/graphspaces/CUSTOM_SPACE/graphs/test", capturedUri.getPath()); + } + + /** + * Test deeply nested path + */ + @Test + public void testDeeplyNested_Path() throws IOException { + setupUriInfo("/", "/graphs/hugegraph/traversers/shortestpath", + Arrays.asList("graphs", "hugegraph", "traversers", "shortestpath"), null); + + pathFilter.filter(requestContext); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + Mockito.verify(requestContext).setRequestUri(Mockito.any(URI.class), uriCaptor.capture()); + + URI capturedUri = uriCaptor.getValue(); + Assert.assertEquals("/graphspaces/DEFAULT/graphs/hugegraph/traversers/shortestpath", + capturedUri.getPath()); + } + + /** + * Test isWhiteAPI static method - single segment whitelist paths + * Note: PathFilter.isWhiteAPI() only checks the first segment in actual usage + */ + @Test + public void testIsWhiteAPI_AllWhiteListPaths() { + // Test single-segment whitelist entries (as used in PathFilter.filter()) + Assert.assertTrue(PathFilter.isWhiteAPI("")); + Assert.assertTrue(PathFilter.isWhiteAPI("apis")); + Assert.assertTrue(PathFilter.isWhiteAPI("metrics")); + Assert.assertTrue(PathFilter.isWhiteAPI("versions")); + Assert.assertTrue(PathFilter.isWhiteAPI("health")); + Assert.assertTrue(PathFilter.isWhiteAPI("gremlin")); + Assert.assertTrue(PathFilter.isWhiteAPI("auth")); + Assert.assertTrue(PathFilter.isWhiteAPI("hstore")); + Assert.assertTrue(PathFilter.isWhiteAPI("pd")); + Assert.assertTrue(PathFilter.isWhiteAPI("kafka")); + Assert.assertTrue(PathFilter.isWhiteAPI("openapi.json")); + } + + /** + * Test isWhiteAPI static method - multi-segment strings + * Note: This tests the static method directly with multi-segment strings, + * but in actual usage, only the first segment is passed to isWhiteAPI() + */ + @Test + public void testIsWhiteAPI_MultiSegmentStrings() { + // These are how multi-segment entries are stored in the whitelist set + Assert.assertTrue(PathFilter.isWhiteAPI("auth/users")); + Assert.assertTrue(PathFilter.isWhiteAPI("graphs/auth")); + Assert.assertTrue(PathFilter.isWhiteAPI("graphs/auth/users")); + } + + /** + * Test isWhiteAPI static method - non-whitelist paths + */ + @Test + public void testIsWhiteAPI_NonWhiteListPaths() { + Assert.assertFalse(PathFilter.isWhiteAPI("graphs")); + Assert.assertFalse(PathFilter.isWhiteAPI("schema")); + Assert.assertFalse(PathFilter.isWhiteAPI("vertices")); + Assert.assertFalse(PathFilter.isWhiteAPI("edges")); + Assert.assertFalse(PathFilter.isWhiteAPI("traversers")); + Assert.assertFalse(PathFilter.isWhiteAPI("tasks")); + Assert.assertFalse(PathFilter.isWhiteAPI("unknown")); + } +} + diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/gremlin/GremlinQueryAPITest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/gremlin/GremlinQueryAPITest.java new file mode 100644 index 0000000000..94deaf921d --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/api/gremlin/GremlinQueryAPITest.java @@ -0,0 +1,63 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.api.gremlin; + +import java.lang.reflect.Method; + +import org.apache.hugegraph.api.gremlin.GremlinQueryAPI; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.junit.Test; + +public class GremlinQueryAPITest extends BaseUnitTest { + + private static boolean matchBadRequest(String exClass) throws Exception { + Method m = GremlinQueryAPI.class.getDeclaredMethod( + "matchBadRequestException", String.class); + m.setAccessible(true); + return (boolean) m.invoke(null, exClass); + } + + @Test + public void testMatchBadRequestExceptionWithTinkerpop() throws Exception { + Assert.assertTrue(matchBadRequest( + "org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException")); + } + + @Test + public void testMatchBadRequestExceptionWithAuthExceptions() throws Exception { + Assert.assertFalse(matchBadRequest( + "org.apache.tinkerpop.gremlin.server.auth.AuthenticationException")); + Assert.assertFalse(matchBadRequest( + "org.apache.tinkerpop.gremlin.server.authz.AuthorizationException")); + } + + @Test + public void testMatchBadRequestExceptionWithHugegraph() throws Exception { + Assert.assertTrue(matchBadRequest("org.apache.hugegraph.exception.NotFoundException")); + Assert.assertTrue(matchBadRequest("java.lang.IllegalArgumentException")); + Assert.assertTrue(matchBadRequest("groovy.lang.MissingPropertyException")); + } + + @Test + public void testMatchBadRequestExceptionWithOther() throws Exception { + Assert.assertFalse(matchBadRequest(null)); + Assert.assertFalse(matchBadRequest("java.lang.NullPointerException")); + Assert.assertFalse(matchBadRequest("java.io.IOException")); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/auth/HugeGraphAuthProxyTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/auth/HugeGraphAuthProxyTest.java new file mode 100644 index 0000000000..1bff9b29d8 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/auth/HugeGraphAuthProxyTest.java @@ -0,0 +1,198 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.auth; + +import java.lang.reflect.Method; + +import org.apache.hugegraph.auth.HugeAuthenticator; +import org.apache.hugegraph.auth.HugeGraphAuthProxy; +import org.apache.hugegraph.auth.RolePermission; +import org.apache.hugegraph.task.TaskManager; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.junit.After; +import org.junit.Test; + +public class HugeGraphAuthProxyTest extends BaseUnitTest { + + private static HugeGraphAuthProxy.Context setContext( + HugeGraphAuthProxy.Context context) { + try { + Method method = HugeGraphAuthProxy.class.getDeclaredMethod( + "setContext", + HugeGraphAuthProxy.Context.class); + method.setAccessible(true); + return (HugeGraphAuthProxy.Context) method.invoke(null, context); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + @After + public void tearDown() { + // Clean up contexts after each test + HugeGraphAuthProxy.resetContext(); + TaskManager.resetContext(); + } + + @Test + public void testUsernameWithNullContext() { + // Ensure no context is set + HugeGraphAuthProxy.resetContext(); + TaskManager.resetContext(); + + // When context is null, username() should return "anonymous" + String username = HugeGraphAuthProxy.username(); + Assert.assertEquals("anonymous", username); + } + + @Test + public void testUsernameWithValidContext() { + // Create a user with a specific username + HugeAuthenticator.User user = new HugeAuthenticator.User( + "test_user", + RolePermission.admin() + ); + + // Set context with this user + HugeGraphAuthProxy.Context context = new HugeGraphAuthProxy.Context(user); + setContext(context); + + // username() should return the user's username + String username = HugeGraphAuthProxy.username(); + Assert.assertEquals("test_user", username); + } + + @Test + public void testUsernameWithAdminUser() { + // Test with ADMIN user + HugeAuthenticator.User adminUser = HugeAuthenticator.User.ADMIN; + HugeGraphAuthProxy.Context context = new HugeGraphAuthProxy.Context( + adminUser); + setContext(context); + + String username = HugeGraphAuthProxy.username(); + Assert.assertEquals("admin", username); + } + + @Test + public void testGetContextReturnsNull() { + // Ensure both TaskManager context and CONTEXTS are null + HugeGraphAuthProxy.resetContext(); + TaskManager.resetContext(); + + HugeGraphAuthProxy.Context context = HugeGraphAuthProxy.getContext(); + Assert.assertNull(context); + } + + @Test + public void testGetContextFromThreadLocal() { + // Set context via setContext (which sets CONTEXTS ThreadLocal) + HugeAuthenticator.User user = new HugeAuthenticator.User( + "thread_local_user", + RolePermission.admin() + ); + HugeGraphAuthProxy.Context expectedContext = new HugeGraphAuthProxy.Context( + user); + setContext(expectedContext); + + // Ensure TaskManager context is null + TaskManager.resetContext(); + + // getContext() should return the context from CONTEXTS ThreadLocal + HugeGraphAuthProxy.Context context = HugeGraphAuthProxy.getContext(); + Assert.assertNotNull(context); + Assert.assertEquals("thread_local_user", context.user().username()); + } + + @Test + public void testGetContextFromTaskManager() { + // Clear CONTEXTS ThreadLocal + HugeGraphAuthProxy.resetContext(); + + // Create a user and set it in TaskManager context + HugeAuthenticator.User user = new HugeAuthenticator.User( + "task_user", + RolePermission.admin() + ); + String userJson = user.toJson(); + TaskManager.setContext(userJson); + + // getContext() should return context from TaskManager + HugeGraphAuthProxy.Context context = HugeGraphAuthProxy.getContext(); + Assert.assertNotNull(context); + Assert.assertEquals("task_user", context.user().username()); + } + + @Test + public void testGetContextPrioritizesTaskManager() { + // Set both TaskManager context and CONTEXTS ThreadLocal + HugeAuthenticator.User taskUser = new HugeAuthenticator.User( + "task_user", + RolePermission.admin() + ); + String taskUserJson = taskUser.toJson(); + TaskManager.setContext(taskUserJson); + + HugeAuthenticator.User threadUser = new HugeAuthenticator.User( + "thread_user", + RolePermission.admin() + ); + HugeGraphAuthProxy.Context threadContext = new HugeGraphAuthProxy.Context( + threadUser); + setContext(threadContext); + + // getContext() should prioritize TaskManager context + HugeGraphAuthProxy.Context context = HugeGraphAuthProxy.getContext(); + Assert.assertNotNull(context); + Assert.assertEquals("task_user", context.user().username()); + } + + @Test + public void testGetContextWithNullTaskManagerJson() { + // Clear CONTEXTS ThreadLocal + HugeGraphAuthProxy.resetContext(); + + // Set null in TaskManager + TaskManager.setContext(null); + + // getContext() should return null + HugeGraphAuthProxy.Context context = HugeGraphAuthProxy.getContext(); + Assert.assertNull(context); + } + + @Test + public void testUsernameAfterResetContext() { + // Set a context first + HugeAuthenticator.User user = new HugeAuthenticator.User( + "temp_user", + RolePermission.admin() + ); + HugeGraphAuthProxy.Context context = new HugeGraphAuthProxy.Context(user); + setContext(context); + + // Verify it's set + Assert.assertEquals("temp_user", HugeGraphAuthProxy.username()); + + // Reset context + HugeGraphAuthProxy.resetContext(); + + // username() should now return "anonymous" + Assert.assertEquals("anonymous", HugeGraphAuthProxy.username()); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CacheManagerTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CacheManagerTest.java index a525bfcb92..8d7ef2166a 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CacheManagerTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CacheManagerTest.java @@ -19,6 +19,7 @@ import java.lang.reflect.Proxy; import java.util.Map; +import java.util.TimerTask; import java.util.concurrent.ConcurrentHashMap; import org.apache.hugegraph.backend.cache.Cache; @@ -271,6 +272,8 @@ public void testCacheListModify() { @Test public void testCacheExpire() { + CacheManager manager = CacheManager.instance(); + Cache cache1 = new RamCache(); cache1.expire(26 * 1000L); @@ -285,17 +288,23 @@ public void testCacheExpire() { mockCache2); Mockito.when(this.mockCaches.entrySet()).thenReturn(caches.entrySet()); - cache1.update(IdGenerator.of("fake-id"), "fake-value"); - cache2.update(IdGenerator.of("fake-id"), "fake-value"); + TimerTask task = Whitebox.invoke(CacheManager.class, "scheduleTimer", + manager, 0.1F); + try { + cache1.update(IdGenerator.of("fake-id"), "fake-value", + -30 * 1000L); + cache2.update(IdGenerator.of("fake-id"), "fake-value"); - waitTillNext(40); + waitTillNext(3); - // Would call tick() per 30s - Mockito.verify(mockCache1, Mockito.times(1)).tick(); - Mockito.verify(mockCache2, Mockito.times(1)).tick(); + Mockito.verify(mockCache1, Mockito.atLeastOnce()).tick(); + Mockito.verify(mockCache2, Mockito.atLeastOnce()).tick(); - Assert.assertEquals(0, cache1.size()); - Assert.assertEquals(1, cache2.size()); + Assert.assertEquals(0, cache1.size()); + Assert.assertEquals(1, cache2.size()); + } finally { + task.cancel(); + } } @SuppressWarnings({"unused", "unchecked"}) @@ -308,4 +317,3 @@ private static Cache newCacheProxy(Cache cache) { return (Cache) p; } } - diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedGraphTransactionTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedGraphTransactionTest.java index 4a1c18dbef..7bcc1a7fef 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedGraphTransactionTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedGraphTransactionTest.java @@ -17,12 +17,21 @@ package org.apache.hugegraph.unit.cache; +import java.lang.reflect.Field; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; + import org.apache.hugegraph.HugeFactory; import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.cache.Cache; import org.apache.hugegraph.backend.cache.CachedGraphTransaction; import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.tx.GraphTransaction; +import org.apache.hugegraph.event.EventListener; import org.apache.hugegraph.schema.VertexLabel; import org.apache.hugegraph.structure.HugeEdge; import org.apache.hugegraph.structure.HugeVertex; @@ -42,19 +51,30 @@ public class CachedGraphTransactionTest extends BaseUnitTest { private CachedGraphTransaction cache; private HugeGraphParams params; + private HugeGraph graph; @Before public void setup() { - HugeGraph graph = HugeFactory.open(FakeObjects.newConfig()); - this.params = Whitebox.getInternalState(graph, "params"); + this.graph = HugeFactory.open(FakeObjects.newConfig()); + this.params = Whitebox.getInternalState(this.graph, "params"); this.cache = new CachedGraphTransaction(this.params, this.params.loadGraphStore()); } @After public void teardown() throws Exception { - this.cache().graph().clearBackend(); - this.cache().graph().close(); + try { + if (this.cache != null) { + this.cache.close(); + } + } finally { + this.cache = null; + if (this.graph != null) { + this.graph.clearBackend(); + this.graph.close(); + this.graph = null; + } + } } private CachedGraphTransaction cache() { @@ -62,6 +82,42 @@ private CachedGraphTransaction cache() { return this.cache; } + @SuppressWarnings("unchecked") + private static ConcurrentMap graphCacheEventListeners() + throws Exception { + Field field = CachedGraphTransaction.class + .getDeclaredField( + "GRAPH_CACHE_EVENT_LISTENERS"); + field.setAccessible(true); + return (ConcurrentMap) field.get(null); + } + + @SuppressWarnings("unchecked") + private static ConcurrentMap storeEventListenStatus() + throws Exception { + Field field = GraphTransaction.class + .getDeclaredField("storeEventListenStatus"); + field.setAccessible(true); + return (ConcurrentMap) field.get(null); + } + + private static void restoreStoreListenerStatusForKnownTeardownBug( + ConcurrentMap storeListeners, String graphName) { + // Closing a secondary transaction can consume storeEventListenStatus due + // to the follow-up bug documented in CachedGraphTransaction.unlistenChanges(). + // Restore it so teardown can still unregister the primary store listener. + storeListeners.putIfAbsent(graphName, true); + } + + private static EventListener holderListener(Object holder) { + return Whitebox.getInternalState(holder, "listener"); + } + + private static int holderRefCount(Object holder) { + Integer refCount = Whitebox.getInternalState(holder, "refCount"); + return refCount; + } + private HugeVertex newVertex(Id id) { HugeGraph graph = this.cache().graph(); graph.schema().propertyKey("name").asText() @@ -138,6 +194,174 @@ public void testEventInvalid() throws Exception { Whitebox.invoke(cache, "verticesCache", "size")); } + @Test + public void testClearCacheEmitsActionClear() throws Exception { + // Producers must emit the present-tense ACTION_CLEAR / ACTION_INVALID, + // not the legacy past-tense variants - otherwise local listeners that + // match only the present-tense actions silently drop the event. + CachedGraphTransaction cache = this.cache(); + CountDownLatch latch = new CountDownLatch(1); + AtomicReference action = new AtomicReference<>(); + EventListener listener = event -> { + Object[] args = event.args(); + if (args.length > 0 && args[0] instanceof String) { + action.set((String) args[0]); + latch.countDown(); + } + return true; + }; + this.params.graphEventHub().listen(Events.CACHE, listener); + try { + cache.clearCache(HugeType.VERTEX, true); + + Assert.assertTrue(latch.await(1L, TimeUnit.SECONDS)); + Assert.assertEquals(Cache.ACTION_CLEAR, action.get()); + } finally { + this.params.graphEventHub().unlisten(Events.CACHE, listener); + } + } + + @Test + public void testVertexMutationEmitsActionInvalid() throws Exception { + CachedGraphTransaction cache = this.cache(); + CountDownLatch latch = new CountDownLatch(1); + AtomicReference action = new AtomicReference<>(); + EventListener listener = event -> { + Object[] args = event.args(); + if (args.length > 0 && Cache.ACTION_INVALID.equals(args[0])) { + action.set((String) args[0]); + latch.countDown(); + } + return true; + }; + this.params.graphEventHub().listen(Events.CACHE, listener); + try { + cache.addVertex(this.newVertex(IdGenerator.of(1))); + cache.commit(); + + Assert.assertTrue(latch.await(1L, TimeUnit.SECONDS)); + Assert.assertEquals(Cache.ACTION_INVALID, action.get()); + } finally { + this.params.graphEventHub().unlisten(Events.CACHE, listener); + } + } + + @Test + public void testClosingNonOwnerKeepsGraphCacheListenerRegistered() + throws Exception { + ConcurrentMap cacheListeners = + graphCacheEventListeners(); + ConcurrentMap storeListeners = + storeEventListenStatus(); + + String graphName = this.params.spaceGraphName(); + Object holder = cacheListeners.get(graphName); + Assert.assertNotNull(holder); + EventListener registered = holderListener(holder); + int refCount = holderRefCount(holder); + + CachedGraphTransaction second = new CachedGraphTransaction( + this.params, this.params.loadGraphStore()); + Assert.assertSame(holder, cacheListeners.get(graphName)); + Assert.assertEquals(refCount + 1, holderRefCount(holder)); + + try { + second.close(); + + Assert.assertSame(holder, cacheListeners.get(graphName)); + Assert.assertEquals(refCount, holderRefCount(holder)); + Assert.assertTrue(this.params.graphEventHub() + .listeners(Events.CACHE) + .contains(registered)); + } finally { + restoreStoreListenerStatusForKnownTeardownBug(storeListeners, + graphName); + } + } + + @Test + public void testCacheListenerSurvivesOwnerClose() throws Exception { + ConcurrentMap cacheListeners = + graphCacheEventListeners(); + String graphName = this.params.spaceGraphName(); + CachedGraphTransaction owner = this.cache(); + CachedGraphTransaction second = new CachedGraphTransaction( + this.params, this.params.loadGraphStore()); + + Object holder = cacheListeners.get(graphName); + Assert.assertNotNull(holder); + EventListener registered = holderListener(holder); + int refCount = holderRefCount(holder); + Assert.assertTrue(refCount >= 2); + + owner.close(); + this.cache = second; + + Assert.assertSame(holder, cacheListeners.get(graphName)); + Assert.assertEquals(refCount - 1, holderRefCount(holder)); + Assert.assertTrue(this.params.graphEventHub() + .listeners(Events.CACHE) + .contains(registered)); + + second.addVertex(this.newVertex(IdGenerator.of(1))); + second.addVertex(this.newVertex(IdGenerator.of(2))); + second.commit(); + Assert.assertTrue(second.queryVertices(IdGenerator.of(1)).hasNext()); + Assert.assertTrue(second.queryVertices(IdGenerator.of(2)).hasNext()); + Assert.assertEquals(2L, + Whitebox.invoke(second, "verticesCache", "size")); + + this.params.graphEventHub().notify(Events.CACHE, Cache.ACTION_INVALID, + HugeType.VERTEX, IdGenerator.of(1)) + .get(); + + Assert.assertEquals(1L, + Whitebox.invoke(second, "verticesCache", "size")); + } + + @Test + public void testLastCloseRemovesGraphCacheListener() throws Exception { + ConcurrentMap cacheListeners = + graphCacheEventListeners(); + String graphName = this.params.spaceGraphName(); + CachedGraphTransaction owner = this.cache(); + CachedGraphTransaction second = new CachedGraphTransaction( + this.params, this.params.loadGraphStore()); + + Object holder = cacheListeners.get(graphName); + Assert.assertNotNull(holder); + EventListener registered = holderListener(holder); + Assert.assertTrue(holderRefCount(holder) >= 2); + + owner.close(); + second.close(); + this.cache = null; + this.params.graphTransaction().close(); + + Assert.assertFalse(cacheListeners.containsKey(graphName)); + Assert.assertFalse(this.params.graphEventHub() + .listeners(Events.CACHE) + .contains(registered)); + + this.graph.clearBackend(); + this.graph.close(); + this.graph = null; + + HugeGraph reopened = HugeFactory.open(FakeObjects.newConfig()); + this.graph = reopened; + this.params = Whitebox.getInternalState(reopened, "params"); + Object reopenedHolder = cacheListeners.get(graphName); + Assert.assertNotNull(reopenedHolder); + Assert.assertNotSame(holder, reopenedHolder); + int reopenedRefCount = holderRefCount(reopenedHolder); + CachedGraphTransaction third = new CachedGraphTransaction( + this.params, this.params.loadGraphStore()); + this.cache = third; + Object newHolder = cacheListeners.get(graphName); + Assert.assertSame(reopenedHolder, newHolder); + Assert.assertEquals(reopenedRefCount + 1, holderRefCount(newHolder)); + } + @Test public void testEdgeCacheClearWhenDeleteVertex() { CachedGraphTransaction cache = this.cache(); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedSchemaTransactionTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedSchemaTransactionTest.java index 83ba5097fa..9921670eef 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedSchemaTransactionTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cache/CachedSchemaTransactionTest.java @@ -17,11 +17,36 @@ package org.apache.hugegraph.unit.cache; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; + import org.apache.hugegraph.HugeFactory; import org.apache.hugegraph.HugeGraph; import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.cache.Cache; +import org.apache.hugegraph.backend.cache.CacheNotifier; +import org.apache.hugegraph.backend.cache.CacheManager; import org.apache.hugegraph.backend.cache.CachedSchemaTransaction; +import org.apache.hugegraph.backend.cache.CachedSchemaTransactionV2; +import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.event.EventHub; +import org.apache.hugegraph.event.EventListener; +import org.apache.hugegraph.meta.MetaDriver; +import org.apache.hugegraph.meta.MetaManager; +import org.apache.hugegraph.meta.managers.GraphMetaManager; +import org.apache.hugegraph.schema.SchemaElement; import org.apache.hugegraph.testutil.Assert; import org.apache.hugegraph.testutil.Whitebox; import org.apache.hugegraph.type.HugeType; @@ -31,6 +56,8 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mockito; import com.google.common.collect.ImmutableMap; @@ -38,19 +65,30 @@ public class CachedSchemaTransactionTest extends BaseUnitTest { private CachedSchemaTransaction cache; private HugeGraphParams params; + private HugeGraph graph; @Before public void setup() { - HugeGraph graph = HugeFactory.open(FakeObjects.newConfig()); - this.params = Whitebox.getInternalState(graph, "params"); + this.graph = HugeFactory.open(FakeObjects.newConfig()); + this.params = Whitebox.getInternalState(this.graph, "params"); this.cache = new CachedSchemaTransaction(this.params, this.params.loadSchemaStore()); } @After public void teardown() throws Exception { - this.cache().graph().clearBackend(); - this.cache().graph().close(); + try { + if (this.cache != null) { + this.cache.close(); + } + } finally { + this.cache = null; + if (this.graph != null) { + this.graph.clearBackend(); + this.graph.close(); + this.graph = null; + } + } } private CachedSchemaTransaction cache() { @@ -58,6 +96,25 @@ private CachedSchemaTransaction cache() { return this.cache; } + @SuppressWarnings("unchecked") + private static ConcurrentMap schemaCacheEventListeners() + throws Exception { + Field field = CachedSchemaTransaction.class + .getDeclaredField( + "SCHEMA_CACHE_EVENT_LISTENERS"); + field.setAccessible(true); + return (ConcurrentMap) field.get(null); + } + + private static EventListener holderListener(Object holder) { + return Whitebox.getInternalState(holder, "listener"); + } + + private static int holderRefCount(Object holder) { + Integer refCount = Whitebox.getInternalState(holder, "refCount"); + return refCount; + } + @Test public void testEventClear() throws Exception { CachedSchemaTransaction cache = this.cache(); @@ -165,6 +222,742 @@ public void testGetSchema() throws Exception { cache.getPropertyKey(IdGenerator.of(1)).name()); } + @Test + public void testLegacySchemaChangeEmitsActionInvalid() + throws Exception { + CachedSchemaTransaction cache = this.cache(); + CountDownLatch latch = new CountDownLatch(1); + AtomicReference action = new AtomicReference<>(); + EventListener listener = event -> { + Object[] args = event.args(); + if (args.length > 0) { + action.set((String) args[0]); + latch.countDown(); + } + return true; + }; + this.params.schemaEventHub().listen(Events.CACHE, listener); + + try { + FakeObjects objects = new FakeObjects("unit-test"); + cache.addPropertyKey(objects.newPropertyKey(IdGenerator.of(1), + "fake-pk-1")); + + Assert.assertTrue(latch.await(1L, TimeUnit.SECONDS)); + Assert.assertEquals(Cache.ACTION_INVALID, action.get()); + Assert.assertEquals(1L, Whitebox.invoke(cache, "idCache", "size")); + Assert.assertEquals(1L, + Whitebox.invoke(cache, "nameCache", "size")); + Assert.assertEquals("fake-pk-1", + cache.getPropertyKey(IdGenerator.of(1)) + .name()); + Assert.assertEquals(IdGenerator.of(1), + cache.getPropertyKey("fake-pk-1").id()); + } finally { + this.params.schemaEventHub().unlisten(Events.CACHE, listener); + } + } + + @Test + public void testCacheListenerSurvivesOwnerClose() throws Exception { + ConcurrentMap registry = schemaCacheEventListeners(); + String graphName = this.params.spaceGraphName(); + CachedSchemaTransaction owner = this.cache(); + CachedSchemaTransaction second = new CachedSchemaTransaction( + this.params, this.params.loadSchemaStore()); + + Object holder = registry.get(graphName); + Assert.assertNotNull(holder); + EventListener registered = holderListener(holder); + int refCount = holderRefCount(holder); + Assert.assertTrue(refCount >= 2); + + owner.close(); + this.cache = second; + + Assert.assertSame(holder, registry.get(graphName)); + Assert.assertEquals(refCount - 1, holderRefCount(holder)); + Assert.assertTrue(this.params.schemaEventHub() + .listeners(Events.CACHE) + .contains(registered)); + + FakeObjects objects = new FakeObjects("unit-test"); + second.addPropertyKey(objects.newPropertyKey(IdGenerator.of(1), + "fake-pk-1")); + second.addPropertyKey(objects.newPropertyKey(IdGenerator.of(2), + "fake-pk-2")); + Assert.assertEquals(2L, Whitebox.invoke(second, "idCache", "size")); + Assert.assertEquals(2L, Whitebox.invoke(second, "nameCache", "size")); + + this.params.schemaEventHub().notify(Events.CACHE, Cache.ACTION_CLEAR, + null).get(); + + Assert.assertEquals(0L, Whitebox.invoke(second, "idCache", "size")); + Assert.assertEquals(0L, Whitebox.invoke(second, "nameCache", "size")); + } + + @Test + public void testLastCloseRemovesSchemaCacheListener() throws Exception { + ConcurrentMap registry = schemaCacheEventListeners(); + String graphName = this.params.spaceGraphName(); + CachedSchemaTransaction owner = this.cache(); + CachedSchemaTransaction second = new CachedSchemaTransaction( + this.params, this.params.loadSchemaStore()); + + Object holder = registry.get(graphName); + Assert.assertNotNull(holder); + EventListener registered = holderListener(holder); + Assert.assertTrue(holderRefCount(holder) >= 2); + + owner.close(); + second.close(); + this.cache = null; + this.params.schemaTransaction().close(); + + Assert.assertFalse(registry.containsKey(graphName)); + Assert.assertFalse(this.params.schemaEventHub() + .listeners(Events.CACHE) + .contains(registered)); + + this.graph.clearBackend(); + this.graph.close(); + this.graph = null; + + HugeGraph reopened = HugeFactory.open(FakeObjects.newConfig()); + this.graph = reopened; + this.params = Whitebox.getInternalState(reopened, "params"); + Object reopenedHolder = registry.get(graphName); + Assert.assertNotNull(reopenedHolder); + Assert.assertNotSame(holder, reopenedHolder); + int reopenedRefCount = holderRefCount(reopenedHolder); + CachedSchemaTransaction third = new CachedSchemaTransaction( + this.params, this.params.loadSchemaStore()); + this.cache = third; + Object newHolder = registry.get(graphName); + Assert.assertSame(reopenedHolder, newHolder); + Assert.assertEquals(reopenedRefCount + 1, holderRefCount(newHolder)); + } + + @Test + public void testCacheNotifierLocalEventCallsProxyOnce() + throws Exception { + EventHub hub = new EventHub("schema-cache-notifier-test"); + AtomicInteger proxyInvalidCalls = new AtomicInteger(); + CacheNotifier proxy = newCacheNotifier(proxyInvalidCalls, + new AtomicInteger(), + new AtomicInteger()); + CacheNotifier notifier = newSchemaCacheNotifier(hub, proxy); + + try { + Assert.assertEquals(1, (int) hub.notify(Events.CACHE, + Cache.ACTION_INVALID, + HugeType.PROPERTY_KEY, + IdGenerator.of(1)) + .get()); + Assert.assertEquals(1, proxyInvalidCalls.get()); + } finally { + notifier.close(); + } + } + + @Test + public void testCacheNotifierRpcInvalidDoesNotLoopToProxy() + throws Exception { + EventHub hub = new EventHub("schema-cache-notifier-test"); + AtomicInteger proxyInvalidCalls = new AtomicInteger(); + AtomicInteger localInvalidCalls = new AtomicInteger(); + CountDownLatch latch = new CountDownLatch(1); + CacheNotifier proxy = newCacheNotifier(proxyInvalidCalls, + new AtomicInteger(), + new AtomicInteger()); + CacheNotifier notifier = newSchemaCacheNotifier(hub, proxy); + EventListener localListener = event -> { + event.checkArgs(String.class, HugeType.class, Id.class); + if (Cache.ACTION_INVALID.equals(event.args()[0])) { + localInvalidCalls.incrementAndGet(); + latch.countDown(); + } + return true; + }; + hub.listen(Events.CACHE, localListener); + + try { + notifier.invalid(HugeType.PROPERTY_KEY, IdGenerator.of(1)); + + Assert.assertTrue(latch.await(1L, TimeUnit.SECONDS)); + Assert.assertEquals(1, localInvalidCalls.get()); + Assert.assertEquals(0, proxyInvalidCalls.get()); + } finally { + notifier.close(); + } + } + + @Test + public void testClearV2SchemaCacheByGraphName() { + String graphName = "DEFAULT-unit-test-v2"; + String otherGraphName = "DEFAULT-other-v2"; + + Cache idCache = CacheManager.instance() + .cache("schema-id-" + + graphName, 10L); + Cache nameCache = CacheManager.instance() + .cache("schema-name-" + + graphName, 10L); + Cache otherIdCache = CacheManager.instance() + .cache("schema-id-" + + otherGraphName, + 10L); + Object arrayCaches = idCache.attachment(newV2SchemaCaches(10)); + Id arrayCacheId = IdGenerator.of(1); + SchemaElement arrayCacheSchema = + new FakeObjects("unit-test-v2") + .newPropertyKey(arrayCacheId, "fake-pk-array"); + + try { + clearV2SchemaCaches(arrayCaches); + setV2SchemaCache(arrayCaches, HugeType.PROPERTY_KEY, arrayCacheId, + arrayCacheSchema); + idCache.update(IdGenerator.of(1), "fake-pk-by-id"); + nameCache.update(IdGenerator.of("fake-pk"), "fake-pk-by-name"); + otherIdCache.update(IdGenerator.of(2), "other-pk-by-id"); + + Assert.assertEquals(1L, idCache.size()); + Assert.assertEquals(1L, nameCache.size()); + Assert.assertEquals(1L, otherIdCache.size()); + Assert.assertSame(arrayCacheSchema, + getV2SchemaCache(arrayCaches, + HugeType.PROPERTY_KEY, + arrayCacheId)); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + new Class[]{String.class}, + "clearSchemaCache", graphName); + + Assert.assertEquals(0L, idCache.size()); + Assert.assertEquals(0L, nameCache.size()); + Assert.assertEquals(1L, otherIdCache.size()); + Assert.assertNull(getV2SchemaCache(arrayCaches, + HugeType.PROPERTY_KEY, + arrayCacheId)); + } finally { + clearV2SchemaCaches(arrayCaches); + idCache.clear(); + nameCache.clear(); + otherIdCache.clear(); + } + } + + private static Object newV2SchemaCaches(int size) { + for (Class clazz : + CachedSchemaTransactionV2.class.getDeclaredClasses()) { + if (!"SchemaCaches".equals(clazz.getSimpleName())) { + continue; + } + try { + Constructor constructor = + clazz.getDeclaredConstructor(int.class); + constructor.setAccessible(true); + return constructor.newInstance(size); + } catch (ReflectiveOperationException e) { + throw new AssertionError("Failed to create SchemaCaches", e); + } + } + throw new AssertionError("SchemaCaches class not found"); + } + + private static void clearV2SchemaCaches(Object arrayCaches) { + Whitebox.invoke(arrayCaches.getClass(), "clear", arrayCaches); + } + + private static void setV2SchemaCache(Object arrayCaches, HugeType type, + Id id, SchemaElement schema) { + Whitebox.invoke(arrayCaches.getClass(), + new Class[]{HugeType.class, Id.class, + SchemaElement.class}, + "set", arrayCaches, type, id, schema); + } + + private static SchemaElement getV2SchemaCache(Object arrayCaches, + HugeType type, Id id) { + return Whitebox.invoke(arrayCaches.getClass(), + new Class[]{HugeType.class, Id.class}, + "get", arrayCaches, type, id); + } + + @Test + public void testListenSchemaCacheClearIsIdempotent() throws Exception { + // Once the JVM-global registration flag is set, every subsequent + // call to listenSchemaCacheClear() must short-circuit before + // touching MetaManager — even under concurrent invocation. Pre-set + // the flag, race N threads, and verify none of them propagated an + // exception (which would happen if MetaManager.instance() + // .listenSchemaCacheClear were invoked without an initialised + // driver). + Field flagField = CachedSchemaTransactionV2.class + .getDeclaredField("metaEventListenerRegistered"); + flagField.setAccessible(true); + AtomicBoolean flag = (AtomicBoolean) flagField.get(null); + boolean previous = flag.getAndSet(true); + try { + int threads = 8; + CountDownLatch start = new CountDownLatch(1); + CountDownLatch done = new CountDownLatch(threads); + AtomicInteger failures = new AtomicInteger(); + for (int i = 0; i < threads; i++) { + new Thread(() -> { + try { + start.await(); + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + "listenSchemaCacheClear"); + } catch (Throwable t) { + failures.incrementAndGet(); + } finally { + done.countDown(); + } + }).start(); + } + start.countDown(); + Assert.assertTrue("listenSchemaCacheClear race timed out", + done.await(10, TimeUnit.SECONDS)); + Assert.assertEquals("listenSchemaCacheClear must short-circuit " + + "when already registered", 0, failures.get()); + Assert.assertTrue("registration flag must remain set", flag.get()); + } finally { + flag.set(previous); + } + } + + @Test + public void testClearSchemaCacheClearsArrayAttachmentMaps() + throws Exception { + // clearSchemaCache() must wipe idCache, nameCache and every internal + // IntObjectMap (pks/vls/els/ils) inside the array attachment so + // stale entries are not served after a meta event. + String graphName = "DEFAULT-unit-test-v2-array"; + Cache idCache = + CacheManager.instance().cache("schema-id-" + graphName, 10L); + Cache nameCache = + CacheManager.instance().cache("schema-name-" + graphName, 10L); + // Size must comfortably exceed the largest id below: IntObjectMap + // grows by doubling and refuses to write past currentSize even after + // a single expansion, so a small capacity rejects mid-range keys. + Object arrayCaches = idCache.attachment(newV2SchemaCaches(64)); + Id pkId = IdGenerator.of(1); + Id vlId = IdGenerator.of(2); + Id elId = IdGenerator.of(3); + Id ilId = IdGenerator.of(4); + FakeObjects fakeObjects = new FakeObjects("unit-test-v2-array"); + SchemaElement pk = fakeObjects.newPropertyKey(pkId, "fake-pk"); + + try { + clearV2SchemaCaches(arrayCaches); + setV2SchemaCache(arrayCaches, HugeType.PROPERTY_KEY, pkId, pk); + setV2SchemaCache(arrayCaches, HugeType.VERTEX_LABEL, vlId, pk); + setV2SchemaCache(arrayCaches, HugeType.EDGE_LABEL, elId, pk); + setV2SchemaCache(arrayCaches, HugeType.INDEX_LABEL, ilId, pk); + idCache.update(pkId, "fake-pk-by-id"); + nameCache.update(IdGenerator.of("fake-pk"), "fake-pk-by-name"); + + Assert.assertEquals(1L, idCache.size()); + Assert.assertEquals(1L, nameCache.size()); + Assert.assertNotNull(getV2SchemaCache(arrayCaches, + HugeType.PROPERTY_KEY, pkId)); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + new Class[]{String.class}, + "clearSchemaCache", graphName); + + Assert.assertEquals(0L, idCache.size()); + Assert.assertEquals(0L, nameCache.size()); + for (String mapName : new String[]{"pks", "vls", "els", "ils"}) { + Object intMap = readField(arrayCaches, mapName); + assertIntObjectMapEmpty(intMap, mapName); + } + Map cachedTypes = readField(arrayCaches, + "cachedTypes"); + Assert.assertTrue("cachedTypes must be empty after clear", + cachedTypes.isEmpty()); + } finally { + clearV2SchemaCaches(arrayCaches); + idCache.clear(); + nameCache.clear(); + } + } + + // TASK_SYNC_DELETION gating of removeSchema notifications and the + // unconditional addSchema notification require an initialised + // CachedSchemaTransactionV2 instance, which in turn needs an hstore + // backend and a connected MetaManager. Both prerequisites are out of + // scope for this unit test class. They are exercised end-to-end by the + // hstore integration tests in CoreTestSuite. TODO(#2617): port these + // assertions into a dedicated CachedSchemaTransactionV2IT once + // mockito-inline becomes available so MetaManager.instance() can be + // stubbed without an hstore cluster. + + @Test + public void testHandleSchemaCacheClearEventSkipsLocalSource() + throws Exception { + String graphName = "DEFAULT-meta-local-source-v2"; + Cache idCache = + CacheManager.instance().cache("schema-id-" + graphName, 10L); + Cache nameCache = + CacheManager.instance() + .cache("schema-name-" + graphName, 10L); + + MetaDriver mockDriver = Mockito.mock(MetaDriver.class); + Object localResponse = new Object(); + Object remoteResponse = new Object(); + String localSource = schemaCacheClearSource(); + Mockito.when(mockDriver.extractValuesFromResponse(localResponse)) + .thenReturn(Collections.singletonList( + MetaManager.schemaCacheClearEventValue(graphName, + localSource))); + Mockito.when(mockDriver.extractValuesFromResponse(remoteResponse)) + .thenReturn(Collections.singletonList( + MetaManager.schemaCacheClearEventValue(graphName, + "remote"))); + + MetaDriver originalDriver = swapMetaDriver(mockDriver); + try { + idCache.update(IdGenerator.of(1), "v"); + nameCache.update(IdGenerator.of("n"), "v"); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + new Class[]{Object.class}, + "handleSchemaCacheClearEvent", + localResponse); + + Assert.assertEquals("local echo must not clear id cache", + 1L, idCache.size()); + Assert.assertEquals("local echo must not clear name cache", + 1L, nameCache.size()); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + new Class[]{Object.class}, + "handleSchemaCacheClearEvent", + remoteResponse); + + Assert.assertEquals(0L, idCache.size()); + Assert.assertEquals(0L, nameCache.size()); + } finally { + swapMetaDriver(originalDriver); + idCache.clear(); + nameCache.clear(); + } + } + + @Test + public void testHandleSchemaCacheClearEventClearsTargetGraphOnly() + throws Exception { + // End-to-end coverage of the meta-event consumer: + // publish (response) -> MetaManager extract -> clearSchemaCache + // We bypass the live etcd/PD watch by stubbing MetaDriver on the + // MetaManager singleton and invoking the package-private consumer + // directly. This validates that only the targeted graph's caches are + // cleared and that other graphs in the same JVM are left untouched. + String targetGraph = "DEFAULT-meta-target-v2"; + String otherGraph = "DEFAULT-meta-other-v2"; + + Cache targetIdCache = + CacheManager.instance().cache("schema-id-" + targetGraph, 10L); + Cache targetNameCache = + CacheManager.instance() + .cache("schema-name-" + targetGraph, 10L); + Cache otherIdCache = + CacheManager.instance().cache("schema-id-" + otherGraph, 10L); + + MetaDriver mockDriver = Mockito.mock(MetaDriver.class); + Object response = new Object(); + Mockito.when(mockDriver.extractValuesFromResponse(response)) + .thenReturn(Arrays.asList(targetGraph)); + + MetaDriver originalDriver = swapMetaDriver(mockDriver); + try { + targetIdCache.update(IdGenerator.of(1), "v"); + targetNameCache.update(IdGenerator.of("n"), "v"); + otherIdCache.update(IdGenerator.of(2), "v"); + + Assert.assertEquals(1L, targetIdCache.size()); + Assert.assertEquals(1L, targetNameCache.size()); + Assert.assertEquals(1L, otherIdCache.size()); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + new Class[]{Object.class}, + "handleSchemaCacheClearEvent", response); + + Assert.assertEquals(0L, targetIdCache.size()); + Assert.assertEquals(0L, targetNameCache.size()); + Assert.assertEquals("Other graph caches must remain untouched", + 1L, otherIdCache.size()); + } finally { + swapMetaDriver(originalDriver); + targetIdCache.clear(); + targetNameCache.clear(); + otherIdCache.clear(); + } + } + + @Test + public void testHandleSchemaCacheClearEventNullGraphsIsNoop() + throws Exception { + // A response that yields no graph names (extractor returns null) must + // be a strict noop: caches stay populated. + String graphName = "DEFAULT-meta-noop-v2"; + Cache idCache = + CacheManager.instance().cache("schema-id-" + graphName, 10L); + + MetaDriver mockDriver = Mockito.mock(MetaDriver.class); + Object response = new Object(); + Mockito.when(mockDriver.extractValuesFromResponse(response)) + .thenReturn(null); + + MetaDriver originalDriver = swapMetaDriver(mockDriver); + try { + idCache.update(IdGenerator.of(1), "v"); + Assert.assertEquals(1L, idCache.size()); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + new Class[]{Object.class}, + "handleSchemaCacheClearEvent", response); + + Assert.assertEquals("noop response must not clear any cache", + 1L, idCache.size()); + } finally { + swapMetaDriver(originalDriver); + idCache.clear(); + } + } + + @Test + public void testHandleSchemaCacheClearEventClearsMultipleGraphs() + throws Exception { + // A single meta event may carry multiple graph names; every one of + // them must have its V2 caches cleared. + String graphA = "DEFAULT-meta-multi-a"; + String graphB = "DEFAULT-meta-multi-b"; + Cache idA = + CacheManager.instance().cache("schema-id-" + graphA, 10L); + Cache idB = + CacheManager.instance().cache("schema-id-" + graphB, 10L); + + MetaDriver mockDriver = Mockito.mock(MetaDriver.class); + Object response = new Object(); + Mockito.when(mockDriver.extractValuesFromResponse(response)) + .thenReturn(Arrays.asList(graphA, graphB)); + + MetaDriver originalDriver = swapMetaDriver(mockDriver); + try { + idA.update(IdGenerator.of(1), "v"); + idB.update(IdGenerator.of(2), "v"); + Assert.assertEquals(1L, idA.size()); + Assert.assertEquals(1L, idB.size()); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + new Class[]{Object.class}, + "handleSchemaCacheClearEvent", response); + + Assert.assertEquals(0L, idA.size()); + Assert.assertEquals(0L, idB.size()); + } finally { + swapMetaDriver(originalDriver); + idA.clear(); + idB.clear(); + } + } + + @Test + @SuppressWarnings({"rawtypes", "unchecked"}) + public void testListenSchemaCacheClearRegistersOnlyOnce() throws Exception { + // Two CachedSchemaTransactionV2 instances in the same JVM must share + // the JVM-global meta listener: only ONE underlying watch should be + // installed even if listenSchemaCacheClear() is invoked multiple + // times. We assert this directly against the MetaDriver mock. + MetaDriver mockDriver = Mockito.mock(MetaDriver.class); + GraphMetaManager mockGraphMgr = + new GraphMetaManager(mockDriver, "test-cluster"); + + AtomicBoolean flag = metaListenerFlag(); + boolean previousFlag = flag.getAndSet(false); + MetaDriver originalDriver = swapMetaDriver(mockDriver); + Object originalGraphMgr = swapGraphMetaManager(mockGraphMgr); + try { + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + "listenSchemaCacheClear"); + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + "listenSchemaCacheClear"); + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + "listenSchemaCacheClear"); + + ArgumentCaptor captor = + ArgumentCaptor.forClass(Consumer.class); + Mockito.verify(mockDriver, Mockito.times(1)) + .listen(Mockito.anyString(), captor.capture()); + Assert.assertNotNull("registered consumer must not be null", + captor.getValue()); + Assert.assertTrue("flag must be set after successful registration", + flag.get()); + } finally { + flag.set(previousFlag); + swapMetaDriver(originalDriver); + swapGraphMetaManager(originalGraphMgr); + } + } + + @Test + @SuppressWarnings({"rawtypes", "unchecked"}) + public void testListenSchemaCacheClearEndToEnd() throws Exception { + // Full publish -> callback -> clear path: register the listener via + // the production code, capture the consumer that was wired into the + // MetaDriver, then invoke it as the watch would and assert the V2 + // caches for the named graph are cleared. + String graphName = "DEFAULT-end-to-end-v2"; + Cache idCache = + CacheManager.instance().cache("schema-id-" + graphName, 10L); + Cache nameCache = + CacheManager.instance() + .cache("schema-name-" + graphName, 10L); + + MetaDriver mockDriver = Mockito.mock(MetaDriver.class); + Object response = new Object(); + Mockito.when(mockDriver.extractValuesFromResponse(response)) + .thenReturn(Collections.singletonList(graphName)); + GraphMetaManager mockGraphMgr = + new GraphMetaManager(mockDriver, "test-cluster"); + + AtomicBoolean flag = metaListenerFlag(); + boolean previousFlag = flag.getAndSet(false); + MetaDriver originalDriver = swapMetaDriver(mockDriver); + Object originalGraphMgr = swapGraphMetaManager(mockGraphMgr); + try { + idCache.update(IdGenerator.of(1), "v"); + nameCache.update(IdGenerator.of("n"), "v"); + Assert.assertEquals(1L, idCache.size()); + Assert.assertEquals(1L, nameCache.size()); + + Whitebox.invokeStatic(CachedSchemaTransactionV2.class, + "listenSchemaCacheClear"); + + ArgumentCaptor captor = + ArgumentCaptor.forClass(Consumer.class); + Mockito.verify(mockDriver) + .listen(Mockito.anyString(), captor.capture()); + + // Simulate the meta server publishing a schema-cache-clear event: + // invoke the consumer captured above with a synthetic response. + captor.getValue().accept(response); + + Assert.assertEquals(0L, idCache.size()); + Assert.assertEquals(0L, nameCache.size()); + } finally { + flag.set(previousFlag); + swapMetaDriver(originalDriver); + swapGraphMetaManager(originalGraphMgr); + idCache.clear(); + nameCache.clear(); + } + } + + private static AtomicBoolean metaListenerFlag() throws Exception { + Field f = CachedSchemaTransactionV2.class + .getDeclaredField("metaEventListenerRegistered"); + f.setAccessible(true); + return (AtomicBoolean) f.get(null); + } + + private static String schemaCacheClearSource() throws Exception { + Field f = CachedSchemaTransactionV2.class + .getDeclaredField("SCHEMA_CACHE_CLEAR_SOURCE"); + f.setAccessible(true); + return (String) f.get(null); + } + + private static MetaDriver swapMetaDriver(MetaDriver replacement) + throws Exception { + Field f = MetaManager.class.getDeclaredField("metaDriver"); + f.setAccessible(true); + MetaDriver previous = (MetaDriver) f.get(MetaManager.instance()); + f.set(MetaManager.instance(), replacement); + return previous; + } + + private static Object swapGraphMetaManager(Object replacement) + throws Exception { + Field f = MetaManager.class.getDeclaredField("graphMetaManager"); + f.setAccessible(true); + Object previous = f.get(MetaManager.instance()); + f.set(MetaManager.instance(), replacement); + return previous; + } + + private static CacheNotifier newSchemaCacheNotifier(EventHub hub, + CacheNotifier proxy) + throws Exception { + Class clazz = Class.forName("org.apache.hugegraph." + + "StandardHugeGraph$" + + "HugeSchemaCacheNotifier"); + Constructor constructor = clazz.getDeclaredConstructor( + EventHub.class, CacheNotifier.class); + constructor.setAccessible(true); + return (CacheNotifier) constructor.newInstance(hub, proxy); + } + + private static CacheNotifier newCacheNotifier(AtomicInteger invalidCalls, + AtomicInteger invalid2Calls, + AtomicInteger clearCalls) { + return new CacheNotifier() { + + @Override + public void invalid(HugeType type, Id id) { + invalidCalls.incrementAndGet(); + } + + @Override + public void invalid2(HugeType type, Object[] ids) { + invalid2Calls.incrementAndGet(); + } + + @Override + public void clear(HugeType type) { + clearCalls.incrementAndGet(); + } + + @Override + public void reload() { + // pass + } + + @Override + public void close() { + // pass + } + }; + } + + @SuppressWarnings("unchecked") + private static T readField(Object target, String name) + throws ReflectiveOperationException { + Field field = target.getClass().getDeclaredField(name); + field.setAccessible(true); + return (T) field.get(target); + } + + private static void assertIntObjectMapEmpty(Object intMap, String label) + throws ReflectiveOperationException { + Object array = readField(intMap, "array"); + if (array instanceof Object[]) { + for (Object slot : (Object[]) array) { + Assert.assertNull(label + " slot must be null after clear", + slot); + } + return; + } + // Older IntObjectMap implementations expose a size accessor instead + // of a raw array; fall back to that if reflection finds no array. + Object size = Whitebox.invoke(intMap.getClass(), "size", intMap); + Assert.assertEquals(label + " must report size 0 after clear", + 0, ((Number) size).intValue()); + } + @Test public void testResetCachedAllIfReachedCapacity() throws Exception { CachedSchemaTransaction cache = this.cache(); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cassandra/CassandraTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cassandra/CassandraTest.java index ef5a8e896b..6445fc38bd 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cassandra/CassandraTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/cassandra/CassandraTest.java @@ -17,11 +17,15 @@ package org.apache.hugegraph.unit.cassandra; +import java.net.InetSocketAddress; +import java.util.Collections; import java.util.Map; import org.apache.commons.configuration2.Configuration; import org.apache.commons.configuration2.PropertiesConfiguration; +import org.apache.hugegraph.backend.BackendException; import org.apache.hugegraph.backend.store.cassandra.CassandraOptions; +import org.apache.hugegraph.backend.store.cassandra.CassandraSessionPool; import org.apache.hugegraph.backend.store.cassandra.CassandraStore; import org.apache.hugegraph.config.HugeConfig; import org.apache.hugegraph.config.OptionSpace; @@ -30,7 +34,14 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; - +import org.mockito.Mockito; + +import com.datastax.driver.core.ResultSet; +import com.datastax.driver.core.ResultSetFuture; +import com.datastax.driver.core.SimpleStatement; +import com.datastax.driver.core.Statement; +import com.datastax.driver.core.exceptions.NoHostAvailableException; +import com.datastax.driver.core.exceptions.OperationTimedOutException; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; @@ -192,4 +203,235 @@ public void testParseReplicaWithNetworkTopologyStrategyAndDoubleReplica() { Whitebox.invokeStatic(CassandraStore.class, "parseReplica", config); }); } + + @Test + public void testReconnectOptionsHaveSensibleDefaults() { + // Runtime-reconnection options must exist with non-zero defaults so + // HugeGraph keeps running when Cassandra restarts (issue #2740). + Assert.assertEquals(1000L, (long) CassandraOptions + .CASSANDRA_RECONNECT_BASE_DELAY.defaultValue()); + Assert.assertEquals(10_000L, (long) CassandraOptions + .CASSANDRA_RECONNECT_MAX_DELAY.defaultValue()); + Assert.assertEquals(3, (int) CassandraOptions + .CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS.defaultValue()); + Assert.assertEquals(1000L, (long) CassandraOptions + .CASSANDRA_QUERY_RETRY_INTERVAL.defaultValue()); + } + + @Test + public void testReconnectOptionsAreOverridable() { + String base = CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(); + String max = CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY.name(); + String retries = CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS + .name(); + String interval = CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL.name(); + + Configuration conf = new PropertiesConfiguration(); + conf.setProperty(base, 500L); + conf.setProperty(max, 30_000L); + conf.setProperty(retries, 3); + conf.setProperty(interval, 1000L); + HugeConfig config = new HugeConfig(conf); + + Assert.assertEquals(500L, (long) config.get( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY)); + Assert.assertEquals(30_000L, (long) config.get( + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY)); + Assert.assertEquals(3, (int) config.get( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS)); + Assert.assertEquals(1000L, (long) config.get( + CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL)); + } + + @Test + public void testQueryRetryAttemptsCanBeDisabled() { + String retries = CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS + .name(); + Configuration conf = new PropertiesConfiguration(); + conf.setProperty(retries, 0); + HugeConfig config = new HugeConfig(conf); + Assert.assertEquals(0, (int) config.get( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS)); + } + + @Test + public void testExecuteWithRetrySucceedsAfterTransientFailures() { + // Configure retry knobs via config so the pool reads them through + // the normal path (no Whitebox overrides on retry fields). Keep the + // values within the validators' lower bounds (base >= 100, max >= + // base, interval >= 100). + Configuration conf = new PropertiesConfiguration(); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(), 100L); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY.name(), 1000L); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS.name(), 3); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL.name(), 100L); + HugeConfig config = new HugeConfig(conf); + CassandraSessionPool pool = new CassandraSessionPool(config, + "ks", "store"); + + com.datastax.driver.core.Session driverSession = Mockito.mock( + com.datastax.driver.core.Session.class); + ResultSet rs = Mockito.mock(ResultSet.class); + NoHostAvailableException transientFailure = + new NoHostAvailableException(Collections.emptyMap()); + Mockito.when(driverSession.execute(Mockito.any(Statement.class))) + .thenThrow(transientFailure) + .thenThrow(transientFailure) + .thenReturn(rs); + + CassandraSessionPool.Session session = pool.new Session(); + Whitebox.setInternalState(session, "session", driverSession); + + ResultSet result = session.execute("SELECT now() FROM system.local"); + Assert.assertSame(rs, result); + Mockito.verify(driverSession, Mockito.times(3)) + .execute(Mockito.any(Statement.class)); + Mockito.verify(driverSession, Mockito.never()).close(); + } + + @Test + public void testExecuteWithRetrySkipsNonIdempotentTimeoutRetry() { + Configuration conf = new PropertiesConfiguration(); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(), 100L); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY.name(), 1000L); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS.name(), 3); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL.name(), 100L); + HugeConfig config = new HugeConfig(conf); + CassandraSessionPool pool = new CassandraSessionPool(config, + "ks", "store"); + + com.datastax.driver.core.Session driverSession = Mockito.mock( + com.datastax.driver.core.Session.class); + OperationTimedOutException timeout = new OperationTimedOutException( + new InetSocketAddress("127.0.0.1", 9042)); + Mockito.when(driverSession.execute(Mockito.any(Statement.class))) + .thenThrow(timeout); + + CassandraSessionPool.Session session = pool.new Session(); + Whitebox.setInternalState(session, "session", driverSession); + + Assert.assertThrows(BackendException.class, () -> + session.execute("UPDATE counter SET value = value + 1")); + Mockito.verify(driverSession, Mockito.times(1)) + .execute(Mockito.any(Statement.class)); + } + + @Test + public void testExecuteWithRetryAllowsIdempotentTimeoutRetry() { + Configuration conf = new PropertiesConfiguration(); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(), 100L); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY.name(), 1000L); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS.name(), 3); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL.name(), 100L); + HugeConfig config = new HugeConfig(conf); + CassandraSessionPool pool = new CassandraSessionPool(config, + "ks", "store"); + + com.datastax.driver.core.Session driverSession = Mockito.mock( + com.datastax.driver.core.Session.class); + ResultSet rs = Mockito.mock(ResultSet.class); + OperationTimedOutException timeout = new OperationTimedOutException( + new InetSocketAddress("127.0.0.1", 9042)); + SimpleStatement statement = new SimpleStatement( + "SELECT now() FROM system.local"); + statement.setIdempotent(true); + Mockito.when(driverSession.execute(statement)) + .thenThrow(timeout) + .thenReturn(rs); + + CassandraSessionPool.Session session = pool.new Session(); + Whitebox.setInternalState(session, "session", driverSession); + + ResultSet result = session.execute(statement); + Assert.assertSame(rs, result); + Mockito.verify(driverSession, Mockito.times(2)).execute(statement); + } + + @Test + public void testCommitAsyncOpensSessionBeforeExecuteAsync() { + Configuration conf = new PropertiesConfiguration(); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(), 100L); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY.name(), 1000L); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS.name(), 3); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL.name(), 100L); + HugeConfig config = new HugeConfig(conf); + CassandraSessionPool pool = new CassandraSessionPool(config, + "ks", "store"); + + com.datastax.driver.core.Cluster mockCluster = Mockito.mock( + com.datastax.driver.core.Cluster.class); + com.datastax.driver.core.Session driverSession = Mockito.mock( + com.datastax.driver.core.Session.class); + ResultSetFuture future = Mockito.mock(ResultSetFuture.class); + Mockito.when(mockCluster.isClosed()).thenReturn(false); + Mockito.when(mockCluster.connect(Mockito.anyString())) + .thenReturn(driverSession); + Mockito.when(driverSession.executeAsync(Mockito.any(Statement.class))) + .thenReturn(future); + Whitebox.setInternalState(pool, "cluster", mockCluster); + + CassandraSessionPool.Session session = pool.new Session(); + Statement statement = new SimpleStatement( + "INSERT INTO system.local(key) VALUES ('test')"); + session.add(statement); + + session.commitAsync(); + + Mockito.verify(mockCluster, Mockito.times(1)).connect("ks"); + Mockito.verify(driverSession, Mockito.times(1)).executeAsync(statement); + Mockito.verify(future, Mockito.times(1)).getUninterruptibly(); + Assert.assertFalse(session.hasChanges()); + } + + @Test + public void testReconnectBaseDelayBelowMinimumRejected() { + // The validator on CASSANDRA_RECONNECT_BASE_DELAY is + // rangeInt(100L, Long.MAX_VALUE); values below 100 must be rejected + // at parse time. Setting the property as a String forces HugeConfig + // to run parseConvert() which invokes the range check. + Configuration conf = new PropertiesConfiguration(); + Assert.assertThrows(Exception.class, () -> { + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(), + "50"); + new HugeConfig(conf); + }); + } + + @Test + public void testReconnectMaxDelayLessThanBaseRejected() { + // Both values must pass their individual range validators with margin + // (base >= 100, max >= 1000), so the only thing that can throw is the + // E.checkArgument(max >= base) cross-check inside the pool ctor. Set + // all four retry/reconnect properties explicitly so the test does not + // depend on default values changing in CassandraOptions. + Configuration conf = new PropertiesConfiguration(); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_BASE_DELAY.name(), 10_000L); + conf.setProperty( + CassandraOptions.CASSANDRA_RECONNECT_MAX_DELAY.name(), 2_000L); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_MAX_ATTEMPTS.name(), 3); + conf.setProperty( + CassandraOptions.CASSANDRA_QUERY_RETRY_INTERVAL.name(), 1_000L); + HugeConfig config = new HugeConfig(conf); + Assert.assertThrows(IllegalArgumentException.class, () -> + new CassandraSessionPool(config, "ks", "store")); + } } diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionQueryFlattenTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionQueryFlattenTest.java index 627dcb29aa..64833a3f70 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionQueryFlattenTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionQueryFlattenTest.java @@ -256,5 +256,127 @@ public void testFlattenWithNotIn() { Collection actual = queries.iterator().next().conditions(); Assert.assertEquals(expect, actual); } + + @Test + public void testFlattenWithBooleanRangeUpperBound() { + Id key = IdGenerator.of("c1"); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + query.query(Condition.lt(key, true)); + query.query(Condition.lt(key, false)); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(1, queries.size()); + + Collection actual = queries.iterator().next().conditions(); + Assert.assertEquals(ImmutableList.of(Condition.lt(key, false)), actual); + } + + @Test + public void testFlattenWithBooleanRangeWindow() { + Id key = IdGenerator.of("c1"); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + query.query(Condition.gte(key, false)); + query.query(Condition.lt(key, true)); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(1, queries.size()); + + Collection actual = queries.iterator().next().conditions(); + Assert.assertEquals(ImmutableList.of(Condition.gte(key, false), + Condition.lt(key, true)), actual); + } + + @Test + public void testFlattenWithConflictingBooleanRange() { + Id key = IdGenerator.of("c1"); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + query.query(Condition.gt(key, false).and(Condition.lt(key, true))); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(0, queries.size()); + } + + @Test + public void testFlattenWithImpossibleInInsideAnd() { + Id key = IdGenerator.of("c1"); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + query.query(Condition.in(key, ImmutableList.of()) + .and(Condition.eq(key, true))); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(0, queries.size()); + } + + @Test + public void testFlattenWithImpossibleInInsideOr() { + Id key = IdGenerator.of("c1"); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + Condition eq = Condition.eq(key, true); + query.query(Condition.in(key, ImmutableList.of()).or(eq)); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(1, queries.size()); + + Collection actual = queries.iterator().next().conditions(); + Assert.assertEquals(ImmutableList.of(eq), actual); + } + + @Test + public void testFlattenWithImpossibleInInsideOrRight() { + Id key = IdGenerator.of("c1"); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + Condition eq = Condition.eq(key, true); + query.query(eq.or(Condition.in(key, ImmutableList.of()))); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(1, queries.size()); + + Collection actual = queries.iterator().next().conditions(); + Assert.assertEquals(ImmutableList.of(eq), actual); + } + + @Test + public void testFlattenWithImpossibleInInsideNestedAndOverOr() { + Id leftKey = IdGenerator.of("c1"); + Id rightKey = IdGenerator.of("c2"); + + Condition left = Condition.in(leftKey, ImmutableList.of()) + .or(Condition.eq(leftKey, "a")); + Condition right = Condition.eq(rightKey, "b"); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + query.query(left.and(right)); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(1, queries.size()); + + Collection actual = queries.iterator().next().conditions(); + Assert.assertEquals(ImmutableList.of(Condition.eq(leftKey, "a"), + right), actual); + } + + @Test + public void testFlattenWithConflictingNumericRangeKeepsQuery() { + Id key = IdGenerator.of("c1"); + + Condition gt = Condition.gt(key, 10); + Condition eq = Condition.eq(key, 9); + + ConditionQuery query = new ConditionQuery(HugeType.VERTEX); + query.query(gt); + query.query(eq); + + List queries = ConditionQueryFlatten.flatten(query); + Assert.assertEquals(1, queries.size()); + + Collection actual = queries.iterator().next().conditions(); + Assert.assertEquals(ImmutableList.of(gt, eq), actual); + } } diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionTest.java index e333c7a98b..ba4b09dcab 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ConditionTest.java @@ -293,6 +293,38 @@ public void testConditionLte() { }); } + @Test + public void testConditionBooleanRange() { + Condition lt = Condition.lt(HugeKeys.ID, true); + Assert.assertTrue(lt.test(false)); + Assert.assertFalse(lt.test(true)); + + Condition lte = Condition.lte(HugeKeys.ID, false); + Assert.assertTrue(lte.test(false)); + Assert.assertFalse(lte.test(true)); + + Condition gt = Condition.gt(HugeKeys.ID, false); + Assert.assertTrue(gt.test(true)); + Assert.assertFalse(gt.test(false)); + + Condition gte = Condition.gte(HugeKeys.ID, true); + Assert.assertTrue(gte.test(true)); + Assert.assertFalse(gte.test(false)); + + Assert.assertThrows(IllegalArgumentException.class, () -> { + Condition.lt(HugeKeys.ID, true).test(1); + }, e -> { + String err = "Can't compare between 1(Integer) and true(Boolean)"; + Assert.assertEquals(err, e.getMessage()); + }); + Assert.assertThrows(IllegalArgumentException.class, () -> { + Condition.lt(HugeKeys.ID, true).test((Object) null); + }, e -> { + String err = "Can't compare between null(null) and true(Boolean)"; + Assert.assertEquals(err, e.getMessage()); + }); + } + @Test public void testConditionNeq() { Condition c1 = Condition.neq(HugeKeys.ID, 123); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/QueryTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/QueryTest.java index 88b161d32a..7d48084dbf 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/QueryTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/QueryTest.java @@ -17,8 +17,10 @@ package org.apache.hugegraph.unit.core; +import org.apache.hugegraph.backend.id.Id; import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.backend.query.Aggregate.AggregateFunc; +import org.apache.hugegraph.backend.query.Condition; import org.apache.hugegraph.backend.query.ConditionQuery; import org.apache.hugegraph.backend.query.IdPrefixQuery; import org.apache.hugegraph.backend.query.IdQuery; @@ -30,6 +32,7 @@ import org.apache.hugegraph.type.define.HugeKeys; import org.junit.Test; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -45,6 +48,53 @@ public void testOrderBy() { query.orders()); } + @Test + public void testConditionWithEqAndIn() { + Id label1 = IdGenerator.of(1); + Id label2 = IdGenerator.of(2); + + ConditionQuery query = new ConditionQuery(HugeType.EDGE); + query.eq(HugeKeys.LABEL, label1); + query.query(Condition.in(HugeKeys.LABEL, + ImmutableList.of(label1, label2))); + + Assert.assertEquals(label1, query.condition(HugeKeys.LABEL)); + } + + @Test + public void testConditionWithConflictingEqAndIn() { + Id label1 = IdGenerator.of(1); + Id label2 = IdGenerator.of(2); + Id label3 = IdGenerator.of(3); + + ConditionQuery query = new ConditionQuery(HugeType.EDGE); + query.eq(HugeKeys.LABEL, label1); + query.eq(HugeKeys.LABEL, label2); + query.query(Condition.in(HugeKeys.LABEL, + ImmutableList.of(label1, label3))); + + Assert.assertNull(query.condition(HugeKeys.LABEL)); + } + + @Test + public void testConditionWithMultipleMatchedInValues() { + Id label1 = IdGenerator.of(1); + Id label2 = IdGenerator.of(2); + Id label3 = IdGenerator.of(3); + Id label4 = IdGenerator.of(4); + + ConditionQuery query = new ConditionQuery(HugeType.EDGE); + query.query(Condition.in(HugeKeys.LABEL, + ImmutableList.of(label1, label2, label3))); + query.query(Condition.in(HugeKeys.LABEL, + ImmutableList.of(label1, label2, label4))); + + Assert.assertThrows(IllegalStateException.class, + () -> query.condition(HugeKeys.LABEL), + e -> Assert.assertContains("Illegal key 'LABEL'", + e.getMessage())); + } + @Test public void testToString() { Query query = new Query(HugeType.VERTEX); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/SchemaElementTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/SchemaElementTest.java new file mode 100644 index 0000000000..9853af107e --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/SchemaElementTest.java @@ -0,0 +1,273 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.core; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.SchemaElement; +import org.apache.hugegraph.schema.Userdata; +import org.apache.hugegraph.schema.VertexLabel; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.type.define.Cardinality; +import org.apache.hugegraph.type.define.DataType; +import org.apache.hugegraph.unit.FakeObjects; +import org.apache.hugegraph.util.DateUtil; +import org.junit.Test; + +public class SchemaElementTest { + + private static SchemaElement newSchema() { + return new PropertyKey(null, IdGenerator.of(1L), "test"); + } + + @Test + public void testSingleSetterNormalizesCreateTimeStringToDate() { + SchemaElement schema = newSchema(); + String formatted = "2026-05-14 10:11:12.345"; + + schema.userdata(Userdata.CREATE_TIME, formatted); + + Object value = schema.userdata().get(Userdata.CREATE_TIME); + Assert.assertTrue("CREATE_TIME should be a Date, was " + + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(DateUtil.parse(formatted), value); + } + + @Test + public void testSingleSetterKeepsCreateTimeDateUnchanged() { + SchemaElement schema = newSchema(); + Date now = DateUtil.now(); + + schema.userdata(Userdata.CREATE_TIME, now); + + Assert.assertSame(now, schema.userdata().get(Userdata.CREATE_TIME)); + } + + @Test + public void testSingleSetterRejectsInvalidCreateTimeString() { + SchemaElement schema = newSchema(); + + Assert.assertThrows(IllegalArgumentException.class, () -> { + schema.userdata(Userdata.CREATE_TIME, "not-a-date"); + }, e -> { + Assert.assertContains(Userdata.CREATE_TIME, e.getMessage()); + Assert.assertContains("not-a-date", e.getMessage()); + Assert.assertNotNull(e.getCause()); + }); + } + + @Test + public void testSingleSetterRejectsNullCreateTime() { + SchemaElement schema = newSchema(); + + Assert.assertThrows(IllegalArgumentException.class, () -> { + schema.userdata(Userdata.CREATE_TIME, null); + }, e -> { + Assert.assertContains("userdata value", e.getMessage()); + }); + } + + @Test + public void testSingleSetterPassesThroughBlankCreateTime() { + // "" is the key-only placeholder for the eliminate()/DELETE builder + // flow (.userdata(CREATE_TIME, "").eliminate()); it must not be parsed. + SchemaElement schema = newSchema(); + + schema.userdata(Userdata.CREATE_TIME, ""); + + Object value = schema.userdata().get(Userdata.CREATE_TIME); + Assert.assertEquals("", value); + } + + @Test + public void testSingleSetterLeavesOtherStringKeysUntouched() { + SchemaElement schema = newSchema(); + + schema.userdata("note", "2026-05-14 10:11:12.345"); + + Object value = schema.userdata().get("note"); + Assert.assertTrue(value instanceof String); + Assert.assertEquals("2026-05-14 10:11:12.345", value); + } + + @Test + public void testUserdataConstructorNormalizesCreateTimeString() { + String formatted = "2026-05-14 10:11:12.345"; + Map map = new HashMap<>(); + map.put(Userdata.CREATE_TIME, formatted); + + Userdata userdata = new Userdata(map); + + Object createTime = userdata.get(Userdata.CREATE_TIME); + Assert.assertTrue(createTime instanceof Date); + Assert.assertEquals(DateUtil.parse(formatted), + createTime); + } + + @Test + public void testUserdataConstructorLeavesOtherEntriesUntouched() { + Map map = new HashMap<>(); + map.put("note", "2026-05-14 10:11:12.345"); + map.put("count", 42); + + Userdata userdata = new Userdata(map); + + Assert.assertEquals("2026-05-14 10:11:12.345", + userdata.get("note")); + Assert.assertEquals(42, userdata.get("count")); + } + + @Test + public void testUserdataConstructorRejectsInvalidCreateTimeString() { + Map map = new HashMap<>(); + map.put(Userdata.CREATE_TIME, "not-a-date"); + + Assert.assertThrows(IllegalArgumentException.class, () -> { + new Userdata(map); + }, e -> { + Assert.assertContains(Userdata.CREATE_TIME, e.getMessage()); + Assert.assertContains("not-a-date", e.getMessage()); + Assert.assertNotNull(e.getCause()); + }); + } + + @Test + public void testBulkSetterNormalizesCreateTimeAndKeepsOtherEntries() { + SchemaElement schema = newSchema(); + Userdata bulk = new Userdata(); + String formatted = "2026-05-14 10:11:12.345"; + bulk.put(Userdata.CREATE_TIME, formatted); + bulk.put("note", "hello"); + bulk.put("count", 42); + + schema.userdata(bulk); + + Object createTime = schema.userdata().get(Userdata.CREATE_TIME); + Assert.assertTrue(createTime instanceof Date); + Assert.assertEquals(DateUtil.parse(formatted), createTime); + Assert.assertEquals("hello", schema.userdata().get("note")); + Assert.assertEquals(42, schema.userdata().get("count")); + } + + @Test + public void testBulkSetterKeepsCreateTimeDateUnchanged() { + SchemaElement schema = newSchema(); + Userdata bulk = new Userdata(); + Date now = DateUtil.now(); + bulk.put(Userdata.CREATE_TIME, now); + + schema.userdata(bulk); + + Assert.assertSame(now, schema.userdata().get(Userdata.CREATE_TIME)); + } + + @Test + public void testVertexLabelFromMapNormalizesCreateTimeString() { + String formatted = "2026-05-14 10:11:12.345"; + Map userdata = new HashMap<>(); + userdata.put(Userdata.CREATE_TIME, formatted); + + Map map = new HashMap<>(); + map.put(VertexLabel.P.ID, 1); + map.put(VertexLabel.P.NAME, "person"); + map.put(VertexLabel.P.USERDATA, userdata); + + VertexLabel vertexLabel = VertexLabel.fromMap(map, + new FakeObjects().graph()); + + Object createTime = vertexLabel.userdata().get(Userdata.CREATE_TIME); + Assert.assertTrue(createTime instanceof Date); + Assert.assertEquals(DateUtil.parse(formatted), + createTime); + } + + @Test + public void testPropertyKeyFromMapNormalizesDateDefaultValue() { + String formatted = "2026-05-14 10:11:12.345"; + Map userdata = new HashMap<>(); + userdata.put(Userdata.DEFAULT_VALUE, formatted); + + Map map = new HashMap<>(); + map.put(PropertyKey.P.ID, 1); + map.put(PropertyKey.P.NAME, "birth"); + map.put(PropertyKey.P.DATA_TYPE, DataType.DATE.string()); + map.put(PropertyKey.P.CARDINALITY, Cardinality.SINGLE.string()); + map.put(PropertyKey.P.USERDATA, userdata); + + PropertyKey propertyKey = PropertyKey.fromMap(map, + new FakeObjects().graph()); + + Object value = propertyKey.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Date, was " + + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(DateUtil.parse(formatted), value); + } + + @Test + public void testPropertyKeyFromMapNormalizesDateSetDefaultValue() { + String first = "2026-05-14 10:11:12.345"; + String second = "2026-05-15 11:12:13.456"; + Map userdata = new HashMap<>(); + userdata.put(Userdata.DEFAULT_VALUE, Arrays.asList(first, second)); + + Map map = new HashMap<>(); + map.put(PropertyKey.P.ID, 1); + map.put(PropertyKey.P.NAME, "tags"); + map.put(PropertyKey.P.DATA_TYPE, DataType.DATE.string()); + map.put(PropertyKey.P.CARDINALITY, Cardinality.SET.string()); + map.put(PropertyKey.P.USERDATA, userdata); + + PropertyKey propertyKey = PropertyKey.fromMap(map, + new FakeObjects().graph()); + + Object value = propertyKey.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Collection, was " + + (value == null ? "null" : value.getClass()), + value instanceof Collection); + Collection values = (Collection) value; + Assert.assertEquals(2, values.size()); + for (Object element : values) { + Assert.assertTrue("each element should be a Date, was " + + (element == null ? "null" : element.getClass()), + element instanceof Date); + } + List expected = Arrays.asList(DateUtil.parse(first), + DateUtil.parse(second)); + Assert.assertTrue(values.containsAll(expected)); + } + + @Test + public void testBulkSetterRejectsNullUserdata() { + SchemaElement schema = newSchema(); + + Assert.assertThrows(IllegalArgumentException.class, () -> { + schema.userdata(null); + }, e -> { + Assert.assertContains("userdata", e.getMessage()); + }); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ServerInfoManagerTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ServerInfoManagerTest.java new file mode 100644 index 0000000000..85815bbc19 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/core/ServerInfoManagerTest.java @@ -0,0 +1,76 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.core; + +import java.util.concurrent.ExecutorService; + +import org.apache.hugegraph.HugeGraphParams; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.masterelection.GlobalMasterInfo; +import org.apache.hugegraph.task.ServerInfoManager; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.testutil.Whitebox; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; + +public class ServerInfoManagerTest { + + private ServerInfoManager sysGraphManager; + private ServerInfoManager hugegraphManager; + + @Before + public void setup() { + HugeGraphParams sysGraphParams = Mockito.mock(HugeGraphParams.class); + Mockito.when(sysGraphParams.spaceGraphName()) + .thenReturn("DEFAULT-~sys_graph"); + + HugeGraphParams hugegraphParams = Mockito.mock(HugeGraphParams.class); + Mockito.when(hugegraphParams.spaceGraphName()) + .thenReturn("DEFAULT-hugegraph"); + + ExecutorService executor = Mockito.mock(ExecutorService.class); + + this.sysGraphManager = new ServerInfoManager(sysGraphParams, executor); + this.hugegraphManager = new ServerInfoManager(hugegraphParams, executor); + } + + @Test + public void testSelfNodeIdScopedByGraphWithSameNodeId() { + GlobalMasterInfo nodeInfo = GlobalMasterInfo.master("server-1"); + + Whitebox.setInternalState(this.sysGraphManager, + "globalNodeInfo", nodeInfo); + Whitebox.setInternalState(this.hugegraphManager, + "globalNodeInfo", nodeInfo); + + Id sysGraphNodeId = this.sysGraphManager.selfNodeId(); + Id hugegraphNodeId = this.hugegraphManager.selfNodeId(); + + Assert.assertEquals("DEFAULT-~sys_graph/server-1", + sysGraphNodeId.asString()); + Assert.assertEquals("DEFAULT-hugegraph/server-1", + hugegraphNodeId.asString()); + Assert.assertFalse(sysGraphNodeId.equals(hugegraphNodeId)); + } + + @Test + public void testSelfNodeIdReturnsNullWhenNotInitialized() { + Assert.assertNull(this.sysGraphManager.selfNodeId()); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/jvector/JVectorPersistenceTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/jvector/JVectorPersistenceTest.java new file mode 100644 index 0000000000..632fbe6a9b --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/jvector/JVectorPersistenceTest.java @@ -0,0 +1,167 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.jvector; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.HashMap; +import java.util.Map; +import java.util.Random; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import io.github.jbellis.jvector.disk.ReaderSupplier; +import io.github.jbellis.jvector.disk.SimpleMappedReader; +import io.github.jbellis.jvector.graph.GraphIndexBuilder; +import io.github.jbellis.jvector.graph.GraphSearcher; +import io.github.jbellis.jvector.graph.MapRandomAccessVectorValues; +import io.github.jbellis.jvector.graph.OnHeapGraphIndex; +import io.github.jbellis.jvector.graph.RandomAccessVectorValues; +import io.github.jbellis.jvector.graph.SearchResult; +import io.github.jbellis.jvector.graph.disk.OnDiskGraphIndex; +import io.github.jbellis.jvector.util.Bits; +import io.github.jbellis.jvector.vector.VectorSimilarityFunction; +import io.github.jbellis.jvector.vector.VectorizationProvider; +import io.github.jbellis.jvector.vector.types.VectorFloat; +import io.github.jbellis.jvector.vector.types.VectorTypeSupport; + +/** + * Test JVector OnDiskGraphIndex persistence + */ +public class JVectorPersistenceTest { + + private static final VectorTypeSupport vts = + VectorizationProvider.getInstance().getVectorTypeSupport(); + private Path testDir; + private final int dimension = 128; + private final int vectorCount = 500; + + @Before + public void setup() throws IOException { + testDir = Files.createTempDirectory("jvector_test_"); + System.out.println("Test directory: " + testDir); + } + + @After + public void cleanup() throws IOException { + // Keep files for inspection, comment out to auto-delete + // Files.walk(testDir).sorted(Comparator.reverseOrder()) + // .forEach(p -> { try { Files.delete(p); } catch (Exception e) {} });System.out.println("\n[Files kept in: " + testDir + "]"); + } + + @Test + public void testPersistAndLoad() throws Exception { + //1. Build vectors in memory + System.out.println("\n=== Step 1: Build vectors ==="); + Map> vectorMap = new HashMap<>(); + Random random = new Random(42); + + for (int i = 0; i < vectorCount; i++) { + float[] data = new float[dimension]; + for (int j = 0; j < dimension; j++) { + data[j] = random.nextFloat(); + } + vectorMap.put(i, vts.createFloatVector(data)); + } + + RandomAccessVectorValues ravv = new MapRandomAccessVectorValues(vectorMap, dimension); + System.out.printf("Created %d vectors, dimension=%d%n", vectorCount, dimension); + + // 2. Build HNSW index (using existing API style from ServerVectorRuntime) + System.out.println("\n=== Step 2: Build HNSW index ==="); + GraphIndexBuilder builder = new GraphIndexBuilder( + ravv, + VectorSimilarityFunction.COSINE, + 16, // M + 100, // beamWidth + 1.2f, // neighborOverflow + 1.2f // alpha + ); + + OnHeapGraphIndex graph = builder.getGraph(); // 从 GraphIndexBuilder 获取 + int upperBound = graph.getIdUpperBound(); + + for (int i = 0; i < vectorCount; i++) { + builder.addGraphNode(i, ravv); + } + System.out.println("Graph size: " + builder.getGraph().size()); + + // 3. Persist to disk + System.out.println("\n=== Step 3: Persist to disk ==="); + Path indexPath = Files.createTempFile(testDir, "sift", ".inline"); + // write the index to disk with default options + builder.cleanup(); + OnDiskGraphIndex.write(builder.getGraph(), ravv, indexPath); + + System.out.println("Persisted to: " + indexPath); + + // 4. List generated files + System.out.println("\n=== Step 4: Generated files ==="); + Files.walk(testDir).filter(Files::isRegularFile) + .forEach(p -> { + try { + long size = Files.size(p); + System.out.printf("%s: %,d bytes (%.2f KB)%n", + p.getFileName(), size, size / 1024.0); + } catch (IOException e) { + e.printStackTrace(); + } + }); + + // 5. Load from disk + System.out.println("\n=== Step 5: Load from disk ==="); + ReaderSupplier readerSupplier = new SimpleMappedReader.Supplier(indexPath); + OnDiskGraphIndex diskIndex = OnDiskGraphIndex.load(readerSupplier); + + System.out.println("Loaded index:"); + System.out.println(" - size: " + diskIndex.size()); + System.out.println(" - dimension: " + diskIndex.getDimension()); + + // 6. Search test + System.out.println("\n=== Step 6: Search test ==="); + float[] queryData = new float[dimension]; + for (int i = 0; i < dimension; i++) { + queryData[i] = random.nextFloat(); + } + VectorFloat queryVector = vts.createFloatVector(queryData); + + // Get view for search + RandomAccessVectorValues diskView = diskIndex.getView(); + + SearchResult results = GraphSearcher.search( + queryVector, + 10, // topK + diskView, + VectorSimilarityFunction.COSINE, + diskIndex, + Bits.ALL + ); + + System.out.println("Top 10 results:"); + for (SearchResult.NodeScore ns : results.getNodes()) { + System.out.printf(" node=%d, score=%.4f%n", ns.node, ns.score); + } + + // Cleanup + readerSupplier.close(); + System.out.println("\n=== Test Complete ==="); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/rocksdb/RocksDBTableQueryByIdsTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/rocksdb/RocksDBTableQueryByIdsTest.java new file mode 100644 index 0000000000..26598ba497 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/rocksdb/RocksDBTableQueryByIdsTest.java @@ -0,0 +1,405 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.rocksdb; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.lang3.tuple.Pair; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.query.IdQuery; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumn; +import org.apache.hugegraph.backend.store.BackendEntry.BackendColumnIterator; +import org.apache.hugegraph.backend.store.rocksdb.RocksDBSessions; +import org.apache.hugegraph.backend.store.rocksdb.RocksDBTables; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.type.HugeType; +import org.junit.Before; +import org.junit.Test; +import org.rocksdb.RocksDBException; + +public class RocksDBTableQueryByIdsTest extends BaseRocksDBUnitTest { + + private static final String DATABASE = "db"; + + private TestVertexTable vertexTable; + private TestEdgeTable edgeOutTable; + private TestEdgeTable edgeInTable; + + @Override + @Before + public void setup() throws RocksDBException { + super.setup(); + this.vertexTable = new TestVertexTable(DATABASE); + this.edgeOutTable = new TestEdgeTable(true, DATABASE); + this.edgeInTable = new TestEdgeTable(false, DATABASE); + this.rocks.createTable(this.vertexTable.table()); + this.rocks.createTable(this.edgeOutTable.table()); + this.rocks.createTable(this.edgeInTable.table()); + } + + @Test + public void testVertexQueryByIdsWithAllExistingIds() { + Id id1 = IdGenerator.of("v1"); + Id id2 = IdGenerator.of("v2"); + Id id3 = IdGenerator.of("v3"); + + this.rocks.session().put(this.vertexTable.table(), id1.asBytes(), getBytes("value1")); + this.rocks.session().put(this.vertexTable.table(), id2.asBytes(), getBytes("value2")); + this.rocks.session().put(this.vertexTable.table(), id3.asBytes(), getBytes("value3")); + this.commit(); + + List ids = Arrays.asList(id1, id2, id3); + BackendColumnIterator iter = this.vertexTable.queryByIds(this.rocks.session(), ids); + + Map results = toResultMap(iter); + + Assert.assertEquals(3, results.size()); + Assert.assertEquals("value1", results.get("v1")); + Assert.assertEquals("value2", results.get("v2")); + Assert.assertEquals("value3", results.get("v3")); + } + + @Test + public void testVertexQueryByIdsWithExistingAndMissingIdsMixed() { + Id id1 = IdGenerator.of("v1"); + Id id2 = IdGenerator.of("v2"); + Id id3 = IdGenerator.of("v3"); + + this.rocks.session().put(this.vertexTable.table(), id1.asBytes(), getBytes("value1")); + this.rocks.session().put(this.vertexTable.table(), id3.asBytes(), getBytes("value3")); + this.commit(); + + List ids = Arrays.asList(id1, id2, id3); + BackendColumnIterator iter = this.vertexTable.queryByIds(this.rocks.session(), ids); + + Map results = toResultMap(iter); + + Assert.assertEquals(2, results.size()); + Assert.assertEquals("value1", results.get("v1")); + Assert.assertEquals("value3", results.get("v3")); + Assert.assertFalse(results.containsKey("v2")); + } + + @Test + public void testVertexQueryByIdsDuplicateIds() { + Id id1 = IdGenerator.of("v1"); + Id id2 = IdGenerator.of("v2"); + + this.rocks.session().put(this.vertexTable.table(), id1.asBytes(), getBytes("value1")); + this.rocks.session().put(this.vertexTable.table(), id2.asBytes(), getBytes("value2")); + this.commit(); + + // [id1, id2, id1] — non-consecutive duplicates must be preserved + List ids = Arrays.asList(id1, id2, id1); + BackendColumnIterator iter = this.vertexTable.queryByIds(this.rocks.session(), ids); + + List names = toColumnNames(iter); + + Assert.assertEquals(3, names.size()); + Assert.assertEquals("v1", names.get(0)); + Assert.assertEquals("v2", names.get(1)); + Assert.assertEquals("v1", names.get(2)); + } + + @Test + public void testEdgeOutQueryByIdsWithAllExistingIds() { + Id id1 = IdGenerator.of("e1"); + Id id2 = IdGenerator.of("e2"); + + this.rocks.session().put(this.edgeOutTable.table(), id1.asBytes(), getBytes("edge-value1")); + this.rocks.session().put(this.edgeOutTable.table(), id2.asBytes(), getBytes("edge-value2")); + this.commit(); + + List ids = Arrays.asList(id1, id2); + BackendColumnIterator iter = this.edgeOutTable.queryByIds(this.rocks.session(), ids); + + Map results = toResultMap(iter); + + Assert.assertEquals(2, results.size()); + Assert.assertEquals("edge-value1", results.get("e1")); + Assert.assertEquals("edge-value2", results.get("e2")); + } + + @Test + public void testEdgeInQueryByIdsWithAllExistingIds() { + Id id1 = IdGenerator.of("e1"); + Id id2 = IdGenerator.of("e2"); + + this.rocks.session().put(this.edgeInTable.table(), id1.asBytes(), getBytes("edge-value1")); + this.rocks.session().put(this.edgeInTable.table(), id2.asBytes(), getBytes("edge-value2")); + this.commit(); + + List ids = Arrays.asList(id1, id2); + BackendColumnIterator iter = this.edgeInTable.queryByIds(this.rocks.session(), ids); + + Map results = toResultMap(iter); + + Assert.assertEquals(2, results.size()); + Assert.assertEquals("edge-value1", results.get("e1")); + Assert.assertEquals("edge-value2", results.get("e2")); + } + + @Test + public void testVertexQueryByIdsFailsWhenHasChanges() { + Id id1 = IdGenerator.of("v1"); + Id id2 = IdGenerator.of("v2"); + + this.rocks.session().put(this.vertexTable.table(), id1.asBytes(), getBytes("value1")); + this.rocks.session().put(this.vertexTable.table(), id2.asBytes(), getBytes("value2")); + this.commit(); + + List ids = Arrays.asList(id1, id2); + RocksDBSessions.Session mockSession = new DelegatingSession(this.rocks.session()) { + @Override + public boolean hasChanges() { + return true; + } + }; + + Assert.assertThrows(IllegalStateException.class, () -> { + this.vertexTable.queryByIds(mockSession, ids); + }, e -> Assert.assertContains("Can't queryByIds()", e.getMessage())); + } + + @Test + public void testPublicQueryMultiIdsFails() { + Id id1 = IdGenerator.of("v1"); + Id id2 = IdGenerator.of("v2"); + + this.rocks.session().put(this.vertexTable.table(), id1.asBytes(), getBytes("value1")); + this.rocks.session().put(this.vertexTable.table(), id2.asBytes(), getBytes("value2")); + this.commit(); + + Set idSet = new LinkedHashSet<>(Arrays.asList(id1, id2)); + IdQuery query = new IdQuery(HugeType.VERTEX, idSet); + + RocksDBSessions.Session mockSession = new DelegatingSession(this.rocks.session()) { + @Override + public boolean hasChanges() { + return true; + } + }; + + Assert.assertThrows(IllegalStateException.class, () -> { + this.vertexTable.query(mockSession, query); + }, e -> Assert.assertContains("Can't queryByIds()", e.getMessage())); + } + + @Test + public void testPublicQuerySingleIdFails() { + Id id1 = IdGenerator.of("v1"); + + this.rocks.session().put(this.vertexTable.table(), id1.asBytes(), getBytes("value1")); + this.commit(); + + Set idSet = new LinkedHashSet<>(Arrays.asList(id1)); + IdQuery query = new IdQuery(HugeType.VERTEX, idSet); + + RocksDBSessions.Session mockSession = new DelegatingSession(this.rocks.session()) { + @Override + public boolean hasChanges() { + return true; + } + }; + + Assert.assertThrows(IllegalStateException.class, () -> { + this.vertexTable.query(mockSession, query); + }, e -> Assert.assertContains("Can't queryByIds()", e.getMessage())); + } + + private Map toResultMap(BackendColumnIterator iter) { + Map results = new HashMap<>(); + while (iter.hasNext()) { + BackendColumn col = iter.next(); + results.put(getString(col.name), getString(col.value)); + } + return results; + } + + private List toColumnNames(BackendColumnIterator iter) { + List names = new ArrayList<>(); + while (iter.hasNext()) { + names.add(getString(iter.next().name)); + } + return names; + } + + /** + * A session wrapper that delegates all operations to an underlying session. + * Subclasses can override specific methods for mocking purposes. + */ + private static class DelegatingSession extends RocksDBSessions.Session { + + private final RocksDBSessions.Session delegate; + + DelegatingSession(RocksDBSessions.Session delegate) { + this.delegate = delegate; + } + + @Override + public String dataPath() { + return this.delegate.dataPath(); + } + + @Override + public String walPath() { + return this.delegate.walPath(); + } + + @Override + public String property(String table, String property) { + return this.delegate.property(table, property); + } + + @Override + public Pair keyRange(String table) { + return this.delegate.keyRange(table); + } + + @Override + public void compactRange(String table) { + this.delegate.compactRange(table); + } + + @Override + public void put(String table, byte[] key, byte[] value) { + this.delegate.put(table, key, value); + } + + @Override + public void merge(String table, byte[] key, byte[] value) { + this.delegate.merge(table, key, value); + } + + @Override + public void increase(String table, byte[] key, byte[] value) { + this.delegate.increase(table, key, value); + } + + @Override + public void delete(String table, byte[] key) { + this.delegate.delete(table, key); + } + + @Override + public void deleteSingle(String table, byte[] key) { + this.delegate.deleteSingle(table, key); + } + + @Override + public void deletePrefix(String table, byte[] key) { + this.delegate.deletePrefix(table, key); + } + + @Override + public void deleteRange(String table, byte[] keyFrom, byte[] keyTo) { + this.delegate.deleteRange(table, keyFrom, keyTo); + } + + @Override + public byte[] get(String table, byte[] key) { + return this.delegate.get(table, key); + } + + @Override + public BackendColumnIterator get(String table, List keys) { + return this.delegate.get(table, keys); + } + + @Override + public BackendColumnIterator scan(String table) { + return this.delegate.scan(table); + } + + @Override + public BackendColumnIterator scan(String table, byte[] prefix) { + return this.delegate.scan(table, prefix); + } + + @Override + public BackendColumnIterator scan(String table, byte[] keyFrom, + byte[] keyTo, int scanType) { + return this.delegate.scan(table, keyFrom, keyTo, scanType); + } + + @Override + public Object commit() { + return this.delegate.commit(); + } + + @Override + public void rollback() { + this.delegate.rollback(); + } + + @Override + public boolean hasChanges() { + return this.delegate.hasChanges(); + } + + @Override + public void open() { + this.delegate.open(); + } + + @Override + public void close() { + this.delegate.close(); + } + } + + /** + * Subclass that exposes the protected queryByIds for testing. + */ + private static class TestVertexTable extends RocksDBTables.Vertex { + + public TestVertexTable(String database) { + super(database); + } + + @Override + public BackendColumnIterator queryByIds(RocksDBSessions.Session session, + Collection ids) { + return super.queryByIds(session, ids); + } + } + + /** + * Subclass that exposes the protected queryByIds for testing. + */ + private static class TestEdgeTable extends RocksDBTables.Edge { + + public TestEdgeTable(boolean out, String database) { + super(out, database); + } + + @Override + public BackendColumnIterator queryByIds(RocksDBSessions.Session session, + Collection ids) { + return super.queryByIds(session, ids); + } + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/BinarySerializerTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/BinarySerializerTest.java index 7a5aa44436..02d64bcc78 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/BinarySerializerTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/BinarySerializerTest.java @@ -17,15 +17,25 @@ package org.apache.hugegraph.unit.serializer; +import java.util.Arrays; +import java.util.Date; +import java.util.Set; + +import org.apache.hugegraph.backend.id.IdGenerator; import org.apache.hugegraph.backend.serializer.BinarySerializer; import org.apache.hugegraph.backend.store.BackendEntry; import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.Userdata; import org.apache.hugegraph.structure.HugeEdge; import org.apache.hugegraph.structure.HugeVertex; import org.apache.hugegraph.testutil.Assert; import org.apache.hugegraph.testutil.Whitebox; +import org.apache.hugegraph.type.define.Cardinality; +import org.apache.hugegraph.type.define.DataType; import org.apache.hugegraph.unit.BaseUnitTest; import org.apache.hugegraph.unit.FakeObjects; +import org.apache.hugegraph.util.DateUtil; import org.junit.Test; public class BinarySerializerTest extends BaseUnitTest { @@ -105,6 +115,75 @@ public void testVertexForPartition() { Assert.assertNull(ser.readVertex(edge.graph(), null)); } + @Test + public void testPropertyKeyUserdataCreateTimeRoundTripsAsDate() { + HugeConfig config = FakeObjects.newConfig(); + BinarySerializer ser = new BinarySerializer(config); + + FakeObjects objects = new FakeObjects(); + PropertyKey original = objects.newPropertyKey(IdGenerator.of(1L), + "name"); + Date created = DateUtil.parse("2026-05-14 10:11:12.345"); + original.userdata(Userdata.CREATE_TIME, created); + + BackendEntry entry = ser.writePropertyKey(original); + PropertyKey reloaded = ser.readPropertyKey(objects.graph(), entry); + + Object value = reloaded.userdata().get(Userdata.CREATE_TIME); + Assert.assertTrue("CREATE_TIME should be a Date after round-trip, " + + "was " + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(created, value); + } + + @Test + public void testPropertyKeyDefaultValueRoundTripsAsDate() { + HugeConfig config = FakeObjects.newConfig(); + BinarySerializer ser = new BinarySerializer(config); + + FakeObjects objects = new FakeObjects(); + PropertyKey original = objects.newPropertyKey(IdGenerator.of(1L), + "name", DataType.DATE); + Date defaultValue = DateUtil.parse("2026-05-14 10:11:12.345"); + original.userdata(Userdata.DEFAULT_VALUE, defaultValue); + + BackendEntry entry = ser.writePropertyKey(original); + PropertyKey reloaded = ser.readPropertyKey(objects.graph(), entry); + + Object value = reloaded.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Date after round-trip, " + + "was " + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(defaultValue, value); + } + + @Test + public void testPropertyKeySetDefaultValueRoundTripsAsDate() { + HugeConfig config = FakeObjects.newConfig(); + BinarySerializer ser = new BinarySerializer(config); + + FakeObjects objects = new FakeObjects(); + PropertyKey original = objects.newPropertyKey(IdGenerator.of(2L), + "tags", DataType.DATE); + original.cardinality(Cardinality.SET); + + String dateStr = "2026-05-14 10:11:12.345"; + Date expected = DateUtil.parse(dateStr); + // ArrayList with duplicates — what JSON deserialization produces + original.userdata(Userdata.DEFAULT_VALUE, Arrays.asList(dateStr, dateStr)); + + BackendEntry entry = ser.writePropertyKey(original); + PropertyKey reloaded = ser.readPropertyKey(objects.graph(), entry); + + Object value = reloaded.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Set after round-trip, was " + + (value == null ? "null" : value.getClass()), + value instanceof Set); + Set values = (Set) value; + Assert.assertEquals("duplicates must be collapsed", 1, values.size()); + Assert.assertTrue(values.contains(expected)); + } + @Test public void testEdgeForPartition() { BinarySerializer ser = new BinarySerializer(true, true, true); diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/TextSerializerTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/TextSerializerTest.java new file mode 100644 index 0000000000..4d55a9b046 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/TextSerializerTest.java @@ -0,0 +1,107 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.serializer; + +import java.util.Arrays; +import java.util.Date; +import java.util.Set; + +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.serializer.TextSerializer; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.schema.PropertyKey; +import org.apache.hugegraph.schema.Userdata; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.type.define.Cardinality; +import org.apache.hugegraph.type.define.DataType; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.apache.hugegraph.unit.FakeObjects; +import org.apache.hugegraph.util.DateUtil; +import org.junit.Test; + +public class TextSerializerTest extends BaseUnitTest { + + @Test + public void testPropertyKeyUserdataCreateTimeRoundTripsAsDate() { + HugeConfig config = FakeObjects.newConfig(); + TextSerializer ser = new TextSerializer(config); + + FakeObjects objects = new FakeObjects(); + PropertyKey original = objects.newPropertyKey(IdGenerator.of(1L), + "name"); + Date created = DateUtil.parse("2026-05-14 10:11:12.345"); + original.userdata(Userdata.CREATE_TIME, created); + + BackendEntry entry = ser.writePropertyKey(original); + PropertyKey reloaded = ser.readPropertyKey(objects.graph(), entry); + + Object value = reloaded.userdata().get(Userdata.CREATE_TIME); + Assert.assertTrue("CREATE_TIME should be a Date after round-trip, " + + "was " + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(created, value); + } + + @Test + public void testPropertyKeyDefaultValueRoundTripsAsDate() { + HugeConfig config = FakeObjects.newConfig(); + TextSerializer ser = new TextSerializer(config); + + FakeObjects objects = new FakeObjects(); + PropertyKey original = objects.newPropertyKey(IdGenerator.of(1L), + "name", DataType.DATE); + Date defaultValue = DateUtil.parse("2026-05-14 10:11:12.345"); + original.userdata(Userdata.DEFAULT_VALUE, defaultValue); + + BackendEntry entry = ser.writePropertyKey(original); + PropertyKey reloaded = ser.readPropertyKey(objects.graph(), entry); + + Object value = reloaded.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Date after round-trip, " + + "was " + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(defaultValue, value); + } + + @Test + public void testPropertyKeySetDefaultValueRoundTripsAsDate() { + HugeConfig config = FakeObjects.newConfig(); + TextSerializer ser = new TextSerializer(config); + + FakeObjects objects = new FakeObjects(); + PropertyKey original = objects.newPropertyKey(IdGenerator.of(2L), + "tags", DataType.DATE); + original.cardinality(Cardinality.SET); + + String dateStr = "2026-05-14 10:11:12.345"; + Date expected = DateUtil.parse(dateStr); + original.userdata(Userdata.DEFAULT_VALUE, Arrays.asList(dateStr, dateStr)); + + BackendEntry entry = ser.writePropertyKey(original); + PropertyKey reloaded = ser.readPropertyKey(objects.graph(), entry); + + Object value = reloaded.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Set after round-trip, was " + + (value == null ? "null" : value.getClass()), + value instanceof Set); + Set values = (Set) value; + Assert.assertEquals("duplicates must be collapsed", 1, values.size()); + Assert.assertTrue(values.contains(expected)); + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/VectorIndexSerializerTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/VectorIndexSerializerTest.java new file mode 100644 index 0000000000..e281bb4227 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/serializer/VectorIndexSerializerTest.java @@ -0,0 +1,199 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.serializer; + +import org.apache.hugegraph.HugeGraph; +import org.apache.hugegraph.backend.id.Id; +import org.apache.hugegraph.backend.id.IdGenerator; +import org.apache.hugegraph.backend.query.ConditionQuery; +import org.apache.hugegraph.backend.serializer.BinarySerializer; +import org.apache.hugegraph.backend.store.BackendEntry; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.schema.IndexLabel; +import org.apache.hugegraph.structure.HugeIndex; +import org.apache.hugegraph.structure.HugeVectorIndexMap; +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.type.HugeType; +import org.apache.hugegraph.type.define.DataType; +import org.apache.hugegraph.type.define.IdStrategy; +import org.apache.hugegraph.type.define.IndexType; +import org.apache.hugegraph.type.define.IndexVectorState; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.apache.hugegraph.unit.FakeObjects; +import org.junit.Test; +import org.mockito.Mockito; + +public class VectorIndexSerializerTest extends BaseUnitTest { + + @Test + public void testSequenceIdEncodeDecode() { + FakeObjects objects = new FakeObjects(); + HugeGraph graph = objects.graph(); + + // prepare minimal schema: one vertex label + one vector index + Id pkId = IdGenerator.of(1); + objects.newPropertyKey(pkId, "v", DataType.INT); + Id vlId = IdGenerator.of(2); + objects.newVertexLabel(vlId, "person", IdStrategy.CUSTOMIZE_NUMBER, pkId); + + Id ilId = IdGenerator.of(3); + IndexLabel il = objects.newIndexLabel(ilId, "vec-index", HugeType.VERTEX, + vlId, IndexType.VECTOR, pkId); + + HugeVectorIndexMap index = new HugeVectorIndexMap(graph, il, IndexVectorState.BUILDING); + long seq = 123L; + index.sequence(seq); + + Id seqId = index.sequenceId(); + byte[] raw = seqId.asBytes(); + + // parseSequenceId currently expects a specific layout; we just assert + // that it either succeeds and preserves label+sequence, or throws a + // well-formed IllegalArgumentException due to layout mismatch. + try { + HugeVectorIndexMap parsed = HugeVectorIndexMap.parseSequenceId(graph, raw); + Assert.assertEquals(il.id(), parsed.indexLabelId()); + Assert.assertEquals(seq, parsed.sequence()); + } catch (IllegalArgumentException e) { + // document current behaviour: layout check may fail + Assert.assertContains("Invalid sequence index id", e.getMessage()); + } + } + + @Test + public void testDirtyLabelIdEncoding() { + FakeObjects objects = new FakeObjects(); + HugeGraph graph = objects.graph(); + + Id pkId = IdGenerator.of(1); + objects.newPropertyKey(pkId, "v", DataType.INT); + Id vlId = IdGenerator.of(2); + objects.newVertexLabel(vlId, "person", IdStrategy.CUSTOMIZE_NUMBER, pkId); + + Id ilId = IdGenerator.of(3); + IndexLabel il = objects.newIndexLabel(ilId, "vec-index", HugeType.VERTEX, + vlId, IndexType.VECTOR, pkId); + + HugeVectorIndexMap index = new HugeVectorIndexMap(graph, il, IndexVectorState.BUILDING); + Id dirtyId = index.dirtyLabelId(); + byte[] bytes = dirtyId.asBytes(); + + // first byte should be DIRTY_PREFIX, next 4 bytes should be schemaId + Assert.assertEquals(IndexVectorState.DIRTY_PREFIX.code(), bytes[0]); + } + + @Test + public void testVectorIndexValueEncoding() { + HugeConfig config = FakeObjects.newConfig(); + BinarySerializer ser = new BinarySerializer(config); + + FakeObjects objects = new FakeObjects(); + HugeGraph graph = objects.graph(); + + Id pkId = IdGenerator.of(1); + objects.newPropertyKey(pkId, "v", DataType.INT); + Id vlId = IdGenerator.of(2); + objects.newVertexLabel(vlId, "person", IdStrategy.CUSTOMIZE_NUMBER, pkId); + + Id ilId = IdGenerator.of(3); + IndexLabel il = objects.newIndexLabel(ilId, "vec-index", HugeType.VERTEX_LABEL, + vlId, IndexType.VECTOR, pkId); + + HugeVectorIndexMap index = new HugeVectorIndexMap(graph, il, IndexVectorState.BUILDING); + long seq = 100L; + index.sequence(seq); + + index.fieldValues(42); //dummy vector id + index.elementIds(IdGenerator.of(5L)); //dummy vertex id + + BackendEntry entry = ser.writeIndex(index); + Assert.assertEquals(HugeType.VECTOR_INDEX_MAP, entry.type()); + Assert.assertEquals(1, entry.columnsSize()); + + byte[] value = entry.columns().iterator().next().value; + // first 8 bytes are sequence; last 1 byte is state code + long encodedSeq = java.nio.ByteBuffer.wrap(value, 0, 8).getLong(); + byte stateCode = value[8]; + + Assert.assertEquals(seq, encodedSeq); + Assert.assertEquals(IndexVectorState.BUILDING.code(), stateCode); + } + + @Test + public void testWriteAndReadVectorSequenceWithNumericVectorId() { + HugeConfig config = FakeObjects.newConfig(); + BinarySerializer ser = new BinarySerializer(config); + + FakeObjects objects = new FakeObjects(); + HugeGraph graph = objects.graph(); + + Id pkId = IdGenerator.of(1); + objects.newPropertyKey(pkId, "v", DataType.INT); + Id vlId = IdGenerator.of(2); + objects.newVertexLabel(vlId, "person", IdStrategy.CUSTOMIZE_NUMBER, pkId); + + Id ilId = IdGenerator.of(3); + IndexLabel il = objects.newIndexLabel(ilId, "vec-index", HugeType.VERTEX, + vlId, IndexType.VECTOR, pkId); + + HugeVectorIndexMap index = new HugeVectorIndexMap(graph, il, IndexVectorState.BUILDING); + index.fieldValues(42); // numeric vectorId so current implementation can cast + + BackendEntry seqEntry = ser.writeVectorSequence(index); + Assert.assertEquals(HugeType.VECTOR_SEQUENCE, seqEntry.type()); + + ConditionQuery query = Mockito.mock(ConditionQuery.class); + HugeVectorIndexMap read = ser.readVectorSequence(graph, query, seqEntry); + // if layout matches, these assertions hold; otherwise we at least smoke-test + Assert.assertNotNull(read); + } + + @Test + public void testUpdateVectorIndexUsesHashBytes() { + // This documents current behaviour: GraphIndexTransaction passes byte[] + // as fieldValues for vectorId, which is incompatible with the numeric + // assumption inside formatVectorSequenceName. + FakeObjects objects = new FakeObjects(); + HugeGraph graph = objects.graph(); + + Id pkId = IdGenerator.of(1); + objects.newPropertyKey(pkId, "v", DataType.INT); + Id vlId = IdGenerator.of(2); + objects.newVertexLabel(vlId, "person", IdStrategy.CUSTOMIZE_NUMBER, pkId); + + Id ilId = IdGenerator.of(3); + IndexLabel il = objects.newIndexLabel(ilId, "vec-index", HugeType.VERTEX, + vlId, IndexType.VECTOR, pkId); + + HugeVectorIndexMap index = new HugeVectorIndexMap(graph, il, IndexVectorState.BUILDING); + Class clazz = DataType.INT.clazz(); + index.fieldValues(HugeIndex.bytes2number(new byte[]{1, 2, 3, 4}, clazz)); + + HugeConfig config = FakeObjects.newConfig(); + BinarySerializer ser = new BinarySerializer(config); + + try { + ser.writeVectorSequence(index); + } catch (ClassCastException e) { + // Expected with current implementation; this highlights a type + // mismatch you may want to fix in production code. + Assert.assertTrue(e.getMessage() == null || e.getMessage().contains("java.lang.ClassCastException")); + } + } +} + diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/util/ConsumersTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/util/ConsumersTest.java new file mode 100644 index 0000000000..1bb152ec75 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/util/ConsumersTest.java @@ -0,0 +1,111 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.util; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicInteger; + +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.util.Consumers; +import org.junit.Test; + +public class ConsumersTest { + + @Test(timeout = 1000) + public void testStartProvideAwaitNormal() throws Throwable { + ExecutorService executor = Executors.newFixedThreadPool(2); + try { + AtomicInteger processed = new AtomicInteger(); + + Consumers consumers = new Consumers<>(executor, v -> { + processed.incrementAndGet(); + }); + + consumers.start("test"); + for (int i = 0; i < 50; i++) { + consumers.provide(i); + } + consumers.await(); + + Assert.assertEquals("Should process all provided elements", + 50, processed.get()); + } finally { + executor.shutdownNow(); + } + } + + /** + * Regression test for deadlock: + * + * ContextCallable fails before entering runAndDone(). + * await() must still return because latch is decremented in safeRun(). + */ + @Test(timeout = 1000) + public void testAwaitDoesNotHangWhenContextCallableFails() throws Throwable { + ExecutorService executor = Executors.newFixedThreadPool(1); + try { + // Use AssertionError to bypass the inner catch(Exception) loop in runAndDone() + // This simulates a scenario where an exception escapes the task logic + // (similar to how a ContextCallable failure would behave from safeRun's perspective) + Consumers consumers = new Consumers<>(executor, v -> { + throw new AssertionError("Simulated fatal error (OOM/StackOverflow/etc)"); + }); + consumers.start("test-fatal-error"); + consumers.provide(1); + // Verification: + // Without the fix, the latch would never be decremented (because runAndDone crashes), causing await() to hang. + // With the fix (safeRun wrapper), the finally block ensures latch.countDown() is called. + consumers.await(); + + // Note: consumer.exception will be null because safeRun only catches Exception, not Error. + // This is acceptable behavior for fatal errors, as long as it doesn't deadlock. + } finally { + executor.shutdownNow(); + } + } + + @Test(timeout = 1000) + public void testAwaitThrowsWhenConsumerThrows() throws Throwable { + ExecutorService executor = Executors.newFixedThreadPool(2); + try { + final String msg = "Injected exception for test"; + + Consumers consumers = new Consumers<>(executor, v -> { + throw new RuntimeException(msg); + }); + + consumers.start("test"); + consumers.provide(1); + + try { + consumers.await(); + Assert.fail("Expected await() to throw when consumer throws"); + } catch (Throwable t) { + Throwable root = t.getCause() != null ? t.getCause() : t; + Assert.assertTrue("Expected RuntimeException, but got: " + root, + root instanceof RuntimeException); + Assert.assertTrue("Exception message should contain injected message", + root.getMessage() != null && + root.getMessage().contains(msg)); + } + } finally { + executor.shutdownNow(); + } + } +} diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/util/StringEncodingTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/util/StringEncodingTest.java index 2d579c1dc4..39d18802b9 100644 --- a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/util/StringEncodingTest.java +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/util/StringEncodingTest.java @@ -23,6 +23,7 @@ import org.apache.hugegraph.util.Bytes; import org.apache.hugegraph.util.StringEncoding; import org.junit.Test; +import org.mindrot.jbcrypt.BCrypt; public class StringEncodingTest { @@ -180,4 +181,41 @@ public void testReadAsciiString() { buf = Bytes.fromHex("80"); Assert.assertEquals("", StringEncoding.readAsciiString(buf, 0)); } + + @Test + public void testCheckPasswordSupportsOldAndNewCost() { + String testPassword = "test123!@#"; + + // Test old work factor (4) + String oldPassword = BCrypt.hashpw(testPassword, BCrypt.gensalt(4)); + Assert.assertTrue(StringEncoding.checkPassword(testPassword, oldPassword)); + Assert.assertFalse(StringEncoding.checkPassword("wrong", oldPassword)); + + // Test new work factor (10) + String newPassword = BCrypt.hashpw(testPassword, BCrypt.gensalt(10)); + Assert.assertTrue(StringEncoding.checkPassword(testPassword, newPassword)); + Assert.assertFalse(StringEncoding.checkPassword("wrong", newPassword)); + + // Test that hashPassword uses the new cost factor + String hashedPassword = StringEncoding.hashPassword(testPassword); + Assert.assertTrue("Hash should contain work factor 10", + hashedPassword.matches("^\\$2[aby]\\$10\\$.*") + ); + + // Compare computational cost between work factor 4 and 10 + long start4 = System.nanoTime(); + StringEncoding.checkPassword(testPassword, oldPassword); + long elapsed4 = System.nanoTime() - start4; + + long start10 = System.nanoTime(); + StringEncoding.checkPassword(testPassword, hashedPassword); + long elapsed10 = System.nanoTime() - start10; + + // BCrypt cost difference: (10-4) = 6 => theoretical ~2^6 = 64x + Assert.assertTrue( + "Work factor 10 should be significantly slower than work factor 4 " + + "(expected exponential cost increase)", + elapsed10 >= elapsed4 * 32 + ); + } } diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/AbstractVectorRuntimeTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/AbstractVectorRuntimeTest.java new file mode 100644 index 0000000000..d3dd350f85 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/AbstractVectorRuntimeTest.java @@ -0,0 +1,262 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.vectorIndex; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Arrays; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.apache.hugegraph.vector.AbstractVectorRuntime; +import org.apache.hugegraph.vector.UpdatableRandomAccessVectorValues; +import org.apache.hugegraph.vector.VectorRecord; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import io.github.jbellis.jvector.graph.GraphIndexBuilder; +import io.github.jbellis.jvector.vector.VectorSimilarityFunction; +import io.github.jbellis.jvector.vector.VectorizationProvider; +import io.github.jbellis.jvector.vector.types.VectorFloat; +import io.github.jbellis.jvector.vector.types.VectorTypeSupport; + +/** + * Unit tests for AbstractVectorRuntime. + * Uses a concrete TestVectorRuntime to test the abstract class's public API. + */ +public class AbstractVectorRuntimeTest extends BaseUnitTest { + + private static final VectorTypeSupport vts = + VectorizationProvider.getInstance().getVectorTypeSupport(); + private static final int DIMENSION = 128; + + private Path testDir; + private TestVectorRuntime runtime; + + @Before + public void setup() throws IOException { + Path parent = Paths.get(""); + testDir = Files.createTempDirectory(parent, "abstract_vector_runtime_test_"); + runtime = new TestVectorRuntime(testDir.toString()); + } + + @After + public void cleanup() throws IOException { + if (testDir != null && Files.exists(testDir)) { + Files.walk(testDir) + .sorted(Comparator.reverseOrder()) + .forEach(p -> { + try { Files.delete(p); } catch (Exception e) { } + }); + } + } + + // ========== Lifecycle Tests ========== + + @Test + public void testInitAndStop() throws IOException { + runtime.init(); + runtime.stop(); + // No exception means success + } + + // ========== Watermark & Sequence Tests ========== + + @Test + public void testGetCurrentWaterMarkReturnsNegativeForNonexistent() { + long watermark = runtime.getCurrentWaterMark("nonexistent"); + Assert.assertEquals(-1L, watermark); + } + + @Test + public void testGetNextVectorIdReturnsNegativeForNonexistent() { + int vectorId = runtime.getNextVectorId("nonexistent"); + Assert.assertEquals(-1, vectorId); + } + + @Test + public void testGetNextSequenceReturnsNegativeForNonexistent() { + long sequence = runtime.getNextSequence("nonexistent"); + Assert.assertEquals(-1L, sequence); + } + + // ========== Update & Search Flow Tests ========== + + @Test + public void testUpdateWithBuildingRecords() { + + String indexLabelId = "testIndex"; + List records = Arrays.asList( + new VectorRecord(1, generateVector(DIMENSION), false, 1L), + new VectorRecord(2, generateVector(DIMENSION), false, 2L) + ); + + runtime.update(indexLabelId, records.iterator()); + + // test update the vector + Assert.assertTrue(runtime.checkVectorIdExists(indexLabelId, 1)); + Assert.assertTrue(runtime.checkVectorIdExists(indexLabelId, 2)); + } + + @Test + public void testUpdateWithDeletedRecords() { + String indexLabelId = "testIndex"; + + // First add records + List addRecords = Arrays.asList( + new VectorRecord(0, generateVector(DIMENSION), false, 1L) + ); + runtime.update(indexLabelId, addRecords.iterator()); + + // Then delete + List deleteRecords = Arrays.asList( + new VectorRecord(0, generateVector(DIMENSION), true, 2L) + ); + + runtime.update(indexLabelId, deleteRecords.iterator()); + // No exception means success + } + + @Test + public void testSearchReturnsIterator() { + String indexLabelId = "testIndex"; + // Initialize context by update + runtime.update(indexLabelId, Arrays.asList( + new VectorRecord(0, generateVector(DIMENSION), false, 1L) + ).iterator()); + + Iterator results = runtime.search(indexLabelId, generateVector(DIMENSION), 5); + Assert.assertNotNull(results); + } + + // ========== MetaData Tests ========== + + @Test + public void testIsUpdateMetaDataReturnsFalseInitially() { + String indexLabelId = "testIndex"; + runtime.update(indexLabelId, Arrays.asList().iterator()); + + Assert.assertFalse(runtime.isUpdateMetaData(indexLabelId)); + } + + @Test + public void testUpdateMetaDataChangesState() { + String indexLabelId = "testIndex"; + runtime.update(indexLabelId, Arrays.asList().iterator()); + + runtime.updateMetaData(indexLabelId, 100, 500L); + + Assert.assertTrue(runtime.isUpdateMetaData(indexLabelId)); + // getNextVectorId increments, so 100 -> 101 + Assert.assertEquals(101, runtime.getNextVectorId(indexLabelId)); + } + + @Test + public void testUpdateMetaDataOnNonexistentIndexDoesNothing() { + runtime.updateMetaData("nonexistent", 100, 500L); + // Should not throw, and nonexistent still returns -1 + Assert.assertEquals(-1, runtime.getNextVectorId("nonexistent")); + } + + // ========== Helper Methods ========== + + private float[] generateVector(int dimension) { + float[] vector = new float[dimension]; + for (int i = 0; i < dimension; i++) { + vector[i] = (float) Math.random(); + } + return vector; + } + + // ========== Test Implementation ========== + + /** + * Concrete implementation of AbstractVectorRuntime for testing. + * This simulates the runtime without requiring HugeGraphParams. + */ + static class TestVectorRuntime extends AbstractVectorRuntime { + + public TestVectorRuntime(String basePath) { + super(basePath); + this.basePath = basePath; + } + + @Override + public void update(String indexLabelId, Iterator records) { + // Ensure context exists + AbstractVectorRuntime.IndexContext context = obtainContext(indexLabelId); + while (records.hasNext()) { + VectorRecord record = records.next(); + if (record.isDeleted()) { + if (context.builder.getGraph().containsNode(record.getVectorId())) { + context.builder.markNodeDeleted(record.getVectorId()); + } + } else { + VectorFloat vector = vts.createFloatVector(record.getVectorData()); + context.vectors.addNode(record.getVectorId(), vector); + context.builder.addGraphNode(record.getVectorId(), vector); + } + } + } + + @Override + public Iterator search(String indexLabelId, float[] queryVector, int topK) { + // Simple implementation for testing + return java.util.Collections.emptyIterator(); + } + + @Override + public boolean isUpdateMetaData(String indexLabelId) { + AbstractVectorRuntime.IndexContext context = getContext(indexLabelId); + return context != null && context.metaData().isUpdateFromLog(); + } + + @Override + protected AbstractVectorRuntime.IndexContext createNewContext(String indexLabelId) { + Map> map = new HashMap<>(); + UpdatableRandomAccessVectorValues ravv = new UpdatableRandomAccessVectorValues(map, DIMENSION); + GraphIndexBuilder builder = new GraphIndexBuilder( + ravv, VectorSimilarityFunction.COSINE, 16, 100, 1.2f, 1.2f); + AbstractVectorRuntime.IndexContext context = + new AbstractVectorRuntime.IndexContext( + indexLabelId, ravv, builder, 0L, DIMENSION, VectorSimilarityFunction.COSINE); + vectorMap.put(indexLabelId, context); + return context; + } + + @Override + protected String idToString(String id) { + return id; + } + + public boolean checkVectorIdExists(String id, int vector) { + + + return this.vectorMap.get(id).builder.getGraph().containsNode(vector); + } + } +} + diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/VectorIndexManagerTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/VectorIndexManagerTest.java new file mode 100644 index 0000000000..aa594eaa11 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/VectorIndexManagerTest.java @@ -0,0 +1,296 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.vectorIndex; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.apache.hugegraph.vector.VectorIndexManager; +import org.apache.hugegraph.vector.VectorIndexRuntime; +import org.apache.hugegraph.vector.VectorIndexStateStore; +import org.apache.hugegraph.vector.VectorRecord; +import org.apache.hugegraph.vector.VectorTaskScheduler; +import org.junit.Before; +import org.junit.Test; + +/** + * Unit tests for VectorIndexManager. + * Tests the coordination between StateStore, Runtime, and Scheduler components. + */ +public class VectorIndexManagerTest extends BaseUnitTest { + + private MockVectorStateStore stateStore; + private MockVectorRuntime runtime; + private MockVectorScheduler scheduler; + private VectorIndexManager manager; + + @Before + public void setup() { + stateStore = new MockVectorStateStore(); + runtime = new MockVectorRuntime(); + scheduler = new MockVectorScheduler(); + manager = new VectorIndexManager<>(stateStore, runtime, scheduler); + } + + // ========== Lifecycle Tests ========== + + @Test + public void testInitCallsRuntimeInit() { + manager.init(); + Assert.assertTrue(runtime.initCalled); + } + + @Test + public void testStopCallsBothRuntimeAndStateStore() throws IOException { + manager.stop(); + Assert.assertTrue(runtime.stopCalled); + Assert.assertTrue(stateStore.stopCalled); + } + + // ========== Signal & ProcessIndex Flow Tests ========== + + @Test + public void testSignalSchedulesTask() { + manager.signal("indexLabel1"); + Assert.assertTrue(scheduler.taskExecuted); + Assert.assertEquals(1, scheduler.executedTaskCount); + } + + @Test + public void testSignalTriggersProcessIndexFlow() { + // Setup: stateStore has delta records, runtime has watermark + runtime.watermark = 10L; + stateStore.deltaRecords = Arrays.asList( + new VectorRecord(1, new float[]{1.0f}, false, 11L), + new VectorRecord(2, new float[]{2.0f}, false, 12L) + ); + + manager.signal("testIndex"); + + // Verify: runtime.update() was called with records from stateStore + Assert.assertTrue(runtime.updateCalled); + Assert.assertEquals("testIndex", runtime.lastUpdatedIndexLabelId); + } + + @Test + public void testSignalWithNegativeWatermarkStartsFromZero() { + runtime.watermark = -1L; // No existing watermark + stateStore.deltaRecords = Collections.singletonList( + new VectorRecord(0, new float[]{1.0f}, false, 1L) + ); + + manager.signal("newIndex"); + + Assert.assertTrue(runtime.updateCalled); + // Verify scanDeltas was called with fromSeq=0 + Assert.assertEquals(0L, stateStore.lastScanFromSeq); + } + + // ========== Search Flow Tests ========== + + @Test + public void testSearchVectorReturnsVertexIds() { + String indexLabelId = "testIndex"; + float[] queryVector = new float[]{1.0f, 2.0f, 3.0f}; + int topK = 5; + + // Setup: runtime returns vectorIds, stateStore maps to vertexIds + runtime.searchResults = Arrays.asList(1, 2, 3).iterator(); + stateStore.vertexIds = new HashSet<>(Arrays.asList("v1", "v2", "v3")); + + Set results = manager.searchVector(indexLabelId, queryVector, topK); + + Assert.assertNotNull(results); + Assert.assertEquals(3, results.size()); + Assert.assertTrue(results.containsAll(Arrays.asList("v1", "v2", "v3"))); + } + + @Test + public void testSearchVectorEmptyResults() { + runtime.searchResults = Collections.emptyIterator(); + stateStore.vertexIds = Collections.emptySet(); + + Set results = manager.searchVector("testIndex", new float[]{1.0f}, 10); + + Assert.assertNotNull(results); + Assert.assertTrue(results.isEmpty()); + } + + // ========== MetaData Sync Flow Tests ========== + + @Test + public void testGetNextVectorIndexWhenMetaDataAlreadyUpdated() { + runtime.isMetaDataUpdated = true; + runtime.nextVectorId = 100; + + int nextId = manager.getNextVectorId("testIndex"); + + Assert.assertEquals(100, nextId); + Assert.assertFalse(stateStore.getCurrentMaxVectorIdCalled); + } + + @Test + public void testGetNextVectorIndexSyncsFromStateStore() { + runtime.isMetaDataUpdated = false; + runtime.nextVectorId = 50; + stateStore.maxVectorId = 100; + stateStore.maxSequence = 200L; + + manager.getNextVectorId("testIndex"); + + // Verify: updateMetaData was called with values from stateStore + Assert.assertTrue(runtime.updateMetaDataCalled); + } + + @Test + public void testGetNextSequenceWhenMetaDataAlreadyUpdated() { + runtime.isMetaDataUpdated = true; + runtime.nextSequence = 500L; + + long nextSeq = manager.getNextSequence("testIndex"); + + Assert.assertEquals(500L, nextSeq); + Assert.assertFalse(stateStore.getCurrentMaxSequenceCalled); + } + + @Test + public void testGetNextSequenceSyncsFromStateStore() { + runtime.isMetaDataUpdated = false; + runtime.nextSequence = 100L; + stateStore.maxVectorId = 50; + stateStore.maxSequence = 300L; + + long nextSequence = manager.getNextSequence("testIndex"); + + Assert.assertEquals(301, nextSequence); + } + + // ========== Mock Classes ========== + + static class MockVectorStateStore implements VectorIndexStateStore { + boolean stopCalled = false; + Set vertexIds = new HashSet<>(); + int maxVectorId = 0; + long maxSequence = 0L; + List deltaRecords = new ArrayList<>(); + long lastScanFromSeq = -1L; + boolean getCurrentMaxVectorIdCalled = false; + boolean getCurrentMaxSequenceCalled = false; + + @Override + public void stop() { stopCalled = true; } + + @Override + public Iterable scanDeltas(String indexLabelId, long fromSeq) { + lastScanFromSeq = fromSeq; + return deltaRecords; + } + + @Override + public Set getVertex(String indexLabelId, Iterator vectorIds) { + return vertexIds; + } + + @Override + public int getCurrentMaxVectorId(String indexLabelId, int currentMaxVectorId) { + getCurrentMaxVectorIdCalled = true; + return Math.max(maxVectorId, currentMaxVectorId); + } + + @Override + public long getCurrentMaxSequence(String indexLabelId, long currentMaxSeq) { + getCurrentMaxSequenceCalled = true; + return Math.max(maxSequence, currentMaxSeq); + } + } + + static class MockVectorRuntime implements VectorIndexRuntime { + boolean initCalled = false; + boolean stopCalled = false; + boolean updateCalled = false; + boolean updateMetaDataCalled = false; + boolean isMetaDataUpdated = false; + String lastUpdatedIndexLabelId = null; + int nextVectorId = 0; + long nextSequence = 0L; + long watermark = 0L; + Iterator searchResults = Collections.emptyIterator(); + + @Override + public void init() { initCalled = true; } + + @Override + public void stop() { stopCalled = true; } + + @Override + public void update(String indexLabelId, Iterator records) { + updateCalled = true; + lastUpdatedIndexLabelId = indexLabelId; + while (records.hasNext()) { records.next(); } + } + + @Override + public void flush(String indexLabelId) { } + + @Override + public Iterator search(String indexLabelId, float[] queryVector, int topK) { + return searchResults; + } + + @Override + public long getCurrentWaterMark(String indexLabelId) { return watermark; } + + @Override + public int getNextVectorId(String indexLabelId) { return nextVectorId; } + + @Override + public long getNextSequence(String indexLabelId) { return nextSequence; } + + @Override + public boolean isUpdateMetaData(String indexLabelId) { return isMetaDataUpdated; } + + @Override + public void updateMetaData(String indexLabelId, int vectorId, long sequence) { + updateMetaDataCalled = true; + this.nextVectorId = vectorId; + this.nextSequence = sequence; + this.isMetaDataUpdated = true; + } + } + + static class MockVectorScheduler implements VectorTaskScheduler { + boolean taskExecuted = false; + int executedTaskCount = 0; + + @Override + public void execute(Runnable task) { + taskExecuted = true; + executedTaskCount++; + task.run(); + } + } +} + diff --git a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/VectorRecordTest.java b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/VectorRecordTest.java new file mode 100644 index 0000000000..cf7c25b8e4 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/vectorIndex/VectorRecordTest.java @@ -0,0 +1,121 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.unit.vectorIndex; + +import org.apache.hugegraph.testutil.Assert; +import org.apache.hugegraph.unit.BaseUnitTest; +import org.apache.hugegraph.vector.VectorRecord; +import org.junit.Test; + +public class VectorRecordTest extends BaseUnitTest { + + @Test + public void testConstructorAndGetters() { + int vectorId = 42; + float[] vector = new float[]{1.0f, 2.0f, 3.0f}; + boolean deleted = false; + long sequence = 100L; + + VectorRecord record = new VectorRecord(vectorId, vector, deleted, sequence); + + Assert.assertEquals(vectorId, record.getVectorId()); + Assert.assertArrayEquals(vector, record.getVectorData(), 0.0001f); + Assert.assertEquals(deleted, record.isDeleted()); + Assert.assertEquals(sequence, record.getSequence()); + } + + @Test + public void testDeletedRecord() { + int vectorId = 99; + float[] vector = new float[]{0.5f, 0.5f}; + boolean deleted = true; + long sequence = 200L; + + VectorRecord record = new VectorRecord(vectorId, vector, deleted, sequence); + + Assert.assertTrue(record.isDeleted()); + Assert.assertEquals(vectorId, record.getVectorId()); + Assert.assertEquals(sequence, record.getSequence()); + } + + @Test + public void testEmptyVector() { + int vectorId = 1; + float[] vector = new float[]{}; + boolean deleted = false; + long sequence = 1L; + + VectorRecord record = new VectorRecord(vectorId, vector, deleted, sequence); + + Assert.assertEquals(0, record.getVectorData().length); + Assert.assertFalse(record.isDeleted()); + } + + @Test + public void testHighDimensionVector() { + int vectorId = 1000; + int dimension = 128; + float[] vector = new float[dimension]; + for (int i = 0; i < dimension; i++) { + vector[i] = i * 0.01f; + } + boolean deleted = false; + long sequence = 999999L; + + VectorRecord record = new VectorRecord(vectorId, vector, deleted, sequence); + + Assert.assertEquals(dimension, record.getVectorData().length); + Assert.assertEquals(0.0f, record.getVectorData()[0], 0.0001f); + Assert.assertEquals(1.27f, record.getVectorData()[127], 0.0001f); + } + + @Test + public void testNullVector() { + int vectorId = 1; + float[] vector = null; + boolean deleted = false; + long sequence = 1L; + + VectorRecord record = new VectorRecord(vectorId, vector, deleted, sequence); + + Assert.assertNull(record.getVectorData()); + } + + @Test + public void testZeroSequence() { + VectorRecord record = new VectorRecord(0, new float[]{1.0f}, false, 0L); + + Assert.assertEquals(0, record.getVectorId()); + Assert.assertEquals(0L, record.getSequence()); + } + + @Test + public void testNegativeSequence() { + VectorRecord record = new VectorRecord(1, new float[]{1.0f}, false, -1L); + + Assert.assertEquals(-1L, record.getSequence()); + } + + @Test + public void testMaxSequence() { + VectorRecord record = new VectorRecord(1, new float[]{1.0f}, false, Long.MAX_VALUE); + + Assert.assertEquals(Long.MAX_VALUE, record.getSequence()); + } +} + diff --git a/hugegraph-server/hugegraph-test/src/test/java/org/apache/hugegraph/unit/config/ServerOptionsTest.java b/hugegraph-server/hugegraph-test/src/test/java/org/apache/hugegraph/unit/config/ServerOptionsTest.java new file mode 100644 index 0000000000..6113c748b0 --- /dev/null +++ b/hugegraph-server/hugegraph-test/src/test/java/org/apache/hugegraph/unit/config/ServerOptionsTest.java @@ -0,0 +1,122 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with this + * work for additional information regarding copyright ownership. The ASF + * licenses this file to You under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + */ + +package org.apache.hugegraph.unit.config; + +import org.apache.commons.configuration2.PropertiesConfiguration; +import org.apache.hugegraph.config.HugeConfig; +import org.apache.hugegraph.config.OptionSpace; +import org.apache.hugegraph.config.ServerOptions; +import org.apache.hugegraph.testutil.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +public class ServerOptionsTest { + + @BeforeClass + public static void init() { + OptionSpace.register("server", + ServerOptions.class.getName()); + } + + @Test + public void testUrlOptionNormalizeAddsDefaultScheme() { + PropertiesConfiguration conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", "127.0.0.1:8080"); + conf.setProperty("gremlinserver.url", "127.0.0.1:8182"); + conf.setProperty("server.urls_to_pd", "0.0.0.0:8080"); + conf.setProperty("server.k8s_url", "127.0.0.1:8888"); + + HugeConfig config = new HugeConfig(conf); + + Assert.assertEquals("http://127.0.0.1:8080", + config.get(ServerOptions.REST_SERVER_URL)); + Assert.assertEquals("http://127.0.0.1:8182", + config.get(ServerOptions.GREMLIN_SERVER_URL)); + Assert.assertEquals("http://0.0.0.0:8080", + config.get(ServerOptions.SERVER_URLS_TO_PD)); + Assert.assertEquals("https://127.0.0.1:8888", + config.get(ServerOptions.SERVER_K8S_URL)); + } + + @Test + public void testUrlNormalizationEdgeCases() { + // Whitespace trimming + PropertiesConfiguration conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", " 127.0.0.1:8080 "); + HugeConfig config = new HugeConfig(conf); + Assert.assertEquals("http://127.0.0.1:8080", + config.get(ServerOptions.REST_SERVER_URL)); + + // Case normalization + conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", "HTTP://127.0.0.1:8080"); + config = new HugeConfig(conf); + Assert.assertEquals("http://127.0.0.1:8080", + config.get(ServerOptions.REST_SERVER_URL)); + + // IPv6 without scheme + conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", "[::1]:8080"); + config = new HugeConfig(conf); + Assert.assertEquals("http://[::1]:8080", + config.get(ServerOptions.REST_SERVER_URL)); + + // IPv6 with existing scheme + conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", "http://[::1]:8080"); + config = new HugeConfig(conf); + Assert.assertEquals("http://[::1]:8080", + config.get(ServerOptions.REST_SERVER_URL)); + } + + @Test + public void testUrlNormalizationPreservesHostnameCase() { + // Uppercase scheme + mixed-case hostname + PropertiesConfiguration conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", "HTTP://MyServer:8080"); + HugeConfig config = new HugeConfig(conf); + // Should lowercase ONLY the scheme, preserve "MyServer" + Assert.assertEquals("http://MyServer:8080", + config.get(ServerOptions.REST_SERVER_URL)); + + // Use server.k8s_url for HTTPS test (it defaults to https://) + conf = new PropertiesConfiguration(); + conf.setProperty("server.k8s_url", "HTTPS://MyHost:8888"); + config = new HugeConfig(conf); + Assert.assertEquals("https://MyHost:8888", + config.get(ServerOptions.SERVER_K8S_URL)); + } + + @Test + public void testUrlNormalizationPreservesPathCase() { + PropertiesConfiguration conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", "http://127.0.0.1:8080/SomePath/CaseSensitive"); + HugeConfig config = new HugeConfig(conf); + Assert.assertEquals("http://127.0.0.1:8080/SomePath/CaseSensitive", + config.get(ServerOptions.REST_SERVER_URL)); + } + + @Test + public void testHttpsSchemeIsNotDowngraded() { + PropertiesConfiguration conf = new PropertiesConfiguration(); + conf.setProperty("restserver.url", "https://127.0.0.1:8080"); + HugeConfig config = new HugeConfig(conf); + Assert.assertEquals("https://127.0.0.1:8080", + config.get(ServerOptions.REST_SERVER_URL)); + } +} diff --git a/hugegraph-server/pom.xml b/hugegraph-server/pom.xml index a4dac32ab5..1ef5ed9574 100644 --- a/hugegraph-server/pom.xml +++ b/hugegraph-server/pom.xml @@ -37,7 +37,7 @@ ${project.basedir}/.. - apache-${release.name}-server-incubating-${project.version} + apache-${release.name}-server-${project.version} 1.7.5 1.2.17 2.17.1 diff --git a/hugegraph-store/AGENTS.md b/hugegraph-store/AGENTS.md index 86b28deaf9..8b5ef46bab 100644 --- a/hugegraph-store/AGENTS.md +++ b/hugegraph-store/AGENTS.md @@ -6,8 +6,6 @@ This file provides guidance to an AI coding tool when working with code in this HugeGraph Store is a distributed storage backend for Apache HugeGraph, using RocksDB as the underlying storage engine with Raft consensus protocol for distributed coordination. It is designed for production-scale deployments requiring high availability and horizontal scalability. -**Status**: BETA (active development since version 1.5.0) - **Technology Stack**: - Java 11+ - RocksDB: Embedded key-value storage engine @@ -131,7 +129,7 @@ bin/restart-hugegraph-store.sh 2. HugeGraph Store cluster (3+ nodes) 3. Proper configuration pointing Store nodes to PD cluster -See Docker Compose example: `hugegraph-server/hugegraph-dist/docker/example/` +See Docker Compose examples in the repository root `../docker/` directory. Single-node quickstart (pre-built images): `../docker/docker-compose.yml`. Single-node dev build (from source): `../docker/docker-compose.dev.yml`. 3-node cluster: `../docker/docker-compose-3pd-3store-3server.yml`. See `../docker/README.md` for the full setup guide. ## Configuration Files @@ -302,14 +300,6 @@ Store integrates with other HugeGraph components: ## Special Notes -### BETA Status - -HugeGraph Store is in BETA: -- Active development and API may change -- Production use requires thorough testing -- Monitor GitHub issues for known problems -- Recommended for new deployments; RocksDB backend available as stable alternative - ### Performance Tuning Key performance factors: diff --git a/hugegraph-store/Dockerfile b/hugegraph-store/Dockerfile index a00e5474af..5883f9cbf7 100644 --- a/hugegraph-store/Dockerfile +++ b/hugegraph-store/Dockerfile @@ -1,3 +1,4 @@ +# syntax=docker/dockerfile:1 # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with @@ -19,32 +20,32 @@ # 1st stage: build source code FROM maven:3.9.0-eclipse-temurin-11 AS build -COPY . /pkg WORKDIR /pkg + +COPY . . + ARG MAVEN_ARGS -RUN mvn package $MAVEN_ARGS -e -B -ntp -Dmaven.test.skip=true -Dmaven.javadoc.skip=true && pwd && ls -l && rm \ - ./hugegraph-server/*.tar.gz && rm ./hugegraph-pd/*.tar.gz && rm ./hugegraph-store/*.tar.gz +RUN --mount=type=cache,target=/root/.m2 \ + mvn package $MAVEN_ARGS -e -B -ntp -Dmaven.test.skip=true -Dmaven.javadoc.skip=true \ + && rm ./hugegraph-server/*.tar.gz ./hugegraph-pd/*.tar.gz ./hugegraph-store/*.tar.gz # 2nd stage: runtime env # Note: ZGC (The Z Garbage Collector) is only supported on ARM-Mac with java > 13 -FROM openjdk:11-slim +FROM eclipse-temurin:11-jre-jammy -COPY --from=build /pkg/hugegraph-store/apache-hugegraph-store-incubating-*/ /hugegraph-store/ +COPY --from=build /pkg/hugegraph-store/apache-hugegraph-store-*/ /hugegraph-store/ LABEL maintainer="HugeGraph Docker Maintainers " # TODO: use g1gc or zgc as default ENV JAVA_OPTS="-XX:+UnlockExperimentalVMOptions -XX:+UseContainerSupport -XX:MaxRAMPercentage=50 -XshowSettings:vm" \ - HUGEGRAPH_HOME="hugegraph-store" + HUGEGRAPH_HOME="hugegraph-store" \ + STDOUT_MODE="true" -#COPY . /hugegraph/hugegraph-store WORKDIR /hugegraph-store/ -# 1. Install environment and init HugeGraph Sever -RUN set -x \ - && rm /var/lib/dpkg/info/libc-bin.* \ - && apt-get -q clean \ - && apt-get -q update \ +# 1. Install runtime dependencies +RUN apt-get -q update \ && apt-get -q install -y --no-install-recommends --no-install-suggests \ dumb-init \ procps \ @@ -53,9 +54,7 @@ RUN set -x \ vim \ cron \ && apt-get clean \ - && rm -rf /var/lib/apt/lists/* \ - && service cron start \ - && pwd && cd /hugegraph-store/ + && rm -rf /var/lib/apt/lists/* # 2. Init docker script COPY hugegraph-store/hg-store-dist/docker/docker-entrypoint.sh . diff --git a/hugegraph-store/README.md b/hugegraph-store/README.md index 5d7821b25a..223517525e 100644 --- a/hugegraph-store/README.md +++ b/hugegraph-store/README.md @@ -104,19 +104,12 @@ From the project root: mvn install -pl hugegraph-struct -am -DskipTests # Build Store and all dependencies -mvn clean package -pl hugegraph-store -am -DskipTests -``` - -Or build from the `hugegraph-store` directory: - -```bash -cd hugegraph-store -mvn clean install -DskipTests +mvn clean package -pl hugegraph-store/hg-store-dist -am -DskipTests ``` The assembled distribution will be available at: ``` -hugegraph-store/hg-store-dist/target/apache-hugegraph-store-incubating-.tar.gz +hugegraph-store/apache-hugegraph-store-/lib/hg-store-node-.jar ``` ### Configuration @@ -220,8 +213,10 @@ For detailed configuration options, RocksDB tuning, and deployment topologies, s Start the Store server: ```bash -tar -xzf apache-hugegraph-store-incubating-.tar.gz -cd apache-hugegraph-store-incubating- +# Replace {version} with your hugegraph version +# For historical 1.7.0 and earlier releases, use +# apache-hugegraph-store-incubating-{version} instead. +cd apache-hugegraph-store-{version} # Start Store node bin/start-hugegraph-store.sh @@ -258,13 +253,13 @@ ps aux | grep hugegraph-store grpcurl -plaintext localhost:8500 list # Check REST API health -curl http://localhost:8520/actuator/health +curl http://localhost:8520/v1/health # Check logs tail -f logs/hugegraph-store.log # Verify registration with PD (from PD node) -curl http://localhost:8620/pd/v1/stores +curl http://localhost:8620/v1/stores ``` For production deployment, see [Deployment Guide](docs/deployment-guide.md) and [Best Practices](docs/best-practices.md). @@ -307,14 +302,12 @@ bin/start-hugegraph.sh ```bash # Check backend via REST API -curl http://localhost:8080/graphs//backend - +curl --location --request GET 'http://localhost:8080/metrics/backend' \ +--header 'Authorization: Bearer ' # Response should show: # {"backend": "hstore", "nodes": [...]} ``` -For detailed integration steps, client API usage, and migration from other backends, see [Integration Guide](docs/integration-guide.md). - --- ## Testing @@ -355,7 +348,7 @@ For development workflows and debugging, see [Development Guide](docs/developmen From the project root: ```bash -docker build -f hugegraph-store/Dockerfile -t hugegraph-store:latest . +docker build -f hugegraph-store/Dockerfile -t hugegraph/store:latest . ``` ### Run Container @@ -365,11 +358,12 @@ docker run -d \ -p 8520:8520 \ -p 8500:8500 \ -p 8510:8510 \ - -v /path/to/conf:/hugegraph-store/conf \ + -e HG_STORE_PD_ADDRESS=:8686 \ + -e HG_STORE_GRPC_HOST= \ + -e HG_STORE_RAFT_ADDRESS=:8510 \ -v /path/to/storage:/hugegraph-store/storage \ - -e PD_ADDRESS=192.168.1.10:8686,192.168.1.11:8686 \ --name hugegraph-store \ - hugegraph-store:latest + hugegraph/store:latest ``` **Exposed Ports**: @@ -382,9 +376,11 @@ docker run -d \ For a complete HugeGraph distributed deployment (PD + Store + Server), see: ``` -hugegraph-server/hugegraph-dist/docker/example/ +docker/docker-compose-3pd-3store-3server.yml ``` +See [docker/README.md](../docker/README.md) for the full setup guide. + For Docker and Kubernetes deployment details, see [Deployment Guide](docs/deployment-guide.md). --- @@ -484,6 +480,4 @@ HugeGraph Store is licensed under the [Apache License 2.0](https://www.apache.or --- -**Status**: BETA (from v1.5.0+) - -HugeGraph Store is under active development. While suitable for production use, APIs and configurations may evolve. Please report issues via GitHub or the mailing list. +HugeGraph Store is under active development. Please report issues via GitHub or the mailing list. diff --git a/hugegraph-store/docs/best-practices.md b/hugegraph-store/docs/best-practices.md index 9a214f4e26..47d02521c3 100644 --- a/hugegraph-store/docs/best-practices.md +++ b/hugegraph-store/docs/best-practices.md @@ -345,13 +345,12 @@ grpc: bin/enable-auth.sh # Configure users and roles via REST API -curl -X POST http://localhost:8080/graphs/hugegraph/auth/users \ - -H "Content-Type: application/json" \ - -d '{ - "user_name": "admin", - "user_password": "password123", - "user_role": "admin" - }' +curl -X POST "http://localhost:8080/graphspaces/{graph_spcace_name}/graphs/{graph}/auth/users" \ + -H "Content-Type: application/json" \ + -d '{ + "user_name": "admin", + "user_password": "password123" + }' ``` ### Data Encryption diff --git a/hugegraph-store/docs/deployment-guide.md b/hugegraph-store/docs/deployment-guide.md index b6aa595687..de07904d64 100644 --- a/hugegraph-store/docs/deployment-guide.md +++ b/hugegraph-store/docs/deployment-guide.md @@ -416,6 +416,7 @@ df -h ```bash # Extract PD distribution +# Note: use "-incubating" only for historical 1.7.0 and earlier package/directory names. tar -xzf apache-hugegraph-pd-incubating-1.7.0.tar.gz cd apache-hugegraph-pd-incubating-1.7.0 @@ -471,17 +472,34 @@ curl http://localhost:8620/actuator/health ```bash # Check cluster members -curl http://192.168.1.10:8620/pd/v1/members +curl http://192.168.1.10:8620/v1/members # Expected output: -# { -# "members": [ -# {"id": "1", "name": "pd-1", "address": "192.168.1.10:8686"}, -# {"id": "2", "name": "pd-2", "address": "192.168.1.11:8686"}, -# {"id": "3", "name": "pd-3", "address": "192.168.1.12:8686"} -# ], -# "leader": "1" -# } +{ + "message":"OK", + "data":{ + "pdLeader":null, + "pdList":[{ + "raftUrl":"127.0.0.1:8610", + "grpcUrl":"", + "restUrl":"", + "state":"Offline", + "dataPath":"", + "role":"Leader", + "replicateState":"", + "serviceName":"-PD", + "serviceVersion":"1.7.0", + "startTimeStamp":1761818483830 + }], + "stateCountMap":{ + "Offline":1 + }, + "numOfService":1, + "state":"Cluster_OK", + "numOfNormalService":0 + }, + "status":0 +} ``` --- @@ -492,6 +510,7 @@ curl http://192.168.1.10:8620/pd/v1/members ```bash # Extract Store distribution +# Note: use "-incubating" only for historical 1.7.0 and earlier package/directory names. tar -xzf apache-hugegraph-store-incubating-1.7.0.tar.gz cd apache-hugegraph-store-incubating-1.7.0 @@ -560,23 +579,45 @@ bin/start-hugegraph-store.sh tail -f logs/hugegraph-store.log # Verify Store is running -curl http://localhost:8520/actuator/health +curl http://localhost:8520/v1/health ``` **Verify Store registration with PD**: ```bash # Query PD for registered stores -curl http://192.168.1.10:8620/pd/v1/stores +curl http://192.168.1.10:8620/v1/stores # Expected output: -# { -# "stores": [ -# {"id": "1", "address": "192.168.1.20:8500", "state": "Online"}, -# {"id": "2", "address": "192.168.1.21:8500", "state": "Online"}, -# {"id": "3", "address": "192.168.1.22:8500", "state": "Online"} -# ] -# } +{ + "message":"OK", + "data":{ + "stores":[{ + "storeId":"1783423547167821026", + "address":"192.168.1.10:8500", + "raftAddress":"192.168.1.10:8510", + "version":"","state":"Up", + "deployPath":"/Users/user/hugegraph/hugegraph-store/hg-store-node/target/classes/", + "dataPath":"./storage", + "startTimeStamp":1761818547335, + "registedTimeStamp":1761818547335, + "lastHeartBeat":1761818727631, + "capacity":245107195904, + "available":118497292288, + "partitionCount":0, + "graphSize":0, + "keyCount":0, + "leaderCount":0, + "serviceName":"192.168.1.10:8500-store", + "serviceVersion":"", + "serviceCreatedTimeStamp":1761818547000, + "partitions":[]}], + "stateCountMap":{"Up":1}, + "numOfService":1, + "numOfNormalService":1 + }, + "status":0 +} ``` --- @@ -587,6 +628,7 @@ curl http://192.168.1.10:8620/pd/v1/stores ```bash # Extract Server distribution +# Note: use "-incubating" only for historical 1.7.0 and earlier package/directory names. tar -xzf apache-hugegraph-incubating-1.7.0.tar.gz cd apache-hugegraph-incubating-1.7.0 @@ -630,163 +672,73 @@ curl http://localhost:8080/versions ### Docker Compose: Complete Cluster -File: `docker-compose.yml` +For a production-like 3-node distributed deployment, use the compose file at `docker/docker-compose-3pd-3store-3server.yml` in the repository root. See [docker/README.md](../../docker/README.md) for the full setup guide. + +> **Prerequisites**: Allocate at least **12 GB** memory to Docker Desktop (Settings → Resources → Memory). The cluster runs 9 JVM processes. + +```bash +cd docker +HUGEGRAPH_VERSION=1.7.0 docker compose -f docker-compose-3pd-3store-3server.yml up -d +``` + +The compose file uses a Docker bridge network (`hg-net`) with container hostnames for service discovery. Configuration is injected via environment variables using the `HG_*` prefix: + +**PD environment variables** (per node): ```yaml -version: '3.8' - -services: - # PD Cluster (3 nodes) - pd1: - image: hugegraph/hugegraph-pd:1.7.0 - container_name: hugegraph-pd1 - ports: - - "8686:8686" - - "8620:8620" - - "8610:8610" - environment: - - GRPC_HOST=pd1 - - RAFT_ADDRESS=pd1:8610 - - RAFT_PEERS=pd1:8610,pd2:8610,pd3:8610 - networks: - - hugegraph-net - - pd2: - image: hugegraph/hugegraph-pd:1.7.0 - container_name: hugegraph-pd2 - ports: - - "8687:8686" - environment: - - GRPC_HOST=pd2 - - RAFT_ADDRESS=pd2:8610 - - RAFT_PEERS=pd1:8610,pd2:8610,pd3:8610 - networks: - - hugegraph-net - - pd3: - image: hugegraph/hugegraph-pd:1.7.0 - container_name: hugegraph-pd3 - ports: - - "8688:8686" - environment: - - GRPC_HOST=pd3 - - RAFT_ADDRESS=pd3:8610 - - RAFT_PEERS=pd1:8610,pd2:8610,pd3:8610 - networks: - - hugegraph-net - - # Store Cluster (3 nodes) - store1: - image: hugegraph/hugegraph-store:1.7.0 - container_name: hugegraph-store1 - ports: - - "8500:8500" - - "8510:8510" - - "8520:8520" - environment: - - PD_ADDRESS=pd1:8686,pd2:8686,pd3:8686 - - GRPC_HOST=store1 - - RAFT_ADDRESS=store1:8510 - volumes: - - store1-data:/hugegraph-store/storage - depends_on: - - pd1 - - pd2 - - pd3 - networks: - - hugegraph-net - - store2: - image: hugegraph/hugegraph-store:1.7.0 - container_name: hugegraph-store2 - ports: - - "8501:8500" - environment: - - PD_ADDRESS=pd1:8686,pd2:8686,pd3:8686 - - GRPC_HOST=store2 - - RAFT_ADDRESS=store2:8510 - volumes: - - store2-data:/hugegraph-store/storage - depends_on: - - pd1 - - pd2 - - pd3 - networks: - - hugegraph-net - - store3: - image: hugegraph/hugegraph-store:1.7.0 - container_name: hugegraph-store3 - ports: - - "8502:8500" - environment: - - PD_ADDRESS=pd1:8686,pd2:8686,pd3:8686 - - GRPC_HOST=store3 - - RAFT_ADDRESS=store3:8510 - volumes: - - store3-data:/hugegraph-store/storage - depends_on: - - pd1 - - pd2 - - pd3 - networks: - - hugegraph-net - - # Server (2 nodes) - server1: - image: hugegraph/hugegraph:1.7.0 - container_name: hugegraph-server1 - ports: - - "8080:8080" - environment: - - BACKEND=hstore - - PD_PEERS=pd1:8686,pd2:8686,pd3:8686 - depends_on: - - store1 - - store2 - - store3 - networks: - - hugegraph-net - - server2: - image: hugegraph/hugegraph:1.7.0 - container_name: hugegraph-server2 - ports: - - "8081:8080" - environment: - - BACKEND=hstore - - PD_PEERS=pd1:8686,pd2:8686,pd3:8686 - depends_on: - - store1 - - store2 - - store3 - networks: - - hugegraph-net - -networks: - hugegraph-net: - driver: bridge - -volumes: - store1-data: - store2-data: - store3-data: +environment: + HG_PD_GRPC_HOST: pd0 # maps to grpc.host + HG_PD_GRPC_PORT: "8686" # maps to grpc.port + HG_PD_REST_PORT: "8620" # maps to server.port + HG_PD_RAFT_ADDRESS: pd0:8610 # maps to raft.address + HG_PD_RAFT_PEERS_LIST: pd0:8610,pd1:8610,pd2:8610 # maps to raft.peers-list + HG_PD_INITIAL_STORE_LIST: store0:8500,store1:8500,store2:8500 # maps to pd.initial-store-list + HG_PD_DATA_PATH: /hugegraph-pd/pd_data # maps to pd.data-path + HG_PD_INITIAL_STORE_COUNT: 3 # maps to pd.initial-store-count ``` +**Store environment variables** (per node): + +```yaml +environment: + HG_STORE_PD_ADDRESS: pd0:8686,pd1:8686,pd2:8686 # maps to pdserver.address + HG_STORE_GRPC_HOST: store0 # maps to grpc.host + HG_STORE_GRPC_PORT: "8500" # maps to grpc.port + HG_STORE_REST_PORT: "8520" # maps to server.port + HG_STORE_RAFT_ADDRESS: store0:8510 # maps to raft.address + HG_STORE_DATA_PATH: /hugegraph-store/storage # maps to app.data-path +``` + +**Server environment variables**: + +```yaml +environment: + HG_SERVER_BACKEND: hstore # maps to backend + HG_SERVER_PD_PEERS: pd0:8686,pd1:8686,pd2:8686 # maps to pd.peers + STORE_REST: store0:8520 # used by wait-partition.sh +``` + +**Startup ordering** is enforced via `depends_on` with `condition: service_healthy`: +1. PD nodes start first and must pass healthchecks (`/v1/health`) +2. Store nodes start after all PD nodes are healthy +3. Server nodes start after all Store nodes are healthy + +> **Note**: The deprecated env var names (`GRPC_HOST`, `RAFT_ADDRESS`, `RAFT_PEERS`, `PD_ADDRESS`, `BACKEND`, `PD_PEERS`) still work but log a warning. Use the `HG_*` prefixed names for new deployments. + **Deploy**: ```bash -# Start cluster -docker-compose up -d +# Start cluster (run from the docker/ directory) +HUGEGRAPH_VERSION=1.7.0 docker compose -f docker-compose-3pd-3store-3server.yml up -d # Check status -docker-compose ps +docker ps # View logs -docker-compose logs -f store1 +docker logs hg-store0 # Stop cluster -docker-compose down +docker compose -f docker-compose-3pd-3store-3server.yml down ``` --- @@ -834,7 +786,7 @@ spec: spec: containers: - name: store - image: hugegraph/hugegraph-store:1.7.0 + image: hugegraph/store:1.7.0 ports: - containerPort: 8500 name: grpc @@ -847,11 +799,11 @@ spec: valueFrom: fieldRef: fieldPath: metadata.name - - name: PD_ADDRESS + - name: HG_STORE_PD_ADDRESS value: "hugegraph-pd-0.hugegraph-pd:8686,hugegraph-pd-1.hugegraph-pd:8686,hugegraph-pd-2.hugegraph-pd:8686" - - name: GRPC_HOST + - name: HG_STORE_GRPC_HOST value: "$(POD_NAME).hugegraph-store" - - name: RAFT_ADDRESS + - name: HG_STORE_RAFT_ADDRESS value: "$(POD_NAME).hugegraph-store:8510" volumeMounts: - name: data @@ -904,47 +856,45 @@ kubectl port-forward svc/hugegraph-store 8500:8500 -n hugegraph ```bash # PD health -curl http://192.168.1.10:8620/actuator/health +curl http://192.168.1.10:8620/v1/health # Store health -curl http://192.168.1.20:8520/actuator/health - -# Server health -curl http://192.168.1.30:8080/actuator/health +curl http://192.168.1.20:8520/v1/health ``` ### Cluster Status ```bash # PD cluster members -curl http://192.168.1.10:8620/pd/v1/members +curl http://192.168.1.10:8620/v1/members # Registered stores -curl http://192.168.1.10:8620/pd/v1/stores +curl http://192.168.1.10:8620/v1/stores # Partitions -curl http://192.168.1.10:8620/pd/v1/partitions +curl http://192.168.1.10:8620/v1/partitions # Graph list -curl http://192.168.1.30:8080/graphs +curl http://192.168.1.10:8620/v1/graphs ``` ### Basic Operations Test ```bash # Create vertex via Server -curl -X POST http://192.168.1.30:8080/graphs/hugegraph/graph/vertices \ - -H "Content-Type: application/json" \ - -d '{ - "label": "person", - "properties": { - "name": "Alice", - "age": 30 - } - }' - -# Query vertex -curl http://192.168.1.30:8080/graphs/hugegraph/graph/vertices +curl -X POST "http://192.168.1.30:8080/graphspaces/{graphspace_name}/graphs/{graph_name}/graph/vertices" \ + -H "Content-Type: application/json" \ + -d '{ + "label": "person", + "properties": { + "name": "marko", + "age": 29 + } + }' + +# Query vertex (using -u if auth is enabled) +curl -u admin:admin \ + -X GET "http://localhost:8080/graphspaces/{graphspace_name}/graphs/graphspace_name}/graph/vertices/{graph_id} ``` ### Performance Baseline Test diff --git a/hugegraph-store/docs/development-guide.md b/hugegraph-store/docs/development-guide.md index 9a6a5e4c34..44136776e7 100644 --- a/hugegraph-store/docs/development-guide.md +++ b/hugegraph-store/docs/development-guide.md @@ -48,9 +48,9 @@ git checkout 1.7-rebase **Code Style**: ```bash -# Import code style -# File → Settings → Editor → Code Style → Java -# Import Scheme → hugegraph-style.xml +# Configure IDE code style +# Ensure EditorConfig support is enabled +# Code style is defined in .editorconfig at repository root ``` **Run Configuration**: @@ -58,7 +58,7 @@ git checkout 1.7-rebase 2. Add new "Application" configuration: - Main class: `org.apache.hugegraph.store.node.StoreNodeApplication` - VM options: `-Xms4g -Xmx4g -Dconfig.file=conf/application.yml` - - Working directory: `hugegraph-store/hg-store-dist/target/apache-hugegraph-store-incubating-1.7.0` + - Working directory: `hugegraph-store/apache-hugegraph-store-` (`apache-hugegraph-store-incubating-` for historical 1.7.0 and earlier directories) - Use classpath of module: `hg-store-node` ### Build from Source @@ -216,10 +216,14 @@ hg-store-grpc/ **Start Server**: ```bash -cd hugegraph-store/hg-store-dist/target/apache-hugegraph-store-incubating-1.7.0 +# Historical 1.7.0 and earlier directories use +# apache-hugegraph-store-incubating- instead. +cd hugegraph-store/apache-hugegraph-store- bin/start-hugegraph-store.sh ``` +If you want to run store module in debug mode +Directly run HgStoreNodeService in your IDE (ensure PD is on). --- ## Build and Test @@ -240,7 +244,7 @@ mvn compile ```bash mvn clean package -DskipTests -# Output: hg-store-dist/target/apache-hugegraph-store-incubating-.tar.gz +# Output: hugegraph-store/apache-hugegraph-store-.tar.gz ``` **Regenerate gRPC stubs** (after modifying `.proto` files): @@ -681,7 +685,7 @@ jmap -dump:format=b,file=heap.bin $(pgrep -f hugegraph-store) ### Code Style **Java**: -- Follow Apache HugeGraph code style (import `hugegraph-style.xml`) +- Follow Apache HugeGraph code style (configured via `.editorconfig`) - Use 4 spaces for indentation (no tabs) - Max line length: 120 characters - Braces on same line (K&R style) @@ -823,7 +827,7 @@ cd install-dist/scripts/dependency - Slack: (link in project README) **Related Projects**: -- Apache JRaft: https://github.com/sofastack/sofa-jraft +- SOFA-JRaft: https://github.com/sofastack/sofa-jraft - RocksDB: https://rocksdb.org/ - gRPC: https://grpc.io/docs/languages/java/ diff --git a/hugegraph-store/docs/distributed-architecture.md b/hugegraph-store/docs/distributed-architecture.md index a972158482..982de223ce 100644 --- a/hugegraph-store/docs/distributed-architecture.md +++ b/hugegraph-store/docs/distributed-architecture.md @@ -200,11 +200,11 @@ HugeGraph Store follows a layered architecture with clear separation of responsi ## Raft Consensus Mechanism -HugeGraph Store uses **Apache JRaft** (Ant Financial's Raft implementation) to achieve strong consistency and high availability. +HugeGraph Store uses **Sofa-JRaft** (Ant Financial's Raft implementation) to achieve strong consistency and high availability. ### Raft per Partition Design -Unlike some distributed systems that use a single Raft group for the entire cluster, HugeGraph Store uses **one Raft group per partition**: +Unlike some distributed systems that use a single Raft group for the entire cluster, HugeGraph Store uses MultiRaft: ``` Store Cluster (3 nodes: S1, S2, S3) diff --git a/hugegraph-store/docs/integration-guide.md b/hugegraph-store/docs/integration-guide.md index a3fad5cae7..f35669c698 100644 --- a/hugegraph-store/docs/integration-guide.md +++ b/hugegraph-store/docs/integration-guide.md @@ -99,19 +99,10 @@ tail -f logs/hugegraph-server.log ```bash # Check backend via REST API -curl http://localhost:8080/graphs/hugegraph/backend - -# Expected response: -{ - "backend": "hstore", - "version": "1.7.0", - "nodes": [ - {"id": "1", "address": "192.168.1.20:8500"}, - {"id": "2", "address": "192.168.1.21:8500"}, - {"id": "3", "address": "192.168.1.22:8500"} - ], - "partitions": 12 -} +curl --location --request GET 'http://localhost:8080/metrics/backend' \ +--header 'Authorization: Bearer ' +# Response should show: +# {"backend": "hstore", "nodes": [...]} ``` --- @@ -125,184 +116,304 @@ The `hg-store-client` module provides a Java client for directly interacting wit ```xml org.apache.hugegraph - hg-store-client + hugegraph-client 1.7.0 ``` ### Basic Usage -#### 1. Creating a Client - -```java -import org.apache.hugegraph.store.client.HgStoreClient; -import org.apache.hugegraph.store.client.HgStoreSession; - -// PD addresses -String pdPeers = "192.168.1.10:8686,192.168.1.11:8686,192.168.1.12:8686"; - -// Create client -HgStoreClient client = HgStoreClient.create(pdPeers); - -// Create session for a graph -String graphName = "hugegraph"; -HgStoreSession session = client.openSession(graphName); -``` - -#### 2. Basic Operations - -**Put (Write)**: -```java -import org.apache.hugegraph.store.client.HgStoreSession; - -// Put a key-value pair -byte[] key = "vertex:person:1001".getBytes(); -byte[] value = serializeVertex(vertex); // Your serialization logic - -session.put(tableName, key, value); -``` - -**Get (Read)**: -```java -// Get value by key -byte[] key = "vertex:person:1001".getBytes(); -byte[] value = session.get(tableName, key); - -if (value != null) { - Vertex vertex = deserializeVertex(value); -} -``` - -**Delete**: -```java -// Delete a key -byte[] key = "vertex:person:1001".getBytes(); -session.delete(tableName, key); -``` +#### 1. Single Example -**Scan (Range Query)**: ```java -import org.apache.hugegraph.store.client.HgStoreResultSet; - -// Scan all keys with prefix "vertex:person:" -byte[] startKey = "vertex:person:".getBytes(); -byte[] endKey = "vertex:person:~".getBytes(); - -HgStoreResultSet resultSet = session.scan(tableName, startKey, endKey); - -while (resultSet.hasNext()) { - HgStoreResultSet.Entry entry = resultSet.next(); - byte[] key = entry.key(); - byte[] value = entry.value(); - - // Process entry -} - -resultSet.close(); -``` - -#### 3. Batch Operations - -```java -import org.apache.hugegraph.store.client.HgStoreBatch; - -// Create batch -HgStoreBatch batch = session.beginBatch(); - -// Add operations to batch -for (Vertex vertex : vertices) { - byte[] key = vertexKey(vertex.id()); - byte[] value = serializeVertex(vertex); - batch.put(tableName, key, value); -} - -// Commit batch (atomic write via Raft) -batch.commit(); - -// Or rollback -// batch.rollback(); -``` - -#### 4. Session Management - -```java -// Close session -session.close(); - -// Close client (releases all resources) -client.close(); -``` - -### Advanced Usage - -#### Query with Filters - -```java -import org.apache.hugegraph.store.client.HgStoreQuery; -import org.apache.hugegraph.store.client.HgStoreQuery.Filter; - -// Build query with filter -HgStoreQuery query = HgStoreQuery.builder() - .table(tableName) - .prefix("vertex:person:") - .filter(Filter.eq("age", 30)) // Filter: age == 30 - .limit(100) - .build(); - -// Execute query -HgStoreResultSet resultSet = session.query(query); - -while (resultSet.hasNext()) { - // Process results +import java.io.IOException; +import java.util.Iterator; +import java.util.List; + +import org.apache.hugegraph.driver.GraphManager; +import org.apache.hugegraph.driver.GremlinManager; +import org.apache.hugegraph.driver.HugeClient; +import org.apache.hugegraph.driver.SchemaManager; +import org.apache.hugegraph.structure.constant.T; +import org.apache.hugegraph.structure.graph.Edge; +import org.apache.hugegraph.structure.graph.Path; +import org.apache.hugegraph.structure.graph.Vertex; +import org.apache.hugegraph.structure.gremlin.Result; +import org.apache.hugegraph.structure.gremlin.ResultSet; + +public class SingleExample { + + public static void main(String[] args) throws IOException { + // If connect failed will throw a exception. + HugeClient hugeClient = HugeClient.builder("http://localhost:8080", + "hugegraph") + .build(); + + SchemaManager schema = hugeClient.schema(); + + schema.propertyKey("name").asText().ifNotExist().create(); + schema.propertyKey("age").asInt().ifNotExist().create(); + schema.propertyKey("city").asText().ifNotExist().create(); + schema.propertyKey("weight").asDouble().ifNotExist().create(); + schema.propertyKey("lang").asText().ifNotExist().create(); + schema.propertyKey("date").asDate().ifNotExist().create(); + schema.propertyKey("price").asInt().ifNotExist().create(); + + schema.vertexLabel("person") + .properties("name", "age", "city") + .primaryKeys("name") + .ifNotExist() + .create(); + + schema.vertexLabel("software") + .properties("name", "lang", "price") + .primaryKeys("name") + .ifNotExist() + .create(); + + schema.indexLabel("personByCity") + .onV("person") + .by("city") + .secondary() + .ifNotExist() + .create(); + + schema.indexLabel("personByAgeAndCity") + .onV("person") + .by("age", "city") + .secondary() + .ifNotExist() + .create(); + + schema.indexLabel("softwareByPrice") + .onV("software") + .by("price") + .range() + .ifNotExist() + .create(); + + schema.edgeLabel("knows") + .sourceLabel("person") + .targetLabel("person") + .properties("date", "weight") + .ifNotExist() + .create(); + + schema.edgeLabel("created") + .sourceLabel("person").targetLabel("software") + .properties("date", "weight") + .ifNotExist() + .create(); + + schema.indexLabel("createdByDate") + .onE("created") + .by("date") + .secondary() + .ifNotExist() + .create(); + + schema.indexLabel("createdByWeight") + .onE("created") + .by("weight") + .range() + .ifNotExist() + .create(); + + schema.indexLabel("knowsByWeight") + .onE("knows") + .by("weight") + .range() + .ifNotExist() + .create(); + + GraphManager graph = hugeClient.graph(); + Vertex marko = graph.addVertex(T.LABEL, "person", "name", "marko", + "age", 29, "city", "Beijing"); + Vertex vadas = graph.addVertex(T.LABEL, "person", "name", "vadas", + "age", 27, "city", "Hongkong"); + Vertex lop = graph.addVertex(T.LABEL, "software", "name", "lop", + "lang", "java", "price", 328); + Vertex josh = graph.addVertex(T.LABEL, "person", "name", "josh", + "age", 32, "city", "Beijing"); + Vertex ripple = graph.addVertex(T.LABEL, "software", "name", "ripple", + "lang", "java", "price", 199); + Vertex peter = graph.addVertex(T.LABEL, "person", "name", "peter", + "age", 35, "city", "Shanghai"); + + marko.addEdge("knows", vadas, "date", "2016-01-10", "weight", 0.5); + marko.addEdge("knows", josh, "date", "2013-02-20", "weight", 1.0); + marko.addEdge("created", lop, "date", "2017-12-10", "weight", 0.4); + josh.addEdge("created", lop, "date", "2009-11-11", "weight", 0.4); + josh.addEdge("created", ripple, "date", "2017-12-10", "weight", 1.0); + peter.addEdge("created", lop, "date", "2017-03-24", "weight", 0.2); + + GremlinManager gremlin = hugeClient.gremlin(); + System.out.println("==== Path ===="); + ResultSet resultSet = gremlin.gremlin("g.V().outE().path()").execute(); + Iterator results = resultSet.iterator(); + results.forEachRemaining(result -> { + System.out.println(result.getObject().getClass()); + Object object = result.getObject(); + if (object instanceof Vertex) { + System.out.println(((Vertex) object).id()); + } else if (object instanceof Edge) { + System.out.println(((Edge) object).id()); + } else if (object instanceof Path) { + List elements = ((Path) object).objects(); + elements.forEach(element -> { + System.out.println(element.getClass()); + System.out.println(element); + }); + } else { + System.out.println(object); + } + }); + + hugeClient.close(); + } } -``` -#### Aggregation Queries - -```java -import org.apache.hugegraph.store.client.HgStoreQuery.Aggregation; - -// Count vertices with label "person" -HgStoreQuery query = HgStoreQuery.builder() - .table(tableName) - .prefix("vertex:person:") - .aggregation(Aggregation.COUNT) - .build(); - -long count = session.aggregate(query); -System.out.println("Person count: " + count); ``` -#### Multi-Partition Iteration +#### 2. Batch Example ```java -// Scan across all partitions (Store handles partition routing) -HgStoreResultSet resultSet = session.scanAll(tableName); - -while (resultSet.hasNext()) { - HgStoreResultSet.Entry entry = resultSet.next(); - // Process entry from any partition +import java.util.ArrayList; +import java.util.List; + +import org.apache.hugegraph.driver.GraphManager; +import org.apache.hugegraph.driver.HugeClient; +import org.apache.hugegraph.driver.SchemaManager; +import org.apache.hugegraph.structure.graph.Edge; +import org.apache.hugegraph.structure.graph.Vertex; + +public class BatchExample { + + public static void main(String[] args) { + // If connect failed will throw a exception. + HugeClient hugeClient = HugeClient.builder("http://localhost:8080", + "hugegraph") + .build(); + + SchemaManager schema = hugeClient.schema(); + + schema.propertyKey("name").asText().ifNotExist().create(); + schema.propertyKey("age").asInt().ifNotExist().create(); + schema.propertyKey("lang").asText().ifNotExist().create(); + schema.propertyKey("date").asDate().ifNotExist().create(); + schema.propertyKey("price").asInt().ifNotExist().create(); + + schema.vertexLabel("person") + .properties("name", "age") + .primaryKeys("name") + .ifNotExist() + .create(); + + schema.vertexLabel("person") + .properties("price") + .nullableKeys("price") + .append(); + + schema.vertexLabel("software") + .properties("name", "lang", "price") + .primaryKeys("name") + .ifNotExist() + .create(); + + schema.indexLabel("softwareByPrice") + .onV("software").by("price") + .range() + .ifNotExist() + .create(); + + schema.edgeLabel("knows") + .link("person", "person") + .properties("date") + .ifNotExist() + .create(); + + schema.edgeLabel("created") + .link("person", "software") + .properties("date") + .ifNotExist() + .create(); + + schema.indexLabel("createdByDate") + .onE("created").by("date") + .secondary() + .ifNotExist() + .create(); + + // get schema object by name + System.out.println(schema.getPropertyKey("name")); + System.out.println(schema.getVertexLabel("person")); + System.out.println(schema.getEdgeLabel("knows")); + System.out.println(schema.getIndexLabel("createdByDate")); + + // list all schema objects + System.out.println(schema.getPropertyKeys()); + System.out.println(schema.getVertexLabels()); + System.out.println(schema.getEdgeLabels()); + System.out.println(schema.getIndexLabels()); + + GraphManager graph = hugeClient.graph(); + + Vertex marko = new Vertex("person").property("name", "marko") + .property("age", 29); + Vertex vadas = new Vertex("person").property("name", "vadas") + .property("age", 27); + Vertex lop = new Vertex("software").property("name", "lop") + .property("lang", "java") + .property("price", 328); + Vertex josh = new Vertex("person").property("name", "josh") + .property("age", 32); + Vertex ripple = new Vertex("software").property("name", "ripple") + .property("lang", "java") + .property("price", 199); + Vertex peter = new Vertex("person").property("name", "peter") + .property("age", 35); + + Edge markoKnowsVadas = new Edge("knows").source(marko).target(vadas) + .property("date", "2016-01-10"); + Edge markoKnowsJosh = new Edge("knows").source(marko).target(josh) + .property("date", "2013-02-20"); + Edge markoCreateLop = new Edge("created").source(marko).target(lop) + .property("date", + "2017-12-10"); + Edge joshCreateRipple = new Edge("created").source(josh).target(ripple) + .property("date", + "2017-12-10"); + Edge joshCreateLop = new Edge("created").source(josh).target(lop) + .property("date", "2009-11-11"); + Edge peterCreateLop = new Edge("created").source(peter).target(lop) + .property("date", + "2017-03-24"); + + List vertices = new ArrayList<>(); + vertices.add(marko); + vertices.add(vadas); + vertices.add(lop); + vertices.add(josh); + vertices.add(ripple); + vertices.add(peter); + + List edges = new ArrayList<>(); + edges.add(markoKnowsVadas); + edges.add(markoKnowsJosh); + edges.add(markoCreateLop); + edges.add(joshCreateRipple); + edges.add(joshCreateLop); + edges.add(peterCreateLop); + + vertices = graph.addVertices(vertices); + vertices.forEach(vertex -> System.out.println(vertex)); + + edges = graph.addEdges(edges, false); + edges.forEach(edge -> System.out.println(edge)); + + hugeClient.close(); + } } - -resultSet.close(); -``` - -### Connection Pool Configuration - -```java -import org.apache.hugegraph.store.client.HgStoreClientConfig; - -// Configure client -HgStoreClientConfig config = HgStoreClientConfig.builder() - .pdPeers(pdPeers) - .maxSessions(10) // Max sessions per Store node - .sessionTimeout(30000) // Session timeout (ms) - .rpcTimeout(10000) // RPC timeout (ms) - .maxRetries(3) // Max retry attempts - .retryInterval(1000) // Retry interval (ms) - .build(); - -HgStoreClient client = HgStoreClient.create(config); ``` --- @@ -332,55 +443,6 @@ HgStoreClient client = HgStoreClient.create(config); - Send request to leader Store ``` -### Partition Routing - -**Example**: Write vertex with ID `"person:1001"` - -```java -// 1. Client hashes the key -String key = "vertex:person:1001"; -int hash = MurmurHash3.hash32(key); // e.g., 0x12345678 - -// 2. Client queries PD: which partition owns this hash? -Partition partition = pdClient.getPartitionByHash(graphName, hash); -// PD responds: Partition 5 - -// 3. Client queries PD: who is the leader of Partition 5? -Shard leader = partition.getLeader(); -// PD responds: Store 2 (192.168.1.21:8500) - -// 4. Client sends write request to Store 2 -storeClient.put(leader.getStoreAddress(), tableName, key, value); -``` - -**Caching**: -- Client caches partition metadata (refreshed every 60 seconds) -- On leader change, client receives redirect response and updates cache - -### Handling PD Failures - -**Scenario**: PD cluster is temporarily unavailable - -**Client Behavior**: -1. **Short outage** (<60 seconds): - - Client uses cached partition metadata - - Operations continue normally - - Client retries PD connection in background - -2. **Long outage** (>60 seconds): - - Cached metadata may become stale (e.g., leader changed) - - Client may send requests to wrong Store node - - Store node redirects client to current leader - - Client updates cache and retries - -3. **Complete PD failure**: - - Client cannot discover new Store nodes or partitions - - Existing operations work, but cluster cannot scale or rebalance - -**Recommendation**: Always run PD in a 3-node or 5-node cluster for high availability - ---- - ## Migration from Other Backends ### RocksDB Embedded to Store @@ -453,13 +515,13 @@ bin/hugegraph-restore.sh \ ```bash # Check vertex count -curl http://localhost:8080/graphs/hugegraph/graph/vertices?limit=0 +curl http://localhost:8080/graphspaces/{graphspace_name}/graphs/{graph_name}/graph/vertices # Check edge count -curl http://localhost:8080/graphs/hugegraph/graph/edges?limit=0 +curl http://localhost:8080/graphspaces/{graphspace_name}/graphs/{graph_name}/graph/edges # Run sample queries -curl http://localhost:8080/graphs/hugegraph/graph/vertices?label=person&limit=10 +curl http://localhost:8080/graphspaces/{graphspace_name}/graphs/{graph_name}/graph/vertices/{id} ``` --- @@ -577,10 +639,10 @@ graph.name=analytics **Access**: ```bash # Production graph -curl http://localhost:8080/graphs/production/graph/vertices +curl "http://192.168.1.30:8080/graphspaces/{graphspace_name}/graphs/production/graph/vertices" # Analytics graph -curl http://localhost:8080/graphs/analytics/graph/vertices +curl "http://192.168.1.30:8080/graphspaces/{graphspace_name}/graphs/analytics/graph/vertices" ``` ### Mixed Backend Configuration @@ -615,7 +677,7 @@ ERROR o.a.h.b.s.h.HstoreProvider - Failed to connect to PD cluster **Diagnosis**: ```bash # Check PD is running -curl http://192.168.1.10:8620/actuator/health +curl http://192.168.1.10:8620/v1/health # Check network connectivity telnet 192.168.1.10 8686 @@ -641,10 +703,10 @@ tail -f logs/hugegraph-server.log | grep PD **Diagnosis**: ```bash # Check Store node health -curl http://192.168.1.20:8520/actuator/metrics +curl http://192.168.1.20:8520/v1/health # Check partition distribution -curl http://192.168.1.10:8620/pd/v1/partitions +curl http://192.168.1.10:8620/v1/partitions # Check if queries are using indexes # (Enable query logging in Server) @@ -652,11 +714,6 @@ curl http://192.168.1.10:8620/pd/v1/partitions **Solutions**: 1. **Create indexes**: Ensure label and property indexes exist - ```groovy - // In Gremlin console - schema.indexLabel("personByName").onV("person").by("name").secondary().create() - ``` - 2. **Increase Store nodes**: If data exceeds capacity of 3 nodes 3. **Tune RocksDB**: See [Best Practices](best-practices.md) 4. **Enable query pushdown**: Ensure Server is using Store's query API @@ -676,10 +733,10 @@ ERROR o.a.h.b.s.h.HstoreSession - Write operation failed: Raft leader not found tail -f logs/hugegraph-store.log | grep Raft # Check partition leaders -curl http://192.168.1.10:8620/pd/v1/partitions | grep leader +curl http://192.168.1.10:8620/v1/partitions | grep leader # Check Store node states -curl http://192.168.1.10:8620/pd/v1/stores +curl http://192.168.1.10:8620/v1/stores ``` **Solutions**: @@ -699,7 +756,7 @@ curl http://192.168.1.10:8620/pd/v1/stores **Diagnosis**: ```bash # Compare counts -curl http://localhost:8080/graphs/hugegraph/graph/vertices?limit=0 +curl http://localhost:8080/graphspaces/{graphspace_name}/graphs/{graph_name}/graph/vertices # vs expected count from backup # Check for restore errors @@ -710,7 +767,7 @@ tail -f logs/hugegraph-tools.log | grep ERROR 1. **Re-run restore**: Delete graph and restore again ```bash # Clear graph - curl -X DELETE http://localhost:8080/graphs/hugegraph/graph/vertices + curl -X DELETE http://localhost:8080/graphspaces/{graphspace_name}/graphs/{graph_name}/graph/vertices/{id} # Restore bin/hugegraph-restore.sh --graph hugegraph --directory /backup/data @@ -738,12 +795,6 @@ jmap -dump:format=b,file=heap.bin **Solutions**: 1. **Close sessions**: Ensure `HgStoreSession.close()` is called - ```java - try (HgStoreSession session = client.openSession(graphName)) { - // Use session - } // Auto-closed - ``` - 2. **Tune connection pool**: Reduce `store.max_sessions` if too high 3. **Increase heap**: Increase Server JVM heap size ```bash diff --git a/hugegraph-store/docs/operations-guide.md b/hugegraph-store/docs/operations-guide.md index 47023d3c9a..f46b5559d7 100644 --- a/hugegraph-store/docs/operations-guide.md +++ b/hugegraph-store/docs/operations-guide.md @@ -52,15 +52,6 @@ curl http://:8620/actuator/metrics - **Normal**: <30,000ms (30 seconds) - **Warning**: >60,000ms (large partition or slow disk) -**Queries**: -```bash -# Check leader election count -curl http://192.168.1.20:8520/actuator/metrics/raft.leader.election.count - -# Check log apply latency -curl http://192.168.1.20:8520/actuator/metrics/raft.log.apply.latency -``` - #### 2. RocksDB Metrics **Metric**: `rocksdb.read.latency` @@ -83,12 +74,6 @@ curl http://192.168.1.20:8520/actuator/metrics/raft.log.apply.latency - **Normal**: >90% - **Warning**: <70% (increase cache size) -**Queries**: -```bash -curl http://192.168.1.20:8520/actuator/metrics/rocksdb.read.latency -curl http://192.168.1.20:8520/actuator/metrics/rocksdb.compaction.pending -``` - #### 3. Partition Metrics **Metric**: `partition.count` @@ -103,14 +88,15 @@ curl http://192.168.1.20:8520/actuator/metrics/rocksdb.compaction.pending **Queries**: ```bash -# Check partition distribution (via PD) -curl http://192.168.1.10:8620/pd/v1/stats/partition-distribution +# Check partition distribution +curl http://localhost:8620/v1/partitionsAndStats -# Expected output: +# Example output (imbalanced): # { -# "store_1": {"total": 12, "leaders": 4}, -# "store_2": {"total": 12, "leaders": 4}, -# "store_3": {"total": 12, "leaders": 4} +# { +# "partitions": {}, +# "partitionStats: {}" +# } # } ``` @@ -272,13 +258,14 @@ curl http://192.168.1.10:8620/pd/v1/partitions | jq '.[] | select(.leader == nul **Diagnosis**: ```bash # Check partition distribution -curl http://192.168.1.10:8620/pd/v1/stats/partition-distribution +curl http://localhost:8620/v1/partitionsAndStats # Example output (imbalanced): # { -# "store_1": {"total": 20, "leaders": 15}, -# "store_2": {"total": 8, "leaders": 2}, -# "store_3": {"total": 8, "leaders": 1} +# { +# "partitions": {}, +# "partitionStats: {}" +# } # } ``` @@ -290,7 +277,7 @@ curl http://192.168.1.10:8620/pd/v1/stats/partition-distribution **Solutions**: 1. **Trigger Manual Rebalance** (via PD API): ```bash - curl -X POST http://192.168.1.10:8620/pd/v1/balance/trigger + curl http://192.168.1.10:8620/v1/balanceLeaders ``` 2. **Reduce Patrol Interval** (in PD `application.yml`): @@ -347,7 +334,7 @@ iostat -x 1 4. **Monitor Progress**: ```bash # Check partition state transitions - curl http://192.168.1.10:8620/pd/v1/partitions | grep -i migrating + curl http://192.168.1.10:8620/v1/partitions | grep -i migrating ``` --- @@ -361,10 +348,6 @@ iostat -x 1 **Diagnosis**: ```bash -# Check RocksDB stats -curl http://192.168.1.20:8520/actuator/metrics/rocksdb.compaction.pending -curl http://192.168.1.20:8520/actuator/metrics/rocksdb.block.cache.hit.rate - # Check Store logs for compaction tail -f logs/hugegraph-store.log | grep compaction ``` @@ -388,13 +371,7 @@ tail -f logs/hugegraph-store.log | grep compaction max_write_buffer_number: 8 # More memtables ``` -3. **Manual Compaction** (if safe): - ```bash - # Trigger compaction via Store admin API - curl -X POST http://192.168.1.20:8520/admin/rocksdb/compact - ``` - -4. **Restart Store Node** (last resort, triggers compaction on startup): +3. **Restart Store Node** (last resort, triggers compaction on startup): ```bash bin/stop-hugegraph-store.sh bin/start-hugegraph-store.sh @@ -496,58 +473,6 @@ scp backup-store1-*.tar.gz backup-server:/backups/ - Requires all Store nodes to be backed up - May miss recent writes (since last snapshot) -#### Strategy 2: RocksDB Checkpoint - -**Frequency**: Before major operations (upgrades, schema changes) - -**Process**: -```bash -# Trigger checkpoint via Store API -curl -X POST http://192.168.1.20:8520/admin/rocksdb/checkpoint - -# Checkpoint created in storage/rocksdb-checkpoint/ -tar -czf backup-checkpoint-$(date +%Y%m%d).tar.gz storage/rocksdb-checkpoint/ - -# Upload to backup server -scp backup-checkpoint-*.tar.gz backup-server:/backups/ -``` - -**Pros**: -- Consistent checkpoint -- Can be restored to a single node (for testing) - -**Cons**: -- Larger backup size -- Slower than snapshot - -#### Strategy 3: Logical Backup (via HugeGraph API) - -**Frequency**: Weekly or monthly - -**Process**: -```bash -# Use HugeGraph-Tools -cd hugegraph-tools - -bin/hugegraph-backup.sh \ - --graph hugegraph \ - --directory /backups/logical-$(date +%Y%m%d) \ - --format json - -# Backup includes: -# - schema.json -# - vertices.json -# - edges.json -``` - -**Pros**: -- Backend-agnostic (can restore to different backend) -- Human-readable format - -**Cons**: -- Slower (especially for large graphs) -- Requires Server to be running - ### Disaster Recovery Procedures #### Scenario 1: Single Store Node Failure @@ -558,7 +483,7 @@ bin/hugegraph-backup.sh \ 1. **No immediate action needed**: Remaining replicas continue serving 2. **Monitor**: Check if Raft leaders re-elected ```bash - curl http://192.168.1.10:8620/pd/v1/partitions | grep leader + curl http://192.168.1.10:8620/v1/partitions | grep leader ``` 3. **Replace Failed Node**: @@ -568,7 +493,7 @@ bin/hugegraph-backup.sh \ 4. **Verify**: Check partition distribution ```bash - curl http://192.168.1.10:8620/pd/v1/stats/partition-distribution + curl http://localhost:8620/v1/partitionsAndStats ``` #### Scenario 2: Complete Store Cluster Failure @@ -597,7 +522,7 @@ bin/hugegraph-backup.sh \ 4. **Verify Data**: ```bash # Check via Server - curl http://192.168.1.30:8080/graphs/hugegraph/graph/vertices?limit=10 + curl http://192.168.1.30:8080/graphspaces/{graphspaces_name}/graphs/{graph_name}/vertices?limit=10 ``` #### Scenario 3: Data Corruption @@ -651,7 +576,7 @@ du -sh storage/ **Partition Count**: ```bash # Current partition count -curl http://192.168.1.10:8620/pd/v1/stats/partition-count +curl http://192.168.1.10:8620/v1/partitionsAndStatus # Recommendation: 3-5x Store node count # Example: 6 Store nodes → 18-30 partitions @@ -668,6 +593,7 @@ curl http://192.168.1.10:8620/pd/v1/stats/partition-count 1. **Deploy New Store Node**: ```bash # Follow deployment guide + # Historical 1.7.0 packages still include the "-incubating" suffix tar -xzf apache-hugegraph-store-incubating-1.7.0.tar.gz cd apache-hugegraph-store-incubating-1.7.0 @@ -678,19 +604,19 @@ curl http://192.168.1.10:8620/pd/v1/stats/partition-count 2. **Verify Registration**: ```bash - curl http://192.168.1.10:8620/pd/v1/stores + curl http://192.168.1.10:8620/v1/stores # New Store should appear ``` 3. **Trigger Rebalancing** (optional): ```bash - curl -X POST http://192.168.1.10:8620/pd/v1/balance/trigger + curl -X POST http://192.168.1.10:8620/v1/balanceLeaders ``` 4. **Monitor Rebalancing**: ```bash # Watch partition distribution - watch -n 10 'curl -s http://192.168.1.10:8620/pd/v1/stats/partition-distribution' + watch -n 10 'curl http://192.168.1.10:8620/v1/partitionsAndStatus' ``` 5. **Verify**: Wait for even distribution (may take hours) @@ -703,17 +629,17 @@ curl http://192.168.1.10:8620/pd/v1/stats/partition-count **Process**: 1. **Mark Store for Removal** (via PD API): - ```bash - curl -X POST http://192.168.1.10:8620/pd/v1/stores/3/decommission - ``` + ```bash + curl --location --request POST 'http://localhost:8080/store/123' \ + --header 'Content-Type: application/json' \ + --data-raw '{ + "storeState": "Off" + }' + ``` + Refer to API definition in `StoreAPI::setStore` 2. **Wait for Migration**: - PD migrates all partitions off this Store - - Monitor: - ```bash - curl http://192.168.1.10:8620/pd/v1/stores/3 - # Check partition count → should reach 0 - ``` 3. **Stop Store Node**: ```bash @@ -721,9 +647,6 @@ curl http://192.168.1.10:8620/pd/v1/stats/partition-count ``` 4. **Remove from PD** (optional): - ```bash - curl -X DELETE http://192.168.1.10:8620/pd/v1/stores/3 - ``` --- @@ -750,9 +673,9 @@ bin/stop-hugegraph-store.sh # Backup current version mv apache-hugegraph-store-incubating-1.7.0 apache-hugegraph-store-incubating-1.7.0-backup -# Extract new version -tar -xzf apache-hugegraph-store-incubating-1.8.0.tar.gz -cd apache-hugegraph-store-incubating-1.8.0 +# Extract new version (newer releases no longer include "-incubating") +tar -xzf apache-hugegraph-store-1.8.0.tar.gz +cd apache-hugegraph-store-1.8.0 # Copy configuration from backup cp ../apache-hugegraph-store-incubating-1.7.0-backup/conf/application.yml conf/ @@ -761,7 +684,7 @@ cp ../apache-hugegraph-store-incubating-1.7.0-backup/conf/application.yml conf/ bin/start-hugegraph-store.sh # Verify -curl http://192.168.1.20:8520/actuator/health +curl http://192.168.1.20:8520/v1/health tail -f logs/hugegraph-store.log ``` @@ -792,7 +715,7 @@ If upgrade fails: bin/stop-hugegraph-store.sh # Restore backup -rm -rf apache-hugegraph-store-incubating-1.8.0 +rm -rf apache-hugegraph-store-1.8.0 mv apache-hugegraph-store-incubating-1.7.0-backup apache-hugegraph-store-incubating-1.7.0 cd apache-hugegraph-store-incubating-1.7.0 diff --git a/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/Load.java b/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/Load.java index 0fbe10d01e..a134d689c2 100644 --- a/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/Load.java +++ b/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/Load.java @@ -121,10 +121,9 @@ public void action(String[] params) throws InterruptedException { for (int i = 0; i < readerSize; i++) { int fi = i; new Thread(() -> { - try { - InputStreamReader isr = new InputStreamReader(new FileInputStream(split[fi]), - StandardCharsets.UTF_8); - BufferedReader reader = new BufferedReader(isr); + try(InputStreamReader isr = new InputStreamReader(new FileInputStream(split[fi]), + StandardCharsets.UTF_8); + BufferedReader reader = new BufferedReader(isr)) { long count = 0; String line; try { @@ -146,9 +145,6 @@ public void action(String[] params) throws InterruptedException { } } catch (Exception e) { throw new RuntimeException(e); - } finally { - isr.close(); - reader.close(); } } catch (Exception e) { log.error("send data with error:", e); @@ -158,13 +154,12 @@ public void action(String[] params) throws InterruptedException { }).start(); } latch.await(); - loadThread.join(); completed.set(true); + loadThread.join(); } public boolean put(String table, List keys) { HgStoreSession session = storeClient.openSession(graph); - session.beginTx(); try { session.beginTx(); for (String key : keys) { diff --git a/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/MultiQuery.java b/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/MultiQuery.java index 6bcc4e3d9b..2128e7fe06 100644 --- a/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/MultiQuery.java +++ b/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/MultiQuery.java @@ -101,7 +101,7 @@ public boolean hasNext() { current = (HgOwnerKey) queue[finalI].poll(1, TimeUnit.SECONDS); } catch (InterruptedException e) { - // + Thread.currentThread().interrupt(); } } if (current == null) { diff --git a/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/ScanTable.java b/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/ScanTable.java index e46e59795b..e8ebda772d 100644 --- a/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/ScanTable.java +++ b/hugegraph-store/hg-store-cli/src/main/java/org/apache/hugegraph/store/cli/cmd/ScanTable.java @@ -73,7 +73,7 @@ public void action(String[] params) throws PDException { if (iterator.hasNext()) { iterator.next(); position = iterator.position(); - System.out.println("count is " + count); + log.info("count is {}", count); } else { position = null; } diff --git a/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/query/QueryExecutor.java b/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/query/QueryExecutor.java index e5e6672734..b4102bb373 100644 --- a/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/query/QueryExecutor.java +++ b/hugegraph-store/hg-store-client/src/main/java/org/apache/hugegraph/store/client/query/QueryExecutor.java @@ -73,12 +73,15 @@ public class QueryExecutor { private final HugeGraphSupplier supplier; - private long timeout = 1800_000; + /** + * Timeout duration for StreamObserver receiving response + */ + private long timeout = 60_000; /** * Used for testing single machine */ - public static String filterStore = null; + private static final ThreadLocal filterStore = new ThreadLocal<>(); public QueryExecutor(HgStoreNodePartitioner nodePartitioner, HugeGraphSupplier supplier, Long timeout) { @@ -123,12 +126,20 @@ public List> getIterators(StoreQueryParam query) throw if (o1 == null && o2 == null) { return 0; } - - if (o1 != null) { - return ((KvElement) o1).compareTo((KvElement) o2); + if (o1 != null && o2 != null) { + if (o1 instanceof KvElement && o2 instanceof KvElement) { + return ((KvElement) o1).compareTo((KvElement) o2); + } + if (!(o1 instanceof KvElement)) { + throw new IllegalStateException( + "Expected KvElement but got: " + o1.getClass().getName()); + } + // !(o2 instanceof KvElement) + throw new IllegalStateException( + "Expected KvElement but got: " + o2.getClass().getName()); } - return 0; + return o1 != null ? 1 : -1; }); iterator = new StreamFinalAggregationIterator<>(iterator, query.getFuncList()); @@ -277,9 +288,10 @@ private List> getNodeTasks(StoreQueryParam } } - if (filterStore != null) { - return tasks.containsKey(filterStore) ? - List.of(Tuple2.of(filterStore, tasks.get(filterStore))) : List.of(); + if (filterStore.get() != null) { + String filterStoreStr = filterStore.get(); + return tasks.containsKey(filterStoreStr) ? + List.of(Tuple2.of(filterStoreStr, tasks.get(filterStoreStr))) : List.of(); } return tasks.entrySet().stream() diff --git a/hugegraph-store/hg-store-common/src/main/java/org/apache/hugegraph/store/query/func/AggregationFunctions.java b/hugegraph-store/hg-store-common/src/main/java/org/apache/hugegraph/store/query/func/AggregationFunctions.java index ee84f87893..23157b1e4b 100644 --- a/hugegraph-store/hg-store-common/src/main/java/org/apache/hugegraph/store/query/func/AggregationFunctions.java +++ b/hugegraph-store/hg-store-common/src/main/java/org/apache/hugegraph/store/query/func/AggregationFunctions.java @@ -79,8 +79,11 @@ public void iterate(T record) { ((AtomicFloat) buffer).getAndAdd((Float) record); break; default: - // throw new Exception ? - break; + // throw new Exception + throw new IllegalStateException( + "Unsupported buffer type: " + buffer.getClass().getName() + + ". Supported types: AtomicLong, AtomicInteger, AtomicDouble, AtomicFloat" + ); } } } diff --git a/hugegraph-store/hg-store-core/pom.xml b/hugegraph-store/hg-store-core/pom.xml index 18abe4937f..0ecf723280 100644 --- a/hugegraph-store/hg-store-core/pom.xml +++ b/hugegraph-store/hg-store-core/pom.xml @@ -178,6 +178,40 @@ hg-store-client test + + org.apache.hugegraph + hg-pd-core + ${revision} + + + + + org.apache.maven.plugins + maven-resources-plugin + + + generate-version + process-resources + + copy-resources + + + ${project.build.directory}/classes + + + src/main/resources + true + + version.txt + + + + + + + + + diff --git a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/PartitionEngine.java b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/PartitionEngine.java index 3b4a8427ed..a70f17465f 100644 --- a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/PartitionEngine.java +++ b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/PartitionEngine.java @@ -42,6 +42,7 @@ import org.apache.hugegraph.pd.common.PDException; import org.apache.hugegraph.pd.grpc.MetaTask; import org.apache.hugegraph.pd.grpc.Metapb; +import org.apache.hugegraph.pd.raft.RaftReflectionUtil; import org.apache.hugegraph.store.business.BusinessHandler; import org.apache.hugegraph.store.business.BusinessHandlerImpl; import org.apache.hugegraph.store.cmd.HgCmdClient; @@ -1146,51 +1147,7 @@ public Configuration getCurrentConf() { } private Replicator.State getReplicatorState(PeerId peerId) { - var replicateGroup = getReplicatorGroup(); - if (replicateGroup == null) { - return null; - } - - ThreadId threadId = replicateGroup.getReplicator(peerId); - if (threadId == null) { - return null; - } else { - Replicator r = (Replicator) threadId.lock(); - if (r == null) { - return Replicator.State.Probe; - } - Replicator.State result = getState(r); - threadId.unlock(); - return result; - } - } - - private ReplicatorGroup getReplicatorGroup() { - var clz = this.raftNode.getClass(); - try { - var f = clz.getDeclaredField("replicatorGroup"); - f.setAccessible(true); - var group = (ReplicatorGroup) f.get(this.raftNode); - f.setAccessible(false); - return group; - } catch (NoSuchFieldException | IllegalAccessException e) { - log.info("getReplicatorGroup: error {}", e.getMessage()); - return null; - } - } - - private Replicator.State getState(Replicator r) { - var clz = r.getClass(); - try { - var f = clz.getDeclaredField("state"); - f.setAccessible(true); - var state = (Replicator.State) f.get(this.raftNode); - f.setAccessible(false); - return state; - } catch (NoSuchFieldException | IllegalAccessException e) { - log.info("getReplicatorGroup: error {}", e.getMessage()); - return null; - } + return RaftReflectionUtil.getReplicatorState(this.raftNode, peerId); } class ReplicatorStateListener implements Replicator.ReplicatorStateListener { diff --git a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandlerImpl.java b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandlerImpl.java index 307e5fc570..9287bfe267 100644 --- a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandlerImpl.java +++ b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/business/BusinessHandlerImpl.java @@ -130,13 +130,17 @@ public class BusinessHandlerImpl implements BusinessHandler { }}; private static final Map dbNames = new ConcurrentHashMap<>(); private static HugeGraphSupplier mockGraphSupplier = null; - private static final int compactionThreadCount = 64; private static final ConcurrentMap pathLock = new ConcurrentHashMap<>(); private static final ConcurrentMap compactionState = new ConcurrentHashMap<>(); + // Default core thread count + private static final int compactionThreadCount = 64; + private static final int compactionMaxThreadCount = 256; + // Max size of compaction queue + private static final int compactionQueueSize = 1000; private static final ThreadPoolExecutor compactionPool = ExecutorUtil.createExecutor(PoolNames.COMPACT, compactionThreadCount, - compactionThreadCount * 4, Integer.MAX_VALUE); + compactionMaxThreadCount, compactionQueueSize); private static final int timeoutMillis = 6 * 3600 * 1000; private final BinaryElementSerializer serializer = BinaryElementSerializer.getInstance(); private final DirectBinarySerializer directBinarySerializer = new DirectBinarySerializer(); @@ -1667,4 +1671,8 @@ public void rollback() throws HgStoreException { }; } } + + public static void clearCache() { + GRAPH_SUPPLIER_CACHE.clear(); + } } diff --git a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/cmd/request/DestroyRaftRequest.java b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/cmd/request/DestroyRaftRequest.java index ecd7e7cf0e..b9e61837d3 100644 --- a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/cmd/request/DestroyRaftRequest.java +++ b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/cmd/request/DestroyRaftRequest.java @@ -27,7 +27,7 @@ @Data public class DestroyRaftRequest extends HgCmdBase.BaseRequest { - private List graphNames = new ArrayList<>(); + private final List graphNames = new ArrayList<>(); public void addGraphName(String graphName) { graphNames.add(graphName); diff --git a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/CopyOnWriteCache.java b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/CopyOnWriteCache.java index f07a5a0182..b20eac39f9 100644 --- a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/CopyOnWriteCache.java +++ b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/CopyOnWriteCache.java @@ -20,6 +20,7 @@ import java.util.Collection; import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentMap; @@ -29,7 +30,9 @@ import org.jetbrains.annotations.NotNull; -//FIXME Missing shutdown method +import lombok.extern.slf4j.Slf4j; + +@Slf4j public class CopyOnWriteCache implements ConcurrentMap { // Scheduled executor service for periodically clearing the cache. @@ -263,4 +266,23 @@ public synchronized V replace(K k, V v) { return null; } } + + public void close(){ + scheduledExecutor.shutdown(); + try { + boolean isTerminated = scheduledExecutor.awaitTermination(30, TimeUnit.SECONDS); + if (!isTerminated) { + List runnables = scheduledExecutor.shutdownNow(); + log.info("CopyOnWriteCache shutting down with {} tasks left", runnables.size()); + + boolean isNowTerminated = scheduledExecutor.awaitTermination(30, TimeUnit.SECONDS); + if (!isNowTerminated) { + log.warn("Failed to shutdown CopyOnWriteCache thread pool"); + } + } + }catch (InterruptedException e) { + scheduledExecutor.shutdownNow(); + Thread.currentThread().interrupt(); + } + } } diff --git a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/Version.java b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/Version.java index a17bd3722a..87b36b59af 100644 --- a/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/Version.java +++ b/hugegraph-store/hg-store-core/src/main/java/org/apache/hugegraph/store/util/Version.java @@ -34,7 +34,7 @@ public static String getVersion() { try (InputStream is = Version.class.getResourceAsStream("/version.txt")) { byte[] buf = new byte[64]; int len = is.read(buf); - version = new String(buf, 0, len); + version = new String(buf, 0, len).trim(); } catch (Exception e) { log.error("Version.getVersion exception: ", e); } diff --git a/hugegraph-store/hg-store-core/src/main/resources/version.txt b/hugegraph-store/hg-store-core/src/main/resources/version.txt new file mode 100644 index 0000000000..4d31294f7d --- /dev/null +++ b/hugegraph-store/hg-store-core/src/main/resources/version.txt @@ -0,0 +1 @@ +${revision} diff --git a/hugegraph-store/hg-store-dist/docker/docker-entrypoint.sh b/hugegraph-store/hg-store-dist/docker/docker-entrypoint.sh old mode 100644 new mode 100755 index 5aa77621dc..1bdaaafc5a --- a/hugegraph-store/hg-store-dist/docker/docker-entrypoint.sh +++ b/hugegraph-store/hg-store-dist/docker/docker-entrypoint.sh @@ -15,8 +15,67 @@ # See the License for the specific language governing permissions and # limitations under the License. # +set -euo pipefail -# start hugegraph store -./bin/start-hugegraph-store.sh -j "$JAVA_OPTS" +log() { echo "[hugegraph-store-entrypoint] $*"; } +require_env() { + local name="$1" + if [[ -z "${!name:-}" ]]; then + echo "ERROR: missing required env '${name}'" >&2; exit 2 + fi +} + +json_escape() { + local s="$1" + s=${s//\\/\\\\}; s=${s//\"/\\\"}; s=${s//$'\n'/} + printf "%s" "$s" +} + +# ── Guard deprecated vars ───────────────────────────────────────────── +migrate_env() { + local old_name="$1" new_name="$2" + + if [[ -n "${!old_name:-}" && -z "${!new_name:-}" ]]; then + log "WARN: deprecated env '${old_name}' detected; mapping to '${new_name}'" + export "${new_name}=${!old_name}" + fi +} + +migrate_env "PD_ADDRESS" "HG_STORE_PD_ADDRESS" +migrate_env "GRPC_HOST" "HG_STORE_GRPC_HOST" +migrate_env "RAFT_ADDRESS" "HG_STORE_RAFT_ADDRESS" +# ── Required vars ───────────────────────────────────────────────────── +require_env "HG_STORE_PD_ADDRESS" +require_env "HG_STORE_GRPC_HOST" +require_env "HG_STORE_RAFT_ADDRESS" + +# ── Defaults ────────────────────────────────────────────────────────── +: "${HG_STORE_GRPC_PORT:=8500}" +: "${HG_STORE_REST_PORT:=8520}" +: "${HG_STORE_DATA_PATH:=/hugegraph-store/storage}" + +# ── Build SPRING_APPLICATION_JSON ───────────────────────────────────── +SPRING_APPLICATION_JSON="$(cat <> ${OUTPUT} 2>&1 & - -PID="$!" -# Write pid to file -echo "$PID" > "$PID_FILE" -echo "[+pid] $PID" +# Turn on security check +if [[ $DAEMON == "true" ]]; then + echo "Starting HugeGraphStoreServer in daemon mode..." + if [[ "${STDOUT_MODE:-false}" == "true" ]]; then + exec ${JAVA} -Dname="HugeGraphStore" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml \ + ${LIB}/hg-store-node-*.jar & + else + exec ${JAVA} -Dname="HugeGraphStore" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml \ + ${LIB}/hg-store-node-*.jar >> ${OUTPUT} 2>&1 & + fi + PID="$!" + # Write pid to file + echo "$PID" > "$PID_FILE" + echo "[+pid] $PID" +else + echo "Starting HugeGraphStoreServer in foreground mode..." + # Write $$ before exec — exec replaces this shell with Java, so $$ becomes Java's PID + echo "$$" > "$PID_FILE" + echo "[+pid] $$" + if [[ "${STDOUT_MODE:-false}" == "true" ]]; then + exec ${JAVA} -Dname="HugeGraphStore" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml \ + ${LIB}/hg-store-node-*.jar + else + exec ${JAVA} -Dname="HugeGraphStore" ${JVM_OPTIONS} ${JAVA_OPTIONS} -jar \ + -Dspring.config.location=${CONF}/application.yml \ + ${LIB}/hg-store-node-*.jar >> ${OUTPUT} 2>&1 + fi +fi diff --git a/hugegraph-store/hg-store-dist/src/assembly/static/bin/util.sh b/hugegraph-store/hg-store-dist/src/assembly/static/bin/util.sh index 93b55311cb..3b3d660102 100644 --- a/hugegraph-store/hg-store-dist/src/assembly/static/bin/util.sh +++ b/hugegraph-store/hg-store-dist/src/assembly/static/bin/util.sh @@ -82,7 +82,7 @@ function process_id() { # check the port of rest server is occupied function check_port() { - local port=`echo $1 | awk -F':' '{print $3}'` + local port=$(echo "$1" | sed 's|.*:||' | sed 's|/.*||') if ! command_available "lsof"; then echo "Required lsof but it is unavailable" exit 1 diff --git a/hugegraph-store/hg-store-dist/src/assembly/static/conf/log4j2.xml b/hugegraph-store/hg-store-dist/src/assembly/static/conf/log4j2.xml index 388d09e2fd..f0cf11fc3d 100644 --- a/hugegraph-store/hg-store-dist/src/assembly/static/conf/log4j2.xml +++ b/hugegraph-store/hg-store-dist/src/assembly/static/conf/log4j2.xml @@ -117,6 +117,7 @@ + diff --git a/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/AppConfig.java b/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/AppConfig.java index a8a1223271..3f1624c087 100644 --- a/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/AppConfig.java +++ b/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/AppConfig.java @@ -278,9 +278,9 @@ public class QueryPushDownConfig { private int fetchBatchSize; /** - * the timeout of request fetch + * the timeout of request fetch (ms) */ - @Value("${query.push-down.fetch_timeout:3600000}") + @Value("${query.push-down.fetch_timeout:300000}") private long fetchTimeOut; /** diff --git a/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/grpc/query/AggregativeQueryObserver.java b/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/grpc/query/AggregativeQueryObserver.java index 199d3ba550..0ba569cb92 100644 --- a/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/grpc/query/AggregativeQueryObserver.java +++ b/hugegraph-store/hg-store-node/src/main/java/org/apache/hugegraph/store/node/grpc/query/AggregativeQueryObserver.java @@ -60,10 +60,6 @@ public class AggregativeQueryObserver implements StreamObserver { private final AtomicInteger consumeCount = new AtomicInteger(0); private final AtomicInteger sendCount = new AtomicInteger(0); private final AtomicBoolean clientCanceled = new AtomicBoolean(false); - // private final ThreadLocal localBuilder = ThreadLocal.withInitial - // (QueryResponse::newBuilder); -// private final ThreadLocal localKvBuilder = ThreadLocal.withInitial -// (Kv::newBuilder); private final BinaryElementSerializer serializer = BinaryElementSerializer.getInstance(); private final StreamObserver sender; private volatile ScanIterator iterator = null; @@ -328,7 +324,7 @@ private void execute(ScanIterator itr) { try { recordCount++; executePipeline(itr.next()); - if (System.currentTimeMillis() - current > timeout * 1000) { + if (System.nanoTime() - current > timeout * 1_000_000) { throw new RuntimeException("execution timeout"); } } catch (EarlyStopException ignore) { diff --git a/hugegraph-store/hg-store-node/src/main/resources/log4j2-dev.xml b/hugegraph-store/hg-store-node/src/main/resources/log4j2-dev.xml index 379acebbae..9cf4a50b50 100644 --- a/hugegraph-store/hg-store-node/src/main/resources/log4j2-dev.xml +++ b/hugegraph-store/hg-store-node/src/main/resources/log4j2-dev.xml @@ -34,7 +34,7 @@ - + @@ -116,10 +116,7 @@ - - - diff --git a/hugegraph-store/pom.xml b/hugegraph-store/pom.xml index b9d7a0382b..9ff1e933e5 100644 --- a/hugegraph-store/pom.xml +++ b/hugegraph-store/pom.xml @@ -45,7 +45,7 @@ 2.15.0 - apache-${release.name}-store-incubating-${project.version} + apache-${release.name}-store-${project.version} diff --git a/hugegraph-struct/pom.xml b/hugegraph-struct/pom.xml index 62ad58ee94..509bd1ab5f 100644 --- a/hugegraph-struct/pom.xml +++ b/hugegraph-struct/pom.xml @@ -108,10 +108,12 @@ fastutil 8.1.0 + org.lz4 lz4-java - 1.7.1 + 1.8.1 org.apache.commons @@ -191,6 +193,12 @@ ikanalyzer 2012_u6 + + io.github.jbellis + jvector + 4.0.0-rc.2 + compile + diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/options/AuthOptions.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/options/AuthOptions.java index 3ae732e2e2..c61946ae8b 100644 --- a/hugegraph-struct/src/main/java/org/apache/hugegraph/options/AuthOptions.java +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/options/AuthOptions.java @@ -19,7 +19,6 @@ package org.apache.hugegraph.options; -import org.apache.hugegraph.config.ConfigListOption; import org.apache.hugegraph.config.ConfigOption; import org.apache.hugegraph.config.OptionHolder; @@ -82,8 +81,7 @@ public static synchronized AuthOptions instance() { new ConfigOption<>( "auth.authenticator", "The class path of authenticator implementation. " + - "e.g., org.apache.hugegraph.auth.StandardAuthenticator, " + - "or org.apache.hugegraph.auth.ConfigAuthenticator.", + "e.g., org.apache.hugegraph.auth.StandardAuthenticator.", null, "" ); @@ -97,24 +95,6 @@ public static synchronized AuthOptions instance() { "hugegraph" ); - public static final ConfigOption AUTH_ADMIN_TOKEN = - new ConfigOption<>( - "auth.admin_token", - "Token for administrator operations, " + - "only for org.apache.hugegraph.auth.ConfigAuthenticator.", - disallowEmpty(), - "162f7848-0b6d-4faf-b557-3a0797869c55" - ); - - public static final ConfigListOption AUTH_USER_TOKENS = - new ConfigListOption<>( - "auth.user_tokens", - "The map of user tokens with name and password, " + - "only for org.apache.hugegraph.auth.ConfigAuthenticator.", - disallowEmpty(), - "hugegraph:9fd95c9c-711b-415b-b85f-d4df46ba5c31" - ); - public static final ConfigOption AUTH_REMOTE_URL = new ConfigOption<>( "auth.remote_url", diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/query/Condition.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/query/Condition.java index 5c7d3e221c..0d1b7ad05b 100644 --- a/hugegraph-struct/src/main/java/org/apache/hugegraph/query/Condition.java +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/query/Condition.java @@ -437,7 +437,7 @@ private static boolean equals(final Object first, * * @param first is actual value, might be Number/Date or String, It is * probably that the `first` is serialized to String. - * @param second is value in query condition, must be Number/Date + * @param second is value in query condition, must be Number/Date/Boolean * @return the value 0 if first is numerically equal to second; * a value less than 0 if first is numerically less than * second; and a value greater than 0 if first is @@ -450,6 +450,8 @@ private static int compare(final Object first, final Object second) { (Number) second); } else if (second instanceof Date) { return compareDate(first, (Date) second); + } else if (second instanceof Boolean) { + return compareBoolean(first, (Boolean) second); } throw new IllegalArgumentException(String.format( @@ -472,6 +474,18 @@ private static int compareDate(Object first, Date second) { second, second.getClass().getSimpleName())); } + private static int compareBoolean(Object first, Boolean second) { + if (first instanceof Boolean) { + return Boolean.compare((Boolean) first, second); + } + + throw new IllegalArgumentException(String.format( + "Can't compare between %s(%s) and %s(%s)", + first, first == null ? null : + first.getClass().getSimpleName(), + second, second.getClass().getSimpleName())); + } + public static List tokenize(String str) { final ArrayList tokens = new ArrayList<>(); int previous = 0; diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/struct/schema/PropertyKey.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/struct/schema/PropertyKey.java index eaf02db04b..81dae36697 100644 --- a/hugegraph-struct/src/main/java/org/apache/hugegraph/struct/schema/PropertyKey.java +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/struct/schema/PropertyKey.java @@ -126,7 +126,22 @@ public void defineDefaultValue(Object value) { public Object defaultValue() { // TODO add a field default_value - return this.userdata().get(Userdata.DEFAULT_VALUE); + Object value = this.userdata().get(Userdata.DEFAULT_VALUE); + if (value == null) { + return null; + } + + // Userdata is reloaded from JSON as a raw Map, so a typed default + // value (e.g. Date) comes back as a String. Normalize it to the + // runtime type expected by this property key's data type. Idempotent + // for values already of the expected type. + Object raw = value; + if (this.cardinality == Cardinality.SET && value instanceof Collection && + !(value instanceof Set)) { + raw = new LinkedHashSet<>((Collection) value); + } + + return this.validValueOrThrow(raw); } public boolean hasSameContent(PropertyKey other) { diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/util/StringEncoding.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/util/StringEncoding.java index 7e9ab6d8f3..f4690d430d 100644 --- a/hugegraph-struct/src/main/java/org/apache/hugegraph/util/StringEncoding.java +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/util/StringEncoding.java @@ -56,6 +56,8 @@ public final class StringEncoding { private static final byte[] BYTES_EMPTY = new byte[0]; private static final int BLOCK_SIZE = 4096; + private static final int BCRYPT_WORK_FACTOR = 10; + static { final String ALG = "SHA-256"; try { @@ -165,7 +167,9 @@ public static String decompress(byte[] value, float bufferRatio) { } public static String hashPassword(String password) { - return BCrypt.hashpw(password, BCrypt.gensalt(4)); + // OWASP suggests 10 as a minimum and 12–14 for production; + // workFactor 12 is not used by default due to its 200+ ms cost. + return BCrypt.hashpw(password, BCrypt.gensalt(BCRYPT_WORK_FACTOR)); } public static boolean checkPassword(String candidatePassword, diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/AbstractVectorRuntime.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/AbstractVectorRuntime.java new file mode 100644 index 0000000000..a1ab4df097 --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/AbstractVectorRuntime.java @@ -0,0 +1,344 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.io.IOException; +import java.nio.channels.FileChannel; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.StandardCopyOption; +import java.nio.file.StandardOpenOption; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.apache.hugegraph.util.JsonUtilCommon; + +import io.github.jbellis.jvector.graph.GraphIndex; +import io.github.jbellis.jvector.graph.GraphIndexBuilder; +import io.github.jbellis.jvector.graph.disk.OnDiskGraphIndex; +import io.github.jbellis.jvector.vector.VectorSimilarityFunction; + +public abstract class AbstractVectorRuntime implements VectorIndexRuntime { + + public String basePath = ""; + protected static final String CURRENT_VERSION_LINK_NAME = "current"; + protected static final String TEMP_LINK_NAME = "current_temp"; + private static final String VERSION_PREFIX = "version_"; + protected static final String INDEX_FILE_NAME = "index.inline"; + protected static final String META_FILE_NAME = "vector_meta.json"; + + protected final ConcurrentMap> vectorMap = new ConcurrentHashMap<>(); + + public AbstractVectorRuntime(String basePath) { + this.basePath = basePath; + } + + public static class IndexContext { + + final Id indexLabelId; + + // for jvector + public final UpdatableRandomAccessVectorValues vectors; // per-index RAVV + public final GraphIndexBuilder builder; // owns the mutable OnHeapGraphIndex + VectorSimilarityFunction similarityFunction; + int dimension; + + // for recover and update + IndexContextMetaData metaData; + + public IndexContext(Id indexLabelId, + UpdatableRandomAccessVectorValues vectors, + GraphIndexBuilder builder, + long watermark, + int dimension, + VectorSimilarityFunction similarityFunction) { + this.indexLabelId = indexLabelId; + this.vectors = vectors; + this.builder = builder; + this.similarityFunction = similarityFunction; + this.dimension = dimension; + this.metaData = new IndexContextMetaData(0, watermark, false); + } + + GraphIndex graphView() { + return builder.getGraph(); + } + + public IndexContextMetaData metaData() { return metaData; } + + void setMetaData(IndexContextMetaData metaData) { this.metaData = metaData; } + + public static class IndexContextMetaData { + + private int nextVectorId; + private final long watermark; + private long currentMaxSequence; + private boolean isUpdateFromLog; + + public IndexContextMetaData(int nextVectorId, long watermark, boolean isUpdateFromLog) { + this.nextVectorId = nextVectorId; + this.watermark = watermark; + this.isUpdateFromLog = isUpdateFromLog; + } + + int getNextVectorId() { + this.nextVectorId++; + return nextVectorId; + } + + void setNextVectorId(int nextVectorId) { + this.nextVectorId = nextVectorId; + } + + void setCurrentMaxSequence(long currentMaxSequence) { + this.currentMaxSequence = currentMaxSequence; + } + + long getCurrentMaxSequence() { + this.currentMaxSequence++; + return this.currentMaxSequence; + } + + public long getWatermark() { return watermark; } + + public boolean isUpdateFromLog() { + return isUpdateFromLog; + } + + public void setUpdateFromLog(boolean isUpdateFromLog) { + this.isUpdateFromLog = isUpdateFromLog; + } + } + } + + @Override + public void init() { + // read the properties + + } + + @Override + public void stop() throws IOException { + // flush all the context to disk + for (Map.Entry> e : vectorMap.entrySet()) { + Id indexLabelId = e.getKey(); + flush(indexLabelId); + } + } + + @Override + public void flush(Id indexlabelId) throws IOException { + IndexContext context = obtainContext(indexlabelId); + String pathString = basePath + "/" + (indexlabelId) + "/"; + Path indexBaseDir = Paths.get(pathString); + + // create temp path + String timestamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); + Path newVersionDir = indexBaseDir.resolve(VERSION_PREFIX + "_" + timestamp); + Files.createDirectories(newVersionDir); + + try { + Path indexPath = newVersionDir.resolve(INDEX_FILE_NAME); + // Create the file first (required by OnDiskGraphIndex.write) + Files.createFile(indexPath); + context.builder.cleanup(); + OnDiskGraphIndex.write(context.builder.getGraph(), context.vectors, indexPath); + + Path metaPath = newVersionDir.resolve(META_FILE_NAME); + Files.write(metaPath, JsonUtilCommon.toJson(context.metaData()).getBytes()); + + // Sync to filesystem + forceSyncDirectory(newVersionDir); + + // Create a temp symlink pointing to the new version + Path tempSymlink = indexBaseDir.resolve(TEMP_LINK_NAME); + Files.deleteIfExists(tempSymlink); + Files.createSymbolicLink(tempSymlink, newVersionDir); + + // Atomically switch the 'current' symlink + Path currentLink = indexBaseDir.resolve(CURRENT_VERSION_LINK_NAME); + if (Files.isSymbolicLink(currentLink)) { + Files.move(tempSymlink, currentLink, + StandardCopyOption.ATOMIC_MOVE, + StandardCopyOption.REPLACE_EXISTING); + } else { + // First save: no existing symlink, simply rename + Files.move(tempSymlink, currentLink, StandardCopyOption.ATOMIC_MOVE); + } + } catch (IOException e) { + System.err.println("Atomic save failed: " + e.getMessage()); + throw e; + } + + vectorMap.clear(); + } + + private void forceSyncDirectory(Path directory) throws IOException { + // need test to prove if it is work + + // First, fsync all files within the directory + if (!Files.isDirectory(directory)) { + throw new IllegalArgumentException("Path is not a directory: " + directory); + } + + try (Stream stream = Files.list(directory)) { + for (Path file : stream.collect(Collectors.toList())) { + if (!Files.isRegularFile(file)) { continue; } + try (FileChannel channel = FileChannel.open(file, StandardOpenOption.WRITE)) { + channel.force(true); + } + } + } + // Then, fsync the directory itself to persist its metadata (the file entries) + // Use FileChannel.open instead of RandomAccessFile to avoid "(Is a directory)" on Linux + try (FileChannel ch = FileChannel.open(directory, StandardOpenOption.READ)) { + ch.force(true); + } catch (IOException e) { + // Best-effort: some systems don't support fsync on directories + } + } + + @Override + public long getCurrentWaterMark(Id indexlabelId) { + if (!this.vectorMap.containsKey(indexlabelId)) { + return -1; + } + return vectorMap.get(indexlabelId).metaData().getWatermark(); + } + + @Override + public int getNextVectorId(Id indexlabelId) { + if (!this.vectorMap.containsKey(indexlabelId)) { + return -1; + } + return vectorMap.get(indexlabelId).metaData().getNextVectorId(); + } + + @Override + public long getNextSequence(Id indexLabelId) { + if (!this.vectorMap.containsKey(indexLabelId)) { + return -1; + } + return vectorMap.get(indexLabelId).metaData().getCurrentMaxSequence(); + } + + @Override + public void updateMetaData(Id indexLabelId, int vectorId, long sequence) { + //if (!this.vectorMap.containsKey(indexLabelId)) { + // // warning to log? + // return; + //} + IndexContext context = obtainContext(indexLabelId); + context.metaData.setNextVectorId(vectorId); + context.metaData.setCurrentMaxSequence(sequence); + context.metaData.setUpdateFromLog(true); + } + + public IndexContext obtainContext(Id indexlabelId) { + // TODO:add the function that update the ord and sequence in the context + IndexContext context = getContext(indexlabelId); + if (context != null) { + return context; + } + // If the IndexLabelId invalid when create New Context will throw error + return createNewContext(indexlabelId); + } + + protected abstract IndexContext createNewContext(Id indexlabelId); + + protected IndexContext getContext(Id indexlabelId) { + if (this.vectorMap.containsKey(indexlabelId)) { + return vectorMap.get(indexlabelId); + } + return null; + } + + boolean checkPathValid(Id indexlabelId) { + String pathString = basePath + "/" + (indexlabelId) + "/"; + Path indexBaseDir = Paths.get(pathString); + if (!Files.isDirectory(indexBaseDir)) { + System.err.println( + "Validation failed: Base directory does not exist or is not a directory: " + + indexBaseDir); + return false; + } + // 2. check the current link path + Path currentLinkPath = indexBaseDir.resolve(CURRENT_VERSION_LINK_NAME); + if (!Files.isSymbolicLink(currentLinkPath)) { + System.err.println( + "Validation failed: 'current' is not a symbolic link or does not exist in: " + + indexBaseDir); + return false; + } + + try { + // 3. read the real Path dir + Path realVersionDir = Files.readSymbolicLink(currentLinkPath); + // transform to the absolute path + if (!realVersionDir.isAbsolute()) { + realVersionDir = indexBaseDir.resolve(realVersionDir).toAbsolutePath(); + } + // 4. check the dir existed + if (!Files.isDirectory(realVersionDir)) { + System.err.println( + "Validation failed: 'current' points to a non-existent directory: " + + realVersionDir); + return false; + } + // 5. check 2 files of index existed + Path indexFilePath = realVersionDir.resolve(INDEX_FILE_NAME); + Path metaFilePath = realVersionDir.resolve(META_FILE_NAME); + + boolean indexFileExists = Files.isRegularFile(indexFilePath); + boolean metaFileExists = Files.isRegularFile(metaFilePath); + if (!indexFileExists) { + System.err.println( + "Validation failed: Index file not found in version directory: " + + indexFilePath); + } + if (!metaFileExists) { + System.err.println( + "Validation failed: Metadata file not found in version directory: " + + metaFilePath); + } + + return indexFileExists && metaFileExists; + + } catch (IOException e) { + System.err.println( + "An I/O error occurred during validation for index " + indexlabelId + ": " + + e.getMessage()); + return false; + } + } + + Path getOnDiskIndexDirPath(Id indexlabelId) throws IOException { + String pathString = basePath + "/" + (indexlabelId) + "/"; + Path indexBaseDir = Paths.get(pathString); + Path currentLinkPath = indexBaseDir.resolve(CURRENT_VERSION_LINK_NAME); + return Files.readSymbolicLink(currentLinkPath); + } + + protected abstract String idToString(Id id); +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/SequenceGenerator.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/SequenceGenerator.java new file mode 100644 index 0000000000..9fbc1a738f --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/SequenceGenerator.java @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +public interface SequenceGenerator { + long next(); + void init(long lastSeq); + long getCurrent(); +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/UpdatableRandomAccessVectorValues.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/UpdatableRandomAccessVectorValues.java new file mode 100644 index 0000000000..d768f4c5a6 --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/UpdatableRandomAccessVectorValues.java @@ -0,0 +1,67 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package org.apache.hugegraph.vector; + +import java.util.Map; + +import io.github.jbellis.jvector.graph.RandomAccessVectorValues; +import io.github.jbellis.jvector.vector.types.VectorFloat; + +public class UpdatableRandomAccessVectorValues implements RandomAccessVectorValues { + private final Map> map; + private final int dimension; + + public UpdatableRandomAccessVectorValues(Map> map, int dimension) { + this.map = map; + this.dimension = dimension; + } + + @Override + public int size() { + return map.size(); + } + + @Override + public int dimension() { + return dimension; + } + + @Override + public VectorFloat getVector(int nodeId) { + return map.get(nodeId); + } + + @Override + public boolean isValueShared() { + return false; + } + + @Override + public RandomAccessVectorValues copy() { + return this; + } + + public void addNode(int nodeId, VectorFloat vector){ + map.put(nodeId, vector); + } + + public void removeNode(int nodeId){ + map.remove(nodeId); + } +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIdAllocator.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIdAllocator.java new file mode 100644 index 0000000000..ff2e2dfa64 --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIdAllocator.java @@ -0,0 +1,37 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.util.concurrent.atomic.AtomicInteger; + +public class VectorIdAllocator { + AtomicInteger vectorId = new AtomicInteger(-1);; + + public VectorIdAllocator(){ + this(-1); + } + + public VectorIdAllocator(int maxVectorId) { + vectorId = new AtomicInteger(maxVectorId); + } + + int next() { + return vectorId.incrementAndGet(); + } + +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexManager.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexManager.java new file mode 100644 index 0000000000..2fb5bab73c --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexManager.java @@ -0,0 +1,109 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.io.IOException; +import java.util.Iterator; +import java.util.Set; + +import org.apache.hugegraph.util.Log; +import org.slf4j.Logger; + +public class VectorIndexManager { + + private static final Logger LOG = Log.logger(VectorIndexManager.class); + + private final VectorIndexStateStore stateStore; + private final VectorIndexRuntime runtime; + private final VectorTaskScheduler scheduler; + + public VectorIndexManager(VectorIndexStateStore stateStore, + VectorIndexRuntime runtime, + VectorTaskScheduler scheduler) { + this.stateStore = stateStore; + this.runtime = runtime; + this.scheduler = scheduler; + } + + public void init() { + this.runtime.init(); + } + + public void stop() throws IOException { + this.runtime.stop(); + this.stateStore.stop(); + } + + public void signal(Id indexLableId) { + this.scheduler.execute(() -> this.processIndex(indexLableId)); + } + + private void processIndex(Id indexLableId) { + + long currentSequence = this.runtime.getCurrentWaterMark(indexLableId); + LOG.debug("processIndex start: ilId={}, waterMark={}", + indexLableId, currentSequence); + + Iterator it = + stateStore.scanDeltas(indexLableId, currentSequence < 0 ? 0 : currentSequence) + .iterator(); + + this.runtime.update(indexLableId, it); + + LOG.debug("processIndex complete: ilId={}", indexLableId); + } + + public Set searchVector(Id indexLableId, float[] vector, int topK) { + Set result = null; + result = stateStore.getVertex(indexLableId, runtime.search(indexLableId, vector, topK)); + return result; + } + + private void initMetaData(Id indexLableId) { + if (!runtime.isUpdateMetaData(indexLableId)) { + int currentMaxVectorId = Math.max(runtime.getNextVectorId(indexLableId), 0); + long currentSequence = Math.max(runtime.getNextSequence(indexLableId), 0L); + runtime.updateMetaData(indexLableId, + stateStore.getCurrentMaxVectorId(indexLableId, + currentMaxVectorId) + 1, + stateStore.getCurrentMaxSequence(indexLableId, + currentSequence) + 1); + } + } + + public int getNextVectorId(Id indexLableId) { + // Initialize from stateStore on first access + initMetaData(indexLableId); + // Always increment and return + int id = runtime.getNextVectorId(indexLableId); + runtime.updateMetaData(indexLableId, id + 1, + runtime.getNextSequence(indexLableId)); + return id; + } + + public long getNextSequence(Id indexLableId) { + // Initialize from stateStore on first access + initMetaData(indexLableId); + // Always increment and return + long seq = runtime.getNextSequence(indexLableId); + runtime.updateMetaData(indexLableId, + runtime.getNextVectorId(indexLableId), seq + 1); + return seq; + } + +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexRuntime.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexRuntime.java new file mode 100644 index 0000000000..6a855f88ab --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexRuntime.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.io.IOException; +import java.util.Iterator; + +// this module implement the logic of managing the vector index structure in memory +public interface VectorIndexRuntime { + + void update(Id indexLabelId, Iterator records); + + void init(); + + void stop() throws IOException; + + void flush(Id indexLabelId) throws IOException; + + Iterator search(Id indexLabelId, float[] queryVector, int topK); + + long getCurrentWaterMark(Id indexLabelId); + + int getNextVectorId(Id indexLabelId); + + long getNextSequence(Id indexLabelId); + + boolean isUpdateMetaData(Id indexLabelId); + + void updateMetaData(Id indexLabelId, int vectorId, long sequence); +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexStateStore.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexStateStore.java new file mode 100644 index 0000000000..58b8860cff --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorIndexStateStore.java @@ -0,0 +1,36 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +import java.util.Iterator; +import java.util.Set; + +// this module implement the logic of grab the vector state in backend +public interface VectorIndexStateStore { + + void stop(); + + Iterable scanDeltas(Id indexLabelId, long fromSeq); + + Set getVertex(Id indexLabelId, Iterator vectorIds); + + int getCurrentMaxVectorId(Id indexLabelId, int currentMaxVectorId); + + long getCurrentMaxSequence(Id indexLabelId, long currentMaxSeq); + +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorRecord.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorRecord.java new file mode 100644 index 0000000000..cd0eaf1819 --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorRecord.java @@ -0,0 +1,41 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +public class VectorRecord { + + private final int vectorId; + private final float[] vector; + private final boolean deleted; + private final long sequence; + + public VectorRecord(int vectorId, float[] vector, boolean deleted, long seq) { + this.vectorId = vectorId; + this.vector = vector; + this.deleted = deleted; + this.sequence = seq; + } + + public float[] getVectorData(){return vector;} + + public boolean isDeleted(){return deleted;} + + public long getSequence(){return sequence;} + + public int getVectorId(){return vectorId;} +} diff --git a/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorTaskScheduler.java b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorTaskScheduler.java new file mode 100644 index 0000000000..d8bcd3750d --- /dev/null +++ b/hugegraph-struct/src/main/java/org/apache/hugegraph/vector/VectorTaskScheduler.java @@ -0,0 +1,25 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.vector; + +// This module implements job-scheduling logic that can target +// either a single-store or a distributed-store platform. +public interface VectorTaskScheduler { + + void execute(Runnable task); +} diff --git a/hugegraph-struct/src/test/java/org/apache/hugegraph/query/ConditionTest.java b/hugegraph-struct/src/test/java/org/apache/hugegraph/query/ConditionTest.java new file mode 100644 index 0000000000..b34fa4e735 --- /dev/null +++ b/hugegraph-struct/src/test/java/org/apache/hugegraph/query/ConditionTest.java @@ -0,0 +1,56 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.query; + +import org.apache.hugegraph.type.define.HugeKeys; +import org.junit.Assert; +import org.junit.Test; + +public class ConditionTest { + + @Test + public void testConditionBooleanRange() { + Condition lt = Condition.lt(HugeKeys.ID, true); + Assert.assertTrue(lt.test(false)); + Assert.assertFalse(lt.test(true)); + + Condition lte = Condition.lte(HugeKeys.ID, false); + Assert.assertTrue(lte.test(false)); + Assert.assertFalse(lte.test(true)); + + Condition gt = Condition.gt(HugeKeys.ID, false); + Assert.assertTrue(gt.test(true)); + Assert.assertFalse(gt.test(false)); + + Condition gte = Condition.gte(HugeKeys.ID, true); + Assert.assertTrue(gte.test(true)); + Assert.assertFalse(gte.test(false)); + + IllegalArgumentException exception = Assert.assertThrows( + IllegalArgumentException.class, + () -> Condition.lt(HugeKeys.ID, true).test(1)); + Assert.assertEquals("Can't compare between 1(Integer) and true(Boolean)", + exception.getMessage()); + + exception = Assert.assertThrows(IllegalArgumentException.class, + () -> Condition.lt(HugeKeys.ID, true) + .test((Object) null)); + Assert.assertEquals("Can't compare between null(null) and true(Boolean)", + exception.getMessage()); + } +} diff --git a/hugegraph-struct/src/test/java/org/apache/hugegraph/struct/schema/PropertyKeyTest.java b/hugegraph-struct/src/test/java/org/apache/hugegraph/struct/schema/PropertyKeyTest.java new file mode 100644 index 0000000000..d8441144f2 --- /dev/null +++ b/hugegraph-struct/src/test/java/org/apache/hugegraph/struct/schema/PropertyKeyTest.java @@ -0,0 +1,70 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hugegraph.struct.schema; + +import java.util.Arrays; +import java.util.Date; +import java.util.Set; + +import org.apache.hugegraph.id.IdGenerator; +import org.apache.hugegraph.type.define.Cardinality; +import org.apache.hugegraph.type.define.DataType; +import org.apache.hugegraph.util.DateUtil; +import org.junit.Assert; +import org.junit.Test; + +public class PropertyKeyTest { + + @Test + public void testDefaultValueNormalizedToDate() { + // Userdata reloaded from JSON keeps ~default_value as a String; + // defaultValue() must normalize it to the data type's runtime type + // (#3028). + String formatted = "2026-05-14 10:11:12.345"; + PropertyKey propertyKey = new PropertyKey(null, IdGenerator.of(1), + "joinDate"); + propertyKey.dataType(DataType.DATE); + propertyKey.userdata(Userdata.DEFAULT_VALUE, formatted); + + Object value = propertyKey.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Date, was " + + (value == null ? "null" : value.getClass()), + value instanceof Date); + Assert.assertEquals(DateUtil.parse(formatted), value); + } + + @Test + public void testSetDefaultValueCollapsesDuplicatesAndReturnsSet() { + String formatted = "2026-05-14 10:11:12.345"; + PropertyKey propertyKey = new PropertyKey(null, IdGenerator.of(1), + "joinDate"); + propertyKey.dataType(DataType.DATE); + propertyKey.cardinality(Cardinality.SET); + propertyKey.userdata(Userdata.DEFAULT_VALUE, + Arrays.asList(formatted, formatted)); + + Object value = propertyKey.defaultValue(); + Assert.assertTrue("DEFAULT_VALUE should be a Set, was " + + (value == null ? "null" : value.getClass()), + value instanceof Set); + + Set values = (Set) value; + Assert.assertEquals(1, values.size()); + Assert.assertTrue(values.contains(DateUtil.parse(formatted))); + } +} diff --git a/install-dist/pom.xml b/install-dist/pom.xml index 0b6ffa9901..45de069d07 100644 --- a/install-dist/pom.xml +++ b/install-dist/pom.xml @@ -29,7 +29,7 @@ install-dist - apache-${release.name}-incubating-${project.version} + apache-${release.name}-${project.version} @@ -50,10 +50,10 @@ cd $root_path || exit mkdir -p ${final.name} - cp -r -v $root_path/hugegraph-pd/apache-hugegraph-pd-incubating-${project.version} ${final.name}/ || exit - cp -r -v $root_path/hugegraph-store/apache-hugegraph-store-incubating-${project.version} ${final.name}/ || exit - cp -r -v $root_path/hugegraph-server/apache-hugegraph-server-incubating-${project.version} ${final.name}/ || exit - cp -r -v $root_path/install-dist/release-docs/* $root_path/DISCLAIMER ${final.name}/ || exit + cp -r -v $root_path/hugegraph-pd/apache-hugegraph-pd-${project.version} ${final.name}/ || exit + cp -r -v $root_path/hugegraph-store/apache-hugegraph-store-${project.version} ${final.name}/ || exit + cp -r -v $root_path/hugegraph-server/apache-hugegraph-server-${project.version} ${final.name}/ || exit + cp -r -v $root_path/install-dist/release-docs/* ${final.name}/ || exit tar zcvf $root_path/target/${final.name}.tar.gz ./${final.name} || exit 1 diff --git a/install-dist/release-docs/LICENSE b/install-dist/release-docs/LICENSE index 1df2d8b25f..fc15a77408 100644 --- a/install-dist/release-docs/LICENSE +++ b/install-dist/release-docs/LICENSE @@ -203,9 +203,9 @@ ============================================================================ - APACHE HUGEGRAPH (Incubating) SUBCOMPONENTS: + APACHE HUGEGRAPH SUBCOMPONENTS: - The Apache HugeGraph(Incubating) project contains subcomponents with separate copyright + The Apache HugeGraph project contains subcomponents with separate copyright notices and license terms. Your use of the source code for the these subcomponents is subject to the terms and conditions of the following licenses. @@ -236,44 +236,133 @@ The text of each license is the standard Apache 2.0 license. (Apache License, Version 2.0) * swagger-ui v4.15.5 (https://github.com/swagger-api/swagger-ui) +======================================================================== +Third party CC0 1.0 licenses +======================================================================== +The following components are provided under the CC0 1.0 License. See project link for details. +The text of each license is also included in licenses/LICENSE-[project].txt. + + https://central.sonatype.com/artifact/org.hdrhistogram/HdrHistogram/2.1.12 -> CC0 1.0 + https://central.sonatype.com/artifact/org.hdrhistogram/HdrHistogram/2.1.9 -> CC0 1.0 + +======================================================================== +Third party BSD-2-Clause licenses +======================================================================== +The following components are provided under the BSD-2-Clause License. See project link for details. +The text of each license is also included in licenses/LICENSE-[project].txt. + + https://central.sonatype.com/artifact/com.github.luben/zstd-jni/1.5.5-1 -> BSD-2-Clause + https://central.sonatype.com/artifact/org.latencyutils/LatencyUtils/2.0.3 -> BSD-2-Clause + https://central.sonatype.com/artifact/org.postgresql/postgresql/42.4.3 -> BSD-2-Clause + ======================================================================== Third party Apache 2.0 licenses ======================================================================== The following components are provided under the Apache 2.0 License. See project link for details. -The text of each license is also included in licenses/LICENSE-[project].txt. +Per-component LICENSE-[project].txt files are included only when additional +non-Apache-2.0 license text is required for a bundled component. - https://central.sonatype.com/artifact/net.minidev/accessors-smart/1.2 -> Apache 2.0 - https://central.sonatype.com/artifact/io.airlift/airline/0.8 -> Apache 2.0 - https://central.sonatype.com/artifact/com.vaadin.external.google/android-json/0.0.20131108.vaadin1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jetbrains/annotations/13.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jetbrains/annotations/24.0.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.addthis.metrics/reporter-config-base/3.0.3 -> Apache 2.0 + https://central.sonatype.com/artifact/com.addthis.metrics/reporter-config3/3.0.3 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alibaba/fastjson/1.2.83 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa.common/sofa-common-tools/1.0.12 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa.lookout/lookout-api/1.4.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/bolt/1.6.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/bolt/1.6.4 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/hessian/3.3.6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/hessian/3.3.7 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/jraft-core/1.3.11 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/jraft-core/1.3.13 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/jraft-core/1.3.9 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/sofa-rpc-all/5.7.6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.alipay.sofa/tracer-core/3.0.8 -> Apache 2.0 + https://central.sonatype.com/artifact/com.beust/jcommander/1.30 -> Apache 2.0 + https://central.sonatype.com/artifact/com.carrotsearch/hppc/0.7.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.carrotsearch/hppc/0.8.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.chenlb.mmseg4j/mmseg4j-core/1.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.clearspring.analytics/stream/2.5.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.codahale.metrics/metrics-core/3.0.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.datastax.cassandra/cassandra-driver-core/3.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.13.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.14.0-rc1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.13.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.13.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.14.0-rc1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.12.6.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.13.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.13.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.14.0-rc1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-yaml/2.11.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-yaml/2.9.3 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jdk8/2.12.6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jsr310/2.11.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jsr310/2.12.6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.jakarta.rs/jackson-jakarta-rs-base/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.jakarta.rs/jackson-jakarta-rs-json-provider/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-base/2.14.0-rc1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-base/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-json-provider/2.14.0-rc1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-json-provider/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-jakarta-xmlbind-annotations/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-jaxb-annotations/2.14.0-rc1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-jaxb-annotations/2.15.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-parameter-names/2.12.6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.ben-manes.caffeine/caffeine/2.3.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.ben-manes.caffeine/caffeine/2.5.6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.jbellis/jamm/0.3.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.jnr/jffi/1.2.16 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.jnr/jnr-ffi/2.1.7 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.mifmif/generex/1.0.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.stephenc.findbugs/findbugs-annotations/1.3.9-1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.github.stephenc.jcip/jcip-annotations/1.0-1 -> Apache 2.0 https://central.sonatype.com/artifact/com.google.android/annotations/4.1.1.4 -> Apache 2.0 - https://central.sonatype.com/artifact/org.ansj/ansj_seg/5.1.6 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apiguardian/apiguardian-api/1.1.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.api.grpc/proto-google-common-protos/1.17.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.api.grpc/proto-google-common-protos/2.0.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.auto.service/auto-service-annotations/1.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.code.findbugs/jsr305/3.0.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.code.findbugs/jsr305/3.0.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.code.gson/gson/2.8.6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.code.gson/gson/2.8.9 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.1.3 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.18.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.3.4 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.4.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/failureaccess/1.0.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/guava/25.1-jre -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/guava/27.0-jre -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/guava/30.0-jre -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/guava/30.1-android -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/guava/31.0.1-android -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/guava/32.0.1-android -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.guava/listenablefuture/9999.0-empty-to-avoid-conflict-with-guava -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.j2objc/j2objc-annotations/1.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.j2objc/j2objc-annotations/1.3 -> Apache 2.0 + https://central.sonatype.com/artifact/com.google.j2objc/j2objc-annotations/2.8 -> Apache 2.0 + https://central.sonatype.com/artifact/com.googlecode.concurrent-trees/concurrent-trees/2.4.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.googlecode.json-simple/json-simple/1.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.hankcs/hanlp/portable-1.8.3 -> Apache 2.0 + https://central.sonatype.com/artifact/com.huaban/jieba-analysis/1.0.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.janeluo/ikanalyzer/2012_u6 -> Apache 2.0 + https://central.sonatype.com/artifact/com.jayway.jsonpath/json-path/2.5.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.lmax/disruptor/3.3.7 -> Apache 2.0 + https://central.sonatype.com/artifact/com.lmax/disruptor/3.4.1 -> Apache 2.0 + https://central.sonatype.com/artifact/com.nimbusds/nimbus-jose-jwt/4.41.2 -> Apache 2.0 + https://central.sonatype.com/artifact/com.squareup.okhttp3/logging-interceptor/3.12.12 -> Apache 2.0 + https://central.sonatype.com/artifact/com.squareup.okhttp3/logging-interceptor/4.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.squareup.okhttp3/okhttp/3.12.12 -> Apache 2.0 + https://central.sonatype.com/artifact/com.squareup.okhttp3/okhttp/4.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.squareup.okio/okio-jvm/3.0.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.squareup.okio/okio/1.15.0 -> Apache 2.0 + https://central.sonatype.com/artifact/com.squareup/javapoet/1.8.0 -> Apache 2.0 https://central.sonatype.com/artifact/com.taobao.arthas/arthas-agent-attach/3.6.4 -> Apache 2.0 https://central.sonatype.com/artifact/com.taobao.arthas/arthas-agent-attach/3.7.1 -> Apache 2.0 https://central.sonatype.com/artifact/com.taobao.arthas/arthas-packaging/3.6.4 -> Apache 2.0 https://central.sonatype.com/artifact/com.taobao.arthas/arthas-packaging/3.7.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.assertj/assertj-core/3.19.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher/ast-9.0/9.0.20190305 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.yetus/audience-annotations/0.5.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.auto.service/auto-service-annotations/1.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/bolt/1.6.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/bolt/1.6.4 -> Apache 2.0 - https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy/1.10.20 -> Apache 2.0 - https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy/1.10.5 -> Apache 2.0 - https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy-agent/1.10.20 -> Apache 2.0 - https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy-agent/1.10.5 -> Apache 2.0 - https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy-agent/1.11.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.ben-manes.caffeine/caffeine/2.3.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.ben-manes.caffeine/caffeine/2.5.6 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.cassandra/cassandra-all/4.0.10 -> Apache 2.0 - https://central.sonatype.com/artifact/com.datastax.cassandra/cassandra-driver-core/3.6.0 -> Apache 2.0 - https://central.sonatype.com/artifact/net.openhft/chronicle-bytes/2.20.111 -> Apache 2.0 - https://central.sonatype.com/artifact/net.openhft/chronicle-core/2.20.126 -> Apache 2.0 - https://central.sonatype.com/artifact/net.openhft/chronicle-queue/5.20.123 -> Apache 2.0 - https://central.sonatype.com/artifact/net.openhft/chronicle-threads/2.20.111 -> Apache 2.0 - https://central.sonatype.com/artifact/net.openhft/chronicle-wire/2.20.117 -> Apache 2.0 + https://central.sonatype.com/artifact/com.vaadin.external.google/android-json/0.0.20131108.vaadin1 -> Apache 2.0 https://central.sonatype.com/artifact/commons-beanutils/commons-beanutils/1.9.4 -> Apache 2.0 https://central.sonatype.com/artifact/commons-cli/commons-cli/1.1 -> Apache 2.0 https://central.sonatype.com/artifact/commons-codec/commons-codec/1.11 -> Apache 2.0 @@ -281,54 +370,47 @@ The text of each license is also included in licenses/LICENSE-[project].txt. https://central.sonatype.com/artifact/commons-codec/commons-codec/1.15 -> Apache 2.0 https://central.sonatype.com/artifact/commons-codec/commons-codec/1.9 -> Apache 2.0 https://central.sonatype.com/artifact/commons-collections/commons-collections/3.2.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-collections4/4.4 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-compress/1.21 -> Apache 2.0 https://central.sonatype.com/artifact/commons-configuration/commons-configuration/1.10 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-configuration2/2.8.0 -> Apache 2.0 https://central.sonatype.com/artifact/commons-io/commons-io/2.12.0 -> Apache 2.0 https://central.sonatype.com/artifact/commons-io/commons-io/2.7 -> Apache 2.0 https://central.sonatype.com/artifact/commons-io/commons-io/2.8.0 -> Apache 2.0 https://central.sonatype.com/artifact/commons-lang/commons-lang/2.6 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-lang3/3.11 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-lang3/3.12.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-lang3/3.13.0 -> Apache 2.0 https://central.sonatype.com/artifact/commons-logging/commons-logging/1.1.1 -> Apache 2.0 https://central.sonatype.com/artifact/commons-logging/commons-logging/1.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-math3/3.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-text/1.10.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.commons/commons-text/1.9 -> Apache 2.0 - https://central.sonatype.com/artifact/com.googlecode.concurrent-trees/concurrent-trees/2.4.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher.gremlin/cypher-gremlin-extensions/1.0.4 -> Apache 2.0 - https://central.sonatype.com/artifact/com.lmax/disruptor/3.3.7 -> Apache 2.0 - https://central.sonatype.com/artifact/com.lmax/disruptor/3.4.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.10.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.3.4 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.errorprone/error_prone_annotations/2.4.0 -> Apache 2.0 - https://central.sonatype.com/artifact/net.objecthunter/exp4j/0.4.8 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher/expressions-9.0/9.0.20190305 -> Apache 2.0 - https://central.sonatype.com/artifact/net.jodah/failsafe/2.4.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.guava/failureaccess/1.0.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alibaba/fastjson/1.2.83 -> Apache 2.0 - https://central.sonatype.com/artifact/it.unimi.dsi/fastutil/8.5.9 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.stephenc.findbugs/findbugs-annotations/1.3.9-1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher/front-end-9.0/9.0.20190305 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-console/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-core/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-driver/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-groovy/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-groovy-test/3.2.11 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-server/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-shaded/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-test/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-cli-picocli/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-console/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-groovysh/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-json/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-jsr223/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-swing/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-templates/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-xml/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/info.picocli/picocli/4.3.2 -> Apache 2.0 + https://central.sonatype.com/artifact/io.airlift/airline/0.8 -> Apache 2.0 + https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-annotation/4.2.4 -> Apache 2.0 + https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-core/3.1.5 -> Apache 2.0 + https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-core/4.0.2 -> Apache 2.0 + https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-core/4.2.4 -> Apache 2.0 + https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-jersey3/4.2.4 -> Apache 2.0 + https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-jvm/3.1.5 -> Apache 2.0 + https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-logback/3.1.5 -> Apache 2.0 + https://central.sonatype.com/artifact/io.etcd/jetcd-common/0.5.9 -> Apache 2.0 + https://central.sonatype.com/artifact/io.etcd/jetcd-core/0.5.9 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-client/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-admissionregistration/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-apiextensions/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-apps/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-autoscaling/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-batch/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-certificates/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-common/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-coordination/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-core/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-discovery/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-events/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-extensions/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-flowcontrol/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-metrics/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-networking/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-node/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-policy/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-rbac/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-scheduling/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/kubernetes-model-storageclass/5.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.fabric8/zjsonpatch/0.3.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.github.lognet/grpc-spring-boot-starter/4.5.5 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-api/1.28.1 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-api/1.39.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-api/1.47.0 -> Apache 2.0 @@ -339,116 +421,133 @@ The text of each license is also included in licenses/LICENSE-[project].txt. https://central.sonatype.com/artifact/io.grpc/grpc-core/1.39.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-core/1.47.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-grpclb/1.39.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.grpc/grpc-netty/1.39.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.grpc/grpc-netty/1.47.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-netty-shaded/1.28.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-netty-shaded/1.39.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-netty-shaded/1.47.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.grpc/grpc-protobuf/1.28.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.grpc/grpc-protobuf/1.39.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.grpc/grpc-netty/1.39.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.grpc/grpc-netty/1.47.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-protobuf-lite/1.28.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-protobuf-lite/1.39.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.grpc/grpc-protobuf/1.28.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.grpc/grpc-protobuf/1.39.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-services/1.39.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.github.lognet/grpc-spring-boot-starter/4.5.5 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-stub/1.28.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-stub/1.39.0 -> Apache 2.0 https://central.sonatype.com/artifact/io.grpc/grpc-stub/1.47.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.code.gson/gson/2.8.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.code.gson/gson/2.8.9 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.guava/guava/27.0-jre -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.guava/guava/30.0-jre -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.guava/guava/30.1-android -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.guava/guava/31.0.1-android -> Apache 2.0 - https://central.sonatype.com/artifact/com.hankcs/hanlp/portable-1.8.3 -> Apache 2.0 - https://central.sonatype.com/artifact/com.baidu.hugegraph/hbase-shaded-endpoint/2.0.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/hessian/3.3.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/hessian/3.3.7 -> Apache 2.0 - https://central.sonatype.com/artifact/com.carrotsearch/hppc/0.7.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.carrotsearch/hppc/0.8.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.htrace/htrace-core4/4.2.0-incubating -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.httpcomponents/httpclient/4.5.13 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.httpcomponents/httpcore/4.4.13 -> Apache 2.0 - https://central.sonatype.com/artifact/com.janeluo/ikanalyzer/2012_u6 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.ivy/ivy/2.4.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.j2objc/j2objc-annotations/1.3 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.12.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.13.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.13.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.14.0-rc1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-annotations/2.15.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.12.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.13.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.13.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-core/2.14.0-rc1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.12.6.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.13.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.13.2.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.14.0-rc1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.core/jackson-databind/2.15.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-yaml/2.9.3 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jdk8/2.12.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jsr310/2.12.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-jsr310/2.15.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.jakarta.rs/jackson-jakarta-rs-base/2.15.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.jakarta.rs/jackson-jakarta-rs-json-provider/2.15.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-base/2.14.0-rc1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-json-provider/2.14.0-rc1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-jakarta-xmlbind-annotations/2.15.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-jaxb-annotations/2.14.0-rc1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.fasterxml.jackson.module/jackson-module-parameter-names/2.12.6 -> Apache 2.0 - https://central.sonatype.com/artifact/jakarta.inject/jakarta.inject-api/2.0.0 -> Apache 2.0 - https://central.sonatype.com/artifact/jakarta.validation/jakarta.validation-api/3.0.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.jbellis/jamm/0.3.2 -> Apache 2.0 - https://central.sonatype.com/artifact/com.squareup/javapoet/1.8.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.javassist/javassist/3.21.0-GA -> Apache 2.0 - https://central.sonatype.com/artifact/org.javassist/javassist/3.24.0-GA -> Apache 2.0 - https://central.sonatype.com/artifact/org.javassist/javassist/3.28.0-GA -> Apache 2.0 - https://central.sonatype.com/artifact/org.javatuples/javatuples/1.2 -> Apache 2.0 - https://central.sonatype.com/artifact/javax.inject/javax.inject/1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/javax-websocket-client-impl/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/javax-websocket-server-impl/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.stephenc.jcip/jcip-annotations/1.0-1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.beust/jcommander/1.30 -> Apache 2.0 - https://central.sonatype.com/artifact/org.lionsoul/jcseg-core/2.6.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jctools/jctools-core/2.1.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jctools/jctools-core/3.1.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.etcd/jetcd-common/0.5.9 -> Apache 2.0 - https://central.sonatype.com/artifact/io.etcd/jetcd-core/0.5.9 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-annotations/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-client/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-continuation/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-http/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-io/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-plus/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-security/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-server/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-servlet/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-servlets/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-util/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-util-ajax/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-webapp/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-xml/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.jnr/jffi/1.2.16 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.jnr/jffi/1.2.16 -> Apache 2.0 - https://central.sonatype.com/artifact/com.huaban/jieba-analysis/1.0.2 -> Apache 2.0 + https://central.sonatype.com/artifact/io.jsonwebtoken/jjwt-api/0.11.2 -> Apache 2.0 https://central.sonatype.com/artifact/io.jsonwebtoken/jjwt-api/0.11.5 -> Apache 2.0 + https://central.sonatype.com/artifact/io.jsonwebtoken/jjwt-impl/0.11.2 -> Apache 2.0 https://central.sonatype.com/artifact/io.jsonwebtoken/jjwt-impl/0.11.5 -> Apache 2.0 https://central.sonatype.com/artifact/io.jsonwebtoken/jjwt-jackson/0.11.5 -> Apache 2.0 + https://central.sonatype.com/artifact/io.micrometer/micrometer-core/1.7.12 -> Apache 2.0 + https://central.sonatype.com/artifact/io.micrometer/micrometer-registry-prometheus/1.7.12 -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-all/4.1.42.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-all/4.1.44.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-all/4.1.61.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-buffer/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-buffer/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec-http/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec-http/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec-http2/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec-http2/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec-socks/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec-socks/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-codec/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-common/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-common/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-handler-proxy/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-handler-proxy/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-handler/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-handler/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-resolver/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-resolver/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-tcnative-boringssl-static/2.0.25.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-tcnative-boringssl-static/2.0.36.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-tcnative-classes/2.0.46.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-transport-native-unix-common/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-transport/4.1.52.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.netty/netty-transport/4.1.72.Final -> Apache 2.0 + https://central.sonatype.com/artifact/io.opentracing/opentracing-api/0.22.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.opentracing/opentracing-mock/0.22.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.opentracing/opentracing-noop/0.22.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.opentracing/opentracing-util/0.22.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.perfmark/perfmark-api/0.19.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.perfmark/perfmark-api/0.23.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.perfmark/perfmark-api/0.25.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.prometheus/simpleclient/0.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.prometheus/simpleclient_common/0.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.protostuff/protostuff-api/1.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.protostuff/protostuff-collectionschema/1.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.protostuff/protostuff-core/1.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.protostuff/protostuff-runtime/1.6.0 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-annotations-jakarta/2.2.18 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-core-jakarta/2.2.18 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-integration-jakarta/2.2.18 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-jaxrs2-jakarta/2.2.18 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-models-jakarta/2.2.18 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger/swagger-annotations/1.5.18 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger/swagger-core/1.5.18 -> Apache 2.0 + https://central.sonatype.com/artifact/io.swagger/swagger-models/1.5.18 -> Apache 2.0 + https://central.sonatype.com/artifact/it.unimi.dsi/fastutil/8.1.0 -> Apache 2.0 + https://central.sonatype.com/artifact/it.unimi.dsi/fastutil/8.5.9 -> Apache 2.0 + https://central.sonatype.com/artifact/jakarta.inject/jakarta.inject-api/2.0.0 -> Apache 2.0 + https://central.sonatype.com/artifact/jakarta.validation/jakarta.validation-api/3.0.0 -> Apache 2.0 + https://central.sonatype.com/artifact/javax.inject/javax.inject/1 -> Apache 2.0 + https://central.sonatype.com/artifact/javax.validation/validation-api/1.1.0.Final -> Apache 2.0 + https://central.sonatype.com/artifact/joda-time/joda-time/2.10.8 -> Apache 2.0 + https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy-agent/1.10.20 -> Apache 2.0 + https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy-agent/1.10.5 -> Apache 2.0 + https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy-agent/1.11.6 -> Apache 2.0 + https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy/1.10.20 -> Apache 2.0 + https://central.sonatype.com/artifact/net.bytebuddy/byte-buddy/1.10.5 -> Apache 2.0 https://central.sonatype.com/artifact/net.java.dev.jna/jna/5.12.1 -> Apache 2.0 https://central.sonatype.com/artifact/net.java.dev.jna/jna/5.5.0 -> Apache 2.0 https://central.sonatype.com/artifact/net.java.dev.jna/jna/5.7.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.github.jnr/jnr-ffi/2.1.7 -> Apache 2.0 - https://central.sonatype.com/artifact/joda-time/joda-time/2.10.8 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/jraft-core/1.3.11 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/jraft-core/1.3.13 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/jraft-core/1.3.9 -> Apache 2.0 - https://central.sonatype.com/artifact/org.skyscreamer/jsonassert/1.5.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.jayway.jsonpath/json-path/2.5.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.googlecode.json-simple/json-simple/1.1 -> Apache 2.0 + https://central.sonatype.com/artifact/net.jodah/failsafe/2.4.1 -> Apache 2.0 + https://central.sonatype.com/artifact/net.minidev/accessors-smart/1.2 -> Apache 2.0 https://central.sonatype.com/artifact/net.minidev/json-smart/2.3 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.code.findbugs/jsr305/3.0.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.code.findbugs/jsr305/3.0.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.lab/jvm-attach-api/1.5 -> Apache 2.0 + https://central.sonatype.com/artifact/net.objecthunter/exp4j/0.4.8 -> Apache 2.0 + https://central.sonatype.com/artifact/net.openhft/chronicle-bytes/2.20.111 -> Apache 2.0 + https://central.sonatype.com/artifact/net.openhft/chronicle-core/2.20.126 -> Apache 2.0 + https://central.sonatype.com/artifact/net.openhft/chronicle-queue/5.20.123 -> Apache 2.0 + https://central.sonatype.com/artifact/net.openhft/chronicle-threads/2.20.111 -> Apache 2.0 + https://central.sonatype.com/artifact/net.openhft/chronicle-wire/2.20.117 -> Apache 2.0 + https://central.sonatype.com/artifact/org.ansj/ansj_seg/5.1.6 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.cassandra/cassandra-all/4.0.10 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-collections4/4.4 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-compress/1.21 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-configuration2/2.8.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-lang3/3.11 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-lang3/3.12.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-lang3/3.13.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-lang3/3.18.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-math3/3.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-pool2/2.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-text/1.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.commons/commons-text/1.9 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.fury/fury-core/0.9.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-client/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-common/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-endpoint/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-hadoop-compat/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-hadoop2-compat/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-logging/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-metrics/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-metrics-api/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-protocol/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-protocol-shaded/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-shaded-client/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase/hbase-zookeeper/2.6.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase.thirdparty/hbase-shaded-gson/4.1.13 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase.thirdparty/hbase-shaded-miscellaneous/4.1.13 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase.thirdparty/hbase-shaded-netty/4.1.13 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase.thirdparty/hbase-shaded-protobuf/4.1.13 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.hbase.thirdparty/hbase-unsafe/4.1.13 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.htrace/htrace-core4/4.2.0-incubating -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.httpcomponents/httpclient/4.5.13 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.httpcomponents/httpcore/4.4.13 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.ivy/ivy/2.4.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.kerby/kerb-admin/2.0.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.kerby/kerb-client/2.0.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.kerby/kerb-common/2.0.0 -> Apache 2.0 @@ -463,11 +562,7 @@ The text of each license is also included in licenses/LICENSE-[project].txt. https://central.sonatype.com/artifact/org.apache.kerby/kerby-pkix/2.0.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.kerby/kerby-util/2.0.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.kerby/kerby-xdr/2.0.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib/1.6.20 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib-common/1.5.31 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib-jdk7/1.6.10 -> Apache 2.0 - https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib-jdk8/1.6.10 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.guava/listenablefuture/9999.0-empty-to-avoid-conflict-with-guava -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.kerby/token-provider/2.0.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-api/2.15.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-api/2.17.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-api/2.17.1 -> Apache 2.0 @@ -483,169 +578,193 @@ The text of each license is also included in licenses/LICENSE-[project].txt. https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-slf4j-impl/2.17.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-slf4j-impl/2.17.1 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-slf4j-impl/2.18.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.squareup.okhttp3/logging-interceptor/4.10.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa.lookout/lookout-api/1.4.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-analyzers-common/5.2.1 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.lucene/lucene-analyzers-common/8.11.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-analyzers-smartcn/7.4.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.lucene/lucene-analyzers-smartcn/8.11.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-backward-codecs/5.2.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-core/7.4.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.lucene/lucene-core/8.11.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-misc/5.2.1 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.lucene/lucene-queries/4.7.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-queries/5.2.1 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.lucene/lucene-queryparser/4.7.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-queryparser/5.2.1 -> Apache 2.0 https://central.sonatype.com/artifact/org.apache.lucene/lucene-sandbox/4.7.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.lz4/lz4-java/1.4.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.lz4/lz4-java/1.8.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-annotation/4.2.4 -> Apache 2.0 - https://central.sonatype.com/artifact/com.codahale.metrics/metrics-core/3.0.2 -> Apache 2.0 - https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-core/3.1.5 -> Apache 2.0 - https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-core/4.0.2 -> Apache 2.0 - https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-core/4.2.4 -> Apache 2.0 - https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-jersey3/4.2.4 -> Apache 2.0 - https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-jvm/3.1.5 -> Apache 2.0 - https://central.sonatype.com/artifact/io.dropwizard.metrics/metrics-logback/3.1.5 -> Apache 2.0 - https://central.sonatype.com/artifact/io.micrometer/micrometer-core/1.7.12 -> Apache 2.0 - https://central.sonatype.com/artifact/io.micrometer/micrometer-registry-prometheus/1.7.12 -> Apache 2.0 - https://central.sonatype.com/artifact/com.chenlb.mmseg4j/mmseg4j-core/1.10.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-sandbox/5.2.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.lucene/lucene-suggest/5.2.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-console/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-core/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-driver/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-groovy-test/3.2.11 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-groovy/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-server/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-shaded/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/gremlin-test/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tinkerpop/tinkergraph-gremlin/3.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.tomcat.embed/tomcat-embed-el/9.0.63 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apache.yetus/audience-annotations/0.5.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.apiguardian/apiguardian-api/1.1.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.assertj/assertj-core/3.19.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.caffinitas.ohc/ohc-core-j8/0.5.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.caffinitas.ohc/ohc-core/0.7.4 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-cli-picocli/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-console/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-groovysh/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-json/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-jsr223/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-swing/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-templates/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy-xml/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.codehaus.groovy/groovy/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/javax-websocket-client-impl/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/javax-websocket-server-impl/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-api/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-client/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-common/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-server/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-servlet/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-annotations/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-client/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-continuation/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-http/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-io/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-plus/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-security/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-server/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-servlet/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-servlets/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-util-ajax/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-util/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-webapp/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.eclipse.jetty/jetty-xml/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.fusesource/sigar/1.6.4 -> Apache 2.0 https://central.sonatype.com/artifact/org.gridkit.jvmtool/mxdump/0.14 -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-all/4.1.42.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-all/4.1.44.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-all/4.1.61.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-buffer/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-buffer/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec-http2/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec-http2/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec-http/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec-http/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec-socks/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-codec-socks/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-common/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-common/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-handler/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-handler/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-handler-proxy/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-handler-proxy/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-resolver/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-resolver/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-tcnative-boringssl-static/2.0.25.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-tcnative-boringssl-static/2.0.36.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-tcnative-classes/2.0.46.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-transport/4.1.52.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-transport/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/io.netty/netty-transport-native-unix-common/4.1.72.Final -> Apache 2.0 - https://central.sonatype.com/artifact/com.nimbusds/nimbus-jose-jwt/4.41.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-agent/0.22 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-cli/0.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-cli/0.22 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-core/0.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-core/0.22 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-hflame/0.22 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-json/0.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-json/0.22 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-stacktrace/0.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-stacktrace/0.22 -> Apache 2.0 + https://central.sonatype.com/artifact/org.gridkit.lab/jvm-attach-api/1.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.javassist/javassist/3.21.0-GA -> Apache 2.0 + https://central.sonatype.com/artifact/org.javassist/javassist/3.24.0-GA -> Apache 2.0 + https://central.sonatype.com/artifact/org.javassist/javassist/3.28.0-GA -> Apache 2.0 + https://central.sonatype.com/artifact/org.javatuples/javatuples/1.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jctools/jctools-core/2.1.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jctools/jctools-core/3.1.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib-common/1.5.31 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib-jdk7/1.6.10 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib-jdk8/1.6.10 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jetbrains.kotlin/kotlin-stdlib/1.6.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jetbrains/annotations/13.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.jetbrains/annotations/24.0.1 -> Apache 2.0 + https://central.sonatype.com/artifact/org.lionsoul/jcseg-core/2.2.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.lionsoul/jcseg-core/2.6.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.lz4/lz4-java/1.4.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.lz4/lz4-java/1.8.1 -> Apache 2.0 https://central.sonatype.com/artifact/org.nlpcn/nlp-lang/1.7.7 -> Apache 2.0 https://central.sonatype.com/artifact/org.objenesis/objenesis/2.6 -> Apache 2.0 https://central.sonatype.com/artifact/org.objenesis/objenesis/3.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.caffinitas.ohc/ohc-core/0.7.4 -> Apache 2.0 - https://central.sonatype.com/artifact/org.caffinitas.ohc/ohc-core-j8/0.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/com.squareup.okhttp3/okhttp/4.10.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.squareup.okio/okio-jvm/3.0.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher.gremlin/cypher-gremlin-extensions/1.0.4 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher.gremlin/translation/1.0.4 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher/ast-9.0/9.0.20190305 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher/expressions-9.0/9.0.20190305 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher/front-end-9.0/9.0.20190305 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher/parser-9.0/9.0.20190305 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher/rewriting-9.0/9.0.20190305 -> Apache 2.0 + https://central.sonatype.com/artifact/org.opencypher/util-9.0/9.0.20190305 -> Apache 2.0 https://central.sonatype.com/artifact/org.opentest4j/opentest4j/1.2.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.opentracing/opentracing-api/0.22.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.opentracing/opentracing-mock/0.22.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.opentracing/opentracing-noop/0.22.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.opentracing/opentracing-util/0.22.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.parboiled/parboiled-core/1.2.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.parboiled/parboiled-scala_2.12/1.2.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher/parser-9.0/9.0.20190305 -> Apache 2.0 - https://central.sonatype.com/artifact/io.perfmark/perfmark-api/0.19.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.perfmark/perfmark-api/0.23.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.perfmark/perfmark-api/0.25.0 -> Apache 2.0 - https://central.sonatype.com/artifact/info.picocli/picocli/4.3.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-jfr-standalone/0.7 -> Apache 2.0 + https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-jfr5/0.5 -> Apache 2.0 + https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-jfr6/0.7 -> Apache 2.0 + https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-nps/0.9 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-api-mockito2/2.0.0-RC.3 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-api-support/2.0.0-RC.3 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-classloading-base/2.0.0-RC.3 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-classloading-xstream/2.0.0-RC.3 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-core/2.0.0-RC.3 -> Apache 2.0 - https://central.sonatype.com/artifact/org.powermock/powermock-module-junit4/2.0.0-RC.3 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-module-junit4-common/2.0.0-RC.3 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-module-junit4-rule/2.0.0-RC.3 -> Apache 2.0 + https://central.sonatype.com/artifact/org.powermock/powermock-module-junit4/2.0.0-RC.3 -> Apache 2.0 https://central.sonatype.com/artifact/org.powermock/powermock-reflect/2.0.0-RC.3 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.api.grpc/proto-google-common-protos/1.17.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.google.api.grpc/proto-google-common-protos/2.0.1 -> Apache 2.0 - https://central.sonatype.com/artifact/io.protostuff/protostuff-api/1.6.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.protostuff/protostuff-collectionschema/1.6.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.protostuff/protostuff-core/1.6.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.protostuff/protostuff-runtime/1.6.0 -> Apache 2.0 - https://central.sonatype.com/artifact/com.addthis.metrics/reporter-config3/3.0.3 -> Apache 2.0 - https://central.sonatype.com/artifact/com.addthis.metrics/reporter-config-base/3.0.3 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher/rewriting-9.0/9.0.20190305 -> Apache 2.0 + https://central.sonatype.com/artifact/org.roaringbitmap/RoaringBitmap/0.9.38 -> Apache 2.0 + https://central.sonatype.com/artifact/org.roaringbitmap/shims/0.9.38 -> Apache 2.0 https://central.sonatype.com/artifact/org.rocksdb/rocksdbjni/6.29.5 -> Apache 2.0 - https://central.sonatype.com/artifact/org.rocksdb/rocksdbjni/7.2.2 -> Apache 2.0 https://central.sonatype.com/artifact/org.rocksdb/rocksdbjni/7.7.3 -> Apache 2.0 - https://central.sonatype.com/artifact/org.fusesource/sigar/1.6.4 -> Apache 2.0 - https://central.sonatype.com/artifact/io.prometheus/simpleclient/0.10.0 -> Apache 2.0 - https://central.sonatype.com/artifact/io.prometheus/simpleclient_common/0.10.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-agent/0.22 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-cli/0.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-cli/0.22 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-core/0.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-core/0.22 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-hflame/0.22 -> Apache 2.0 - https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-jfr5/0.5 -> Apache 2.0 - https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-jfr6/0.7 -> Apache 2.0 - https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-jfr-standalone/0.7 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-json/0.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-json/0.22 -> Apache 2.0 - https://central.sonatype.com/artifact/org.perfkit.sjk.parsers/sjk-nps/0.9 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-stacktrace/0.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.gridkit.jvmtool/sjk-stacktrace/0.22 -> Apache 2.0 - https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.18 -> Apache 2.0 - https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.26 -> Apache 2.0 - https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.27 -> Apache 2.0 - https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.28 -> Apache 2.0 - https://central.sonatype.com/artifact/org.yaml/snakeyaml/2.2 -> Apache 2.0 - https://central.sonatype.com/artifact/org.xerial.snappy/snappy-java/1.1.2.6 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa.common/sofa-common-tools/1.0.12 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/sofa-rpc-all/5.7.6 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework/spring-aop/5.3.20 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework/spring-beans/5.3.20 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework.boot/spring-boot/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-actuator/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.rocksdb/rocksdbjni/8.10.2 -> Apache 2.0 + https://central.sonatype.com/artifact/org.skyscreamer/jsonassert/1.5.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-actuator-autoconfigure/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-actuator/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-autoconfigure/2.5.0 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-autoconfigure/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter/2.5.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter-actuator/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter-jetty/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter-json/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter-log4j2/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter-test/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter-web/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-test/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter/2.5.0 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-starter/2.5.14 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-test-autoconfigure/2.5.14 -> Apache 2.0 - https://central.sonatype.com/artifact/org.springframework/spring-context/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework.boot/spring-boot-test/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework.boot/spring-boot/2.5.14 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework.security/spring-security-core/5.8.3 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework.security/spring-security-crypto/5.8.3 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-aop/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-aop/5.3.27 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-beans/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-beans/5.3.27 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework/spring-context-support/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-context/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-context/5.3.27 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework/spring-core/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-core/5.3.27 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework/spring-expression/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-expression/5.3.27 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework/spring-jcl/5.3.20 -> Apache 2.0 + https://central.sonatype.com/artifact/org.springframework/spring-jcl/5.3.27 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework/spring-web/5.3.20 -> Apache 2.0 https://central.sonatype.com/artifact/org.springframework/spring-webmvc/5.3.20 -> Apache 2.0 - https://central.sonatype.com/artifact/com.clearspring.analytics/stream/2.5.2 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger/swagger-annotations/1.5.18 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-annotations-jakarta/2.2.18 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger/swagger-core/1.5.18 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-core-jakarta/2.2.18 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-integration-jakarta/2.2.18 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-jaxrs2-jakarta/2.2.18 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger/swagger-models/1.5.18 -> Apache 2.0 - https://central.sonatype.com/artifact/io.swagger.core.v3/swagger-models-jakarta/2.2.18 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tinkerpop/tinkergraph-gremlin/3.5.1 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.kerby/token-provider/2.0.0 -> Apache 2.0 - https://central.sonatype.com/artifact/org.apache.tomcat.embed/tomcat-embed-el/9.0.63 -> Apache 2.0 - https://central.sonatype.com/artifact/com.alipay.sofa/tracer-core/3.0.8 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher.gremlin/translation/1.0.4 -> Apache 2.0 - https://central.sonatype.com/artifact/org.opencypher/util-9.0/9.0.20190305 -> Apache 2.0 - https://central.sonatype.com/artifact/javax.validation/validation-api/1.1.0.Final -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-api/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-client/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-common/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-server/9.4.46.v20220331 -> Apache 2.0 - https://central.sonatype.com/artifact/org.eclipse.jetty.websocket/websocket-servlet/9.4.46.v20220331 -> Apache 2.0 + https://central.sonatype.com/artifact/org.xerial.snappy/snappy-java/1.1.2.6 -> Apache 2.0 https://central.sonatype.com/artifact/org.xmlunit/xmlunit-core/2.8.4 -> Apache 2.0 + https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.18 -> Apache 2.0 + https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.26 -> Apache 2.0 + https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.27 -> Apache 2.0 + https://central.sonatype.com/artifact/org.yaml/snakeyaml/1.28 -> Apache 2.0 + https://central.sonatype.com/artifact/org.yaml/snakeyaml/2.2 -> Apache 2.0 https://central.sonatype.com/artifact/org.zeroturnaround/zt-zip/1.14 -> Apache 2.0 - https://central.sonatype.com/artifact/io.fabric8/kubernetes-client/5.6.0 -> Apache 2.0 + +======================================================================== +Third party BSD licenses +======================================================================== +The following components are provided under the BSD License. See project link for details. +The text of each license is also included in licenses/LICENSE-[project].txt. + + https://central.sonatype.com/artifact/com.belerweb/pinyin4j/2.5.0 -> BSD + https://central.sonatype.com/artifact/com.github.rholder/snowball-stemmer/1.3.0.581.1 -> BSD + https://central.sonatype.com/artifact/com.jcabi/jcabi-log/0.14 -> BSD + https://central.sonatype.com/artifact/com.jcabi/jcabi-manifests/1.1 -> BSD + https://central.sonatype.com/artifact/com.thoughtworks.xstream/xstream/1.4.10 -> BSD + https://central.sonatype.com/artifact/de.jflex/jflex/1.8.2 -> BSD + https://central.sonatype.com/artifact/dk.brics.automaton/automaton/1.11-8 -> BSD + https://central.sonatype.com/artifact/jline/jline/2.14.6 -> BSD + https://central.sonatype.com/artifact/org.antlr/ST4/4.0.8 -> BSD + https://central.sonatype.com/artifact/org.antlr/antlr-runtime/3.5.2 -> BSD + https://central.sonatype.com/artifact/org.hamcrest/hamcrest-core/1.3 -> BSD + https://central.sonatype.com/artifact/org.ow2.asm/asm-analysis/5.0.3 -> BSD + https://central.sonatype.com/artifact/org.ow2.asm/asm-commons/5.0.3 -> BSD + https://central.sonatype.com/artifact/org.ow2.asm/asm-tree/5.0.3 -> BSD + https://central.sonatype.com/artifact/org.ow2.asm/asm-util/5.0.3 -> BSD + https://central.sonatype.com/artifact/org.ow2.asm/asm/5.0.4 -> BSD + https://central.sonatype.com/artifact/org.ow2.asm/asm/6.0 -> BSD + https://central.sonatype.com/artifact/org.ow2.asm/asm/7.1 -> BSD ======================================================================== Third party MIT licenses @@ -653,49 +772,32 @@ Third party MIT licenses The following components are provided under the MIT License. See project link for details. The text of each license is also included in licenses/LICENSE-[project].txt. - https://central.sonatype.com/artifact/org.codehaus.mojo/animal-sniffer-annotations/1.18 -> MIT - https://central.sonatype.com/artifact/org.codehaus.mojo/animal-sniffer-annotations/1.19 -> MIT + https://central.sonatype.com/artifact/com.boundary/high-scale-lib/1.0.6 -> MIT + https://central.sonatype.com/artifact/com.github.jnr/jnr-x86asm/1.0.2 -> MIT + https://central.sonatype.com/artifact/com.lihaoyi/fastparse_2.12/2.0.4 -> MIT + https://central.sonatype.com/artifact/com.lihaoyi/sourcecode_2.12/0.1.4 -> MIT + https://central.sonatype.com/artifact/io.github.classgraph/classgraph/4.8.162 -> MIT https://central.sonatype.com/artifact/org.checkerframework/checker-compat-qual/2.5.5 -> MIT + https://central.sonatype.com/artifact/org.checkerframework/checker-qual/2.0.0 -> MIT https://central.sonatype.com/artifact/org.checkerframework/checker-qual/3.12.0 -> MIT + https://central.sonatype.com/artifact/org.checkerframework/checker-qual/3.33.0 -> MIT https://central.sonatype.com/artifact/org.checkerframework/checker-qual/3.5.0 -> MIT - https://central.sonatype.com/artifact/io.github.classgraph/classgraph/4.8.162 -> MIT - https://central.sonatype.com/artifact/com.lihaoyi/fastparse_2.12/2.0.4 -> MIT - https://central.sonatype.com/artifact/com.boundary/high-scale-lib/1.0.6 -> MIT - https://central.sonatype.com/artifact/org.slf4j/jcl-over-slf4j/1.7.25 -> MIT - https://central.sonatype.com/artifact/com.github.jnr/jnr-x86asm/1.0.2 -> MIT - https://central.sonatype.com/artifact/org.slf4j/jul-to-slf4j/1.7.36 -> MIT - https://central.sonatype.com/artifact/org.projectlombok/lombok/1.18.24 -> MIT + https://central.sonatype.com/artifact/org.codehaus.mojo/animal-sniffer-annotations/1.14 -> MIT + https://central.sonatype.com/artifact/org.codehaus.mojo/animal-sniffer-annotations/1.18 -> MIT + https://central.sonatype.com/artifact/org.codehaus.mojo/animal-sniffer-annotations/1.19 -> MIT https://central.sonatype.com/artifact/org.mockito/mockito-core/3.3.3 -> MIT https://central.sonatype.com/artifact/org.mockito/mockito-core/3.9.0 -> MIT https://central.sonatype.com/artifact/org.mockito/mockito-junit-jupiter/3.9.0 -> MIT + https://central.sonatype.com/artifact/org.projectlombok/lombok/1.18.24 -> MIT https://central.sonatype.com/artifact/org.psjava/psjava/0.1.19 -> MIT + https://central.sonatype.com/artifact/org.slf4j/jcl-over-slf4j/1.7.25 -> MIT + https://central.sonatype.com/artifact/org.slf4j/jul-to-slf4j/1.7.36 -> MIT https://central.sonatype.com/artifact/org.slf4j/slf4j-api/1.7.21 -> MIT https://central.sonatype.com/artifact/org.slf4j/slf4j-api/1.7.25 -> MIT + https://central.sonatype.com/artifact/org.slf4j/slf4j-api/1.7.31 -> MIT https://central.sonatype.com/artifact/org.slf4j/slf4j-api/1.7.32 -> MIT https://central.sonatype.com/artifact/org.slf4j/slf4j-api/2.0.9 -> MIT - https://central.sonatype.com/artifact/com.lihaoyi/sourcecode_2.12/0.1.4 -> MIT - -======================================================================== -Third party BSD licenses -======================================================================== -The following components are provided under the BSD License. See project link for details. -The text of each license is also included in licenses/LICENSE-[project].txt. - - https://central.sonatype.com/artifact/org.antlr/antlr-runtime/3.5.2 -> BSD - https://central.sonatype.com/artifact/org.ow2.asm/asm/6.0 -> BSD - https://central.sonatype.com/artifact/org.ow2.asm/asm/7.1 -> BSD - https://central.sonatype.com/artifact/org.ow2.asm/asm-analysis/5.0.3 -> BSD - https://central.sonatype.com/artifact/org.ow2.asm/asm-commons/5.0.3 -> BSD - https://central.sonatype.com/artifact/org.ow2.asm/asm-tree/5.0.3 -> BSD - https://central.sonatype.com/artifact/org.ow2.asm/asm-util/5.0.3 -> BSD - https://central.sonatype.com/artifact/org.hamcrest/hamcrest-core/1.3 -> BSD - https://central.sonatype.com/artifact/com.jcabi/jcabi-log/0.14 -> BSD - https://central.sonatype.com/artifact/com.jcabi/jcabi-manifests/1.1 -> BSD - https://central.sonatype.com/artifact/de.jflex/jflex/1.8.2 -> BSD - https://central.sonatype.com/artifact/jline/jline/2.14.6 -> BSD - https://central.sonatype.com/artifact/com.github.rholder/snowball-stemmer/1.3.0.581.1 -> BSD - https://central.sonatype.com/artifact/org.antlr/ST4/4.0.8 -> BSD - https://central.sonatype.com/artifact/com.thoughtworks.xstream/xstream/1.4.10 -> BSD + https://central.sonatype.com/artifact/redis.clients/jedis/2.5.1 -> MIT ======================================================================== Third party EPL 2.0 licenses @@ -703,41 +805,41 @@ Third party EPL 2.0 licenses The following components are provided under the EPL 2.0 License. See project link for details. The text of each license is also included in licenses/LICENSE-[project].txt. - https://central.sonatype.com/artifact/org.glassfish.hk2.external/aopalliance-repackaged/3.0.1 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-framework/3.0.1 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-http/3.0.1 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-http-server/3.0.1 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-http-servlet/3.0.1 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.hk2/hk2-api/3.0.1 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.hk2/hk2-locator/3.0.1 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.hk2/hk2-utils/3.0.1 -> EPL 2.0 https://central.sonatype.com/artifact/jakarta.annotation/jakarta.annotation-api/1.3.5 -> EPL 2.0 https://central.sonatype.com/artifact/jakarta.annotation/jakarta.annotation-api/2.0.0 -> EPL 2.0 https://central.sonatype.com/artifact/jakarta.servlet/jakarta.servlet-api/4.0.4 -> EPL 2.0 https://central.sonatype.com/artifact/jakarta.servlet/jakarta.servlet-api/5.0.0 -> EPL 2.0 https://central.sonatype.com/artifact/jakarta.websocket/jakarta.websocket-api/1.1.2 -> EPL 2.0 https://central.sonatype.com/artifact/jakarta.ws.rs/jakarta.ws.rs-api/3.0.0 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-framework/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-http-server/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-http-servlet/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.grizzly/grizzly-http/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.hk2.external/aopalliance-repackaged/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.hk2/hk2-api/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.hk2/hk2-locator/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.hk2/hk2-utils/3.0.1 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.hk2/osgi-resource-locator/1.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.connectors/jersey-apache-connector/3.0.3 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.jersey.core/jersey-client/3.0.3 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.jersey.core/jersey-common/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.containers/jersey-container-grizzly2-http/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.containers/jersey-container-grizzly2-servlet/3.0.3 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.jersey.containers/jersey-container-servlet/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.containers/jersey-container-servlet-core/3.0.3 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.jersey.containers/jersey-container-servlet/3.0.3 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.jersey.core/jersey-client/3.0.3 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.jersey.core/jersey-common/3.0.3 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.jersey.core/jersey-server/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.ext/jersey-entity-filtering/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.inject/jersey-hk2/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.media/jersey-media-jaxb/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.media/jersey-media-json-jackson/3.0.3 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.jersey.core/jersey-server/3.0.3 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.jersey.test-framework/jersey-test-framework-core/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.glassfish.jersey.test-framework.providers/jersey-test-framework-provider-grizzly2/3.0.3 -> EPL 2.0 - https://central.sonatype.com/artifact/org.junit.jupiter/junit-jupiter/5.7.2 -> EPL 2.0 + https://central.sonatype.com/artifact/org.glassfish.jersey.test-framework/jersey-test-framework-core/3.0.3 -> EPL 2.0 https://central.sonatype.com/artifact/org.junit.jupiter/junit-jupiter-api/5.7.2 -> EPL 2.0 https://central.sonatype.com/artifact/org.junit.jupiter/junit-jupiter-engine/5.7.2 -> EPL 2.0 https://central.sonatype.com/artifact/org.junit.jupiter/junit-jupiter-params/5.7.2 -> EPL 2.0 + https://central.sonatype.com/artifact/org.junit.jupiter/junit-jupiter/5.7.2 -> EPL 2.0 https://central.sonatype.com/artifact/org.junit.platform/junit-platform-commons/1.7.2 -> EPL 2.0 https://central.sonatype.com/artifact/org.junit.platform/junit-platform-engine/1.7.2 -> EPL 2.0 - https://central.sonatype.com/artifact/org.glassfish.hk2/osgi-resource-locator/1.0.3 -> EPL 2.0 ======================================================================== Third party BSD-3-Clause licenses @@ -745,16 +847,16 @@ Third party BSD-3-Clause licenses The following components are provided under the BSD-3-Clause License. See project link for details. The text of each license is also included in licenses/LICENSE-[project].txt. - https://central.sonatype.com/artifact/org.ow2.asm/asm-analysis/9.2 -> BSD-3-Clause - https://central.sonatype.com/artifact/org.ow2.asm/asm-commons/9.2 -> BSD-3-Clause - https://central.sonatype.com/artifact/org.ow2.asm/asm-tree/9.2 -> BSD-3-Clause - https://central.sonatype.com/artifact/org.hamcrest/hamcrest/2.2 -> BSD-3-Clause - https://central.sonatype.com/artifact/com.sun.activation/jakarta.activation/2.0.0 -> BSD-3-Clause + https://central.sonatype.com/artifact/com.google.protobuf/protobuf-java-util/3.17.2 -> BSD-3-Clause https://central.sonatype.com/artifact/com.google.protobuf/protobuf-java/3.11.0 -> BSD-3-Clause https://central.sonatype.com/artifact/com.google.protobuf/protobuf-java/3.17.2 -> BSD-3-Clause https://central.sonatype.com/artifact/com.google.protobuf/protobuf-java/3.21.7 -> BSD-3-Clause https://central.sonatype.com/artifact/com.google.protobuf/protobuf-java/3.5.1 -> BSD-3-Clause - https://central.sonatype.com/artifact/com.google.protobuf/protobuf-java-util/3.17.2 -> BSD-3-Clause + https://central.sonatype.com/artifact/com.sun.activation/jakarta.activation/2.0.0 -> BSD-3-Clause + https://central.sonatype.com/artifact/org.hamcrest/hamcrest/2.2 -> BSD-3-Clause + https://central.sonatype.com/artifact/org.ow2.asm/asm-analysis/9.2 -> BSD-3-Clause + https://central.sonatype.com/artifact/org.ow2.asm/asm-commons/9.2 -> BSD-3-Clause + https://central.sonatype.com/artifact/org.ow2.asm/asm-tree/9.2 -> BSD-3-Clause https://central.sonatype.com/artifact/org.scala-lang.modules/scala-java8-compat_2.12/0.8.0 -> BSD-3-Clause https://central.sonatype.com/artifact/org.scala-lang/scala-library/2.12.7 -> BSD-3-Clause https://central.sonatype.com/artifact/org.scala-lang/scala-reflect/2.12.7 -> BSD-3-Clause @@ -765,32 +867,24 @@ Third party EDL 1.0 licenses The following components are provided under the EDL 1.0 License. See project link for details. The text of each license is also included in licenses/LICENSE-[project].txt. - https://central.sonatype.com/artifact/org.eclipse.collections/eclipse-collections/11.1.0 -> EDL 1.0 - https://central.sonatype.com/artifact/org.eclipse.collections/eclipse-collections-api/11.1.0 -> EDL 1.0 https://central.sonatype.com/artifact/com.sun.activation/jakarta.activation/2.0.1 -> EDL 1.0 + https://central.sonatype.com/artifact/com.sun.xml.bind/jaxb-core/3.0.2 -> EDL 1.0 + https://central.sonatype.com/artifact/com.sun.xml.bind/jaxb-impl/3.0.2 -> EDL 1.0 https://central.sonatype.com/artifact/jakarta.activation/jakarta.activation-api/1.2.2 -> EDL 1.0 https://central.sonatype.com/artifact/jakarta.xml.bind/jakarta.xml.bind-api/2.3.3 -> EDL 1.0 https://central.sonatype.com/artifact/jakarta.xml.bind/jakarta.xml.bind-api/3.0.0 -> EDL 1.0 - https://central.sonatype.com/artifact/com.sun.xml.bind/jaxb-core/3.0.2 -> EDL 1.0 - https://central.sonatype.com/artifact/com.sun.xml.bind/jaxb-impl/3.0.2 -> EDL 1.0 - -======================================================================== -Third party CC0 1.0 licenses -======================================================================== -The following components are provided under the CC0 1.0 License. See project link for details. -The text of each license is also included in licenses/LICENSE-[project].txt. - - https://central.sonatype.com/artifact/org.hdrhistogram/HdrHistogram/2.1.12 -> CC0 1.0 - https://central.sonatype.com/artifact/org.hdrhistogram/HdrHistogram/2.1.9 -> CC0 1.0 - https://central.sonatype.com/artifact/org.latencyutils/LatencyUtils/2.0.3 -> CC0 1.0 + https://central.sonatype.com/artifact/org.eclipse.collections/eclipse-collections-api/10.4.0 -> EDL 1.0 + https://central.sonatype.com/artifact/org.eclipse.collections/eclipse-collections-api/11.1.0 -> EDL 1.0 + https://central.sonatype.com/artifact/org.eclipse.collections/eclipse-collections/10.4.0 -> EDL 1.0 + https://central.sonatype.com/artifact/org.eclipse.collections/eclipse-collections/11.1.0 -> EDL 1.0 ======================================================================== -Third party CUP Parser Generator Copyright Notice, License, and Disclaimer licenses +Third party Historical Permission Notice and Disclaimer licenses ======================================================================== -The following components are provided under the CUP Parser Generator Copyright Notice, License, and Disclaimer License. See project link for details. +The following components are provided under the Historical Permission Notice and Disclaimer License. See project link for details. The text of each license is also included in licenses/LICENSE-[project].txt. - https://central.sonatype.com/artifact/com.github.vbmacher/java-cup-runtime/11b-20160615 -> CUP Parser Generator Copyright Notice, License, and Disclaimer + https://central.sonatype.com/artifact/com.github.vbmacher/java-cup-runtime/11b-20160615 -> Historical Permission Notice and Disclaimer ======================================================================== Third party CDDL licenses @@ -827,15 +921,6 @@ The text of each license is also included in licenses/LICENSE-[project].txt. https://central.sonatype.com/artifact/junit/junit/4.13.1 -> EPL 1.0 https://central.sonatype.com/artifact/junit/junit/4.13.2 -> EPL 1.0 -======================================================================== -Third party BSD-2-Clause licenses -======================================================================== -The following components are provided under the BSD-2-Clause License. See project link for details. -The text of each license is also included in licenses/LICENSE-[project].txt. - - https://central.sonatype.com/artifact/org.postgresql/postgresql/42.4.3 -> BSD-2-Clause - https://central.sonatype.com/artifact/com.github.luben/zstd-jni/1.5.5-1 -> BSD-2-Clause - ======================================================================== Third party Public Domain licenses ======================================================================== diff --git a/install-dist/release-docs/NOTICE b/install-dist/release-docs/NOTICE index f3eb6d4cc4..fdded4e6dd 100644 --- a/install-dist/release-docs/NOTICE +++ b/install-dist/release-docs/NOTICE @@ -1,5 +1,5 @@ -Apache HugeGraph(incubating) -Copyright 2022-2025 The Apache Software Foundation +Apache HugeGraph +Copyright 2022-2026 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). @@ -314,991 +314,114 @@ Copyright 2003-2020 The Apache Software Foundation ======================================================================== -hbase-shaded-endpoint NOTICE +hbase-endpoint NOTICE ======================================================================== -hugegraph-hbase-shaded-endpoint +Apache HBase - Endpoint Copyright 2007-2021 The Apache Software Foundation -==== -hugegraph-hbase-shaded-endpoint contained works - -This product contains additional works that are distributed under licenses -other than ASL v2. See LICENSE for full details - --- -This product includes portions of the Bootstrap project v3.0.0 - -Copyright 2013 Twitter, Inc. - -Licensed under the Apache License v2.0 - -This product uses the Glyphicons Halflings icon set. - -http://glyphicons.com/ - -Copyright Jan Kovařík - -Licensed under the Apache License v2.0 as a part of the Bootstrap project. - --- -This product includes the 'Findbugs Annotations under Apache License' project -(https://github.com/stephenc/findbugs-annotations), version 1.3.9-1 -licensed under the Apache Software License, version 2.0. --- -This product includes findbugs-annotations - -Licensed under Apache License, Version 2.0, see LICENSE for details. - -incorporated from com.github.stephenc.findbugs:findbugs-annotations:jar:1.3.9-1 - -For source see 'http://stephenc.github.com/findbugs-annotations/findbugs-annotations'. --- -This product includes gson - -incorporated from com.google.code.gson:gson:jar:2.2.4 - -For source see 'http://code.google.com/p/google-gson/gson'. --- -This product includes guava - -incorporated from com.google.guava:guava:jar:11.0.2 - -For source see 'http://code.google.com/p/guava-libraries/guava/guava'. --- -This product includes java-xmlbuilder - -incorporated from com.jamesmurty.utils:java-xmlbuilder:jar:0.4 - -For source see 'http://code.google.com/p/java-xmlbuilder/java-xmlbuilder'. --- -This product includes commons-beanutils-core - -incorporated from commons-beanutils:commons-beanutils-core:jar:1.8.0 - -For source see 'http://commons.apache.org/beanutils/commons-beanutils-core'. --- -This product includes commons-cli - -incorporated from commons-cli:commons-cli:jar:1.2 - -For source see 'http://commons.apache.org/cli/commons-cli'. --- -This product includes commons-codec - -incorporated from commons-codec:commons-codec:jar:1.10 - -For source see 'http://commons.apache.org/proper/commons-codec/commons-codec'. --- -This product includes Apache Commons Collections - -incorporated from commons-collections:commons-collections:jar:3.2.2 - -For source see 'http://commons.apache.org/collections/'. --- -This product includes commons-configuration - -incorporated from commons-configuration:commons-configuration:jar:1.6 - -For source see 'http://commons.apache.org/${pom.artifactId.substring(8)}/commons-configuration'. --- -This product includes commons-digester - -incorporated from commons-digester:commons-digester:jar:1.8 - -For source see 'http://jakarta.apache.org/commons/digester/commons-digester'. --- -This product includes commons-httpclient - -incorporated from commons-httpclient:commons-httpclient:jar:3.1 - -For source see 'http://jakarta.apache.org/httpcomponents/httpclient-3.x/commons-httpclient'. --- -This product includes commons-io - -incorporated from commons-io:commons-io:jar:2.5 - -For source see 'http://commons.apache.org/proper/commons-io/commons-io'. --- -This product includes commons-lang - -incorporated from commons-lang:commons-lang:jar:2.6 - -For source see 'http://commons.apache.org/lang/commons-lang'. --- -This product includes commons-net - -incorporated from commons-net:commons-net:jar:3.1 - -For source see 'http://commons.apache.org/net/commons-net'. --- -This product includes metrics-core - -incorporated from io.dropwizard.metrics:metrics-core:jar:3.2.6 - -For source see 'http://metrics.dropwizard.io/metrics-core/metrics-core'. --- -This product includes JUnit - -Licensed under Eclipse Public License 1.0, see LICENSE for details. - -incorporated from junit:junit:jar:4.12 - -For source see 'http://junit.org/'. --- -This product includes 'Apache log4j' -Copyright 2010 The Apache Software Foundation - --- -This product includes log4j - -incorporated from log4j:log4j:jar:1.2.17 - -For source see 'http://logging.apache.org/log4j/1.2/log4j'. --- -This product includes 'Jets3t', which includes software developed by: - - The Apache Software Foundation (http://www.apache.org/). - - The ExoLab Project (http://www.exolab.org/) - - Sun Microsystems (http://www.sun.com/) - - Codehaus (http://castor.codehaus.org) - - Tatu Saloranta (http://wiki.fasterxml.com/TatuSaloranta) - --- -This product includes jets3t - -incorporated from net.java.dev.jets3t:jets3t:jar:0.9.0 - -For source see 'http://www.jets3t.org/jets3t'. --- -This product includes avro - -incorporated from org.apache.avro:avro:jar:1.7.7 - -For source see 'http://avro.apache.org/avro'. --- -This product includes commons-compress - -incorporated from org.apache.commons:commons-compress:jar:1.4.1 - -For source see 'http://commons.apache.org/compress/commons-compress'. --- -This product includes Apache Commons Crypto - -incorporated from org.apache.commons:commons-crypto:jar:1.0.0 - -For source see 'http://commons.apache.org/proper/commons-crypto/'. --- -This product includes software from the Spring Framework, -under the Apache License 2.0 (see: StringUtils.containsWhitespace()) - --- -This product includes Apache Commons Lang - -incorporated from org.apache.commons:commons-lang3:jar:3.6 - -For source see 'http://commons.apache.org/proper/commons-lang/'. --- -This product includes commons-math3 - -incorporated from org.apache.commons:commons-math3:jar:3.6.1 - -For source see 'http://commons.apache.org/proper/commons-math/commons-math3'. --- -This product includes curator-client - -incorporated from org.apache.curator:curator-client:jar:4.0.0 - -For source see 'http://curator.apache.org/curator-client/curator-client'. --- -This product includes curator-framework - -incorporated from org.apache.curator:curator-framework:jar:4.0.0 - -For source see 'http://curator.apache.org/curator-framework/curator-framework'. --- -This product includes curator-recipes - -incorporated from org.apache.curator:curator-recipes:jar:4.0.0 - -For source see 'http://curator.apache.org/curator-recipes/curator-recipes'. --- -This product includes api-asn1-api - -incorporated from org.apache.directory.api:api-asn1-api:jar:1.0.0-M20 - -For source see 'http://directory.apache.org/api-parent/api-asn1-parent/api-asn1-api/api-asn1-api'. --- -This product includes api-util - -incorporated from org.apache.directory.api:api-util:jar:1.0.0-M20 - -For source see 'http://directory.apache.org/api-parent/api-util/api-util'. --- -This product includes apacheds-i18n - -incorporated from org.apache.directory.server:apacheds-i18n:jar:2.0.0-M15 - -For source see 'http://directory.apache.org/apacheds/1.5/apacheds-i18n/apacheds-i18n'. --- -This product includes apacheds-kerberos-codec - -incorporated from org.apache.directory.server:apacheds-kerberos-codec:jar:2.0.0-M15 - -For source see 'http://directory.apache.org/apacheds/1.5/apacheds-kerberos-codec/apacheds-kerberos-codec'. --- -This product includes hadoop-annotations - -incorporated from org.apache.hadoop:hadoop-annotations:jar:2.7.7 - -For source see '${dep.url}'. --- -This product includes hadoop-auth - -incorporated from org.apache.hadoop:hadoop-auth:jar:2.7.7 - -For source see '${dep.url}'. --- -This product includes hadoop-common - -incorporated from org.apache.hadoop:hadoop-common:jar:2.7.7 - -For source see '${dep.url}'. --- This product includes Apache HBase - Client -incorporated from org.apache.hbase:hbase-client:jar:2.0.6 +incorporated from org.apache.hbase:hbase-client:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-client'. -- This product includes Apache HBase - Common -incorporated from org.apache.hbase:hbase-common:jar:2.0.6 +incorporated from org.apache.hbase:hbase-common:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-common'. -- This product includes Apache HBase - Coprocessor Endpoint -incorporated from org.apache.hbase:hbase-endpoint:jar:2.0.6 +incorporated from org.apache.hbase:hbase-endpoint:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-endpoint'. -- This product includes Apache HBase - Hadoop Compatibility -incorporated from org.apache.hbase:hbase-hadoop-compat:jar:2.0.6 +incorporated from org.apache.hbase:hbase-hadoop-compat:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-hadoop-compat'. -- -This product includes Apache HBase - MapReduce +This product includes Apache HBase - Hadoop2 Compatibility -incorporated from org.apache.hbase:hbase-mapreduce:jar:2.0.6 +incorporated from org.apache.hbase:hbase-hadoop2-compat:jar:2.6.5 -For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-mapreduce'. +For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-hadoop2-compat'. -- This product includes Apache HBase - Metrics Implementation -incorporated from org.apache.hbase:hbase-metrics:jar:2.0.6 +incorporated from org.apache.hbase:hbase-metrics:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-metrics'. -- This product includes Apache HBase - Metrics API -incorporated from org.apache.hbase:hbase-metrics-api:jar:2.0.6 +incorporated from org.apache.hbase:hbase-metrics-api:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-metrics-api'. -- This product includes Apache HBase - Protocol -incorporated from org.apache.hbase:hbase-protocol:jar:2.0.6 +incorporated from org.apache.hbase:hbase-protocol:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-protocol'. -- This product includes Apache HBase - Shaded Protocol -incorporated from org.apache.hbase:hbase-protocol-shaded:jar:2.0.6 +incorporated from org.apache.hbase:hbase-protocol-shaded:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-protocol-shaded'. -- -This product includes Apache HBase - Replication +This product includes Apache HBase - Shaded Client -incorporated from org.apache.hbase:hbase-replication:jar:2.0.6 +incorporated from org.apache.hbase:hbase-shaded-client:jar:2.6.5 -For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-replication'. +For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-shaded-client'. -- -This product includes Apache HBase - Resource Bundle +This product includes Apache HBase - Logging -incorporated from org.apache.hbase:hbase-resource-bundle:jar:2.0.6 +incorporated from org.apache.hbase:hbase-logging:jar:2.6.5 -For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-resource-bundle'. +For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-logging'. -- This product includes Apache HBase - Zookeeper -incorporated from org.apache.hbase:hbase-zookeeper:jar:2.0.6 +incorporated from org.apache.hbase:hbase-zookeeper:jar:2.6.5 For source see 'http://hbase.apache.org/hbase-build-configuration/hbase-zookeeper'. -- This product includes Apache HBase Relocated (Shaded) Third-party Miscellaneous Libs -incorporated from org.apache.hbase.thirdparty:hbase-shaded-miscellaneous:jar:2.1.0 +incorporated from org.apache.hbase.thirdparty:hbase-shaded-miscellaneous:jar:4.1.13 For source see 'http://hbase.apache.org/hbase-shaded-miscellaneous'. -- This product includes Apache HBase Relocated (Shaded) Netty Libs -incorporated from org.apache.hbase.thirdparty:hbase-shaded-netty:jar:2.1.0 +incorporated from org.apache.hbase.thirdparty:hbase-shaded-netty:jar:4.1.13 For source see 'http://hbase.apache.org/hbase-shaded-netty'. -- This product includes Apache HBase Patched & Relocated (Shaded) Protobuf -incorporated from org.apache.hbase.thirdparty:hbase-shaded-protobuf:jar:2.1.0 +incorporated from org.apache.hbase.thirdparty:hbase-shaded-protobuf:jar:4.1.13 For source see 'http://hbase.apache.org/hbase-shaded-protobuf'. -- -This product includes htrace-core4 - -incorporated from org.apache.htrace:htrace-core4:jar:4.2.0-incubating - -For source see 'http://incubator.apache.org/projects/htrace.html/htrace-core4'. --- -This product includes httpclient - -incorporated from org.apache.httpcomponents:httpclient:jar:4.5.3 - -For source see 'http://hc.apache.org/httpcomponents-client/httpclient'. --- -This product includes httpcore - -incorporated from org.apache.httpcomponents:httpcore:jar:4.4.6 - -For source see 'http://hc.apache.org/httpcomponents-core-ga/httpcore'. --- -This product includes Apache Yetus - Audience Annotations - -incorporated from org.apache.yetus:audience-annotations:jar:0.5.0 - -For source see 'https://yetus.apache.org/audience-annotations'. --- -This product includes 'Apache ZooKeeper' -Copyright 2009-2012 The Apache Software Foundation +This product includes Apache HBase Relocated (Shaded) Gson --- -This product includes zookeeper - -incorporated from org.apache.zookeeper:zookeeper:jar:3.4.10 - -For source see '${dep.url}'. --- -This product includes jetty - -incorporated from org.mortbay.jetty:jetty:jar:6.1.26 - -For source see 'http://www.eclipse.org/jetty/jetty-parent/project/modules/jetty/jetty'. --- -This product includes jetty-sslengine - -incorporated from org.mortbay.jetty:jetty-sslengine:jar:6.1.26 - -For source see 'http://jetty.mortbay.org/jetty-sslengine'. --- -This product includes jetty-util - -incorporated from org.mortbay.jetty:jetty-util:jar:6.1.26 +incorporated from org.apache.hbase.thirdparty:hbase-shaded-gson:jar:4.1.13 -For source see 'http://www.eclipse.org/jetty/jetty-parent/project/jetty-util/jetty-util'. +For source see 'http://hbase.apache.org/hbase-shaded-gson'. -- -This product includes snappy-java - -incorporated from org.xerial.snappy:snappy-java:jar:1.0.5 - -For source see 'http://github.com/xerial/snappy-java/snappy-java'. --- -This product includes portions of 'The Jetty Web Container' - -Copyright 1995-2016 Mort Bay Consulting Pty Ltd. - -The UnixCrypt.java code ~Implements the one way cryptography used by -Unix systems for simple password protection. Copyright 1996 Aki Yoshida, -modified April 2001 by Iris Van den Broeke, Daniel Deville. -Permission to use, copy, modify and distribute UnixCrypt -for non-commercial or commercial purposes and without fee is -granted provided that the copyright notice appears in all copies. - -Some portions of the code are Copyright: - 2006 Tim Vernum - 1999 Jason Gilbert. - -. -licensed under the Apache Software License, version 2.0. - ----- ----- -Incorporated NOTICE files from bundled works below. ----- - -Apache HBase - Coprocessor Endpoint -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase Patched & Relocated (Shaded) Protobuf -Copyright 2017-2018 The Apache Software Foundation - ---- - -Apache Commons Collections -Copyright 2001-2015 The Apache Software Foundation - -Apache HBase Relocated (Shaded) Third-party Miscellaneous Libs -Copyright 2017-2018 The Apache Software Foundation - -Apache Commons CLI -Copyright 2001-2017 The Apache Software Foundation - -Apache HBase - Common -Copyright 2007-2019 The Apache Software Foundation - -Apache Commons Codec -Copyright 2002-2014 The Apache Software Foundation - -src/test/org/apache/commons/codec/language/DoubleMetaphoneTest.java -contains test data from http://aspell.net/test/orig/batch0.tab. -Copyright (C) 2002 Kevin Atkinson (kevina@gnu.org) - -=============================================================================== - -The content of package org.apache.commons.codec.language.bm has been translated -from the original php source code available at http://stevemorse.org/phoneticinfo.htm -with permission from the original authors. -Original source copyright: -Copyright (c) 2008 Alexander Beider & Stephen P. Morse. - -Apache Commons Lang -Copyright 2001-2017 The Apache Software Foundation - -This product includes software from the Spring Framework, -under the Apache License 2.0 (see: StringUtils.containsWhitespace()) - -Apache Commons IO -Copyright 2002-2016 The Apache Software Foundation - -Apache HBase - Hadoop Compatibility -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase - Metrics API -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase - Protocol -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase - Shaded Protocol -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase - Client -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase Relocated (Shaded) Netty Libs -Copyright 2017-2018 The Apache Software Foundation - -Apache HBase - Zookeeper -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase - MapReduce -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase - Metrics Implementation -Copyright 2007-2019 The Apache Software Foundation - -Apache HBase - Replication -Copyright 2007-2019 The Apache Software Foundation - -Curator Client -Copyright 2011-2017 The Apache Software Foundation - -This product includes software developed by The Apache Software -Foundation (http://www.apache.org/). - -The binary distribution of this product bundles binaries of -org.iq80.leveldb:leveldb-api (https://github.com/dain/leveldb), which has the -following notices: -* Copyright 2011 Dain Sundstrom -* Copyright 2011 FuseSource Corp. http://fusesource.com - -The binary distribution of this product bundles binaries of -org.fusesource.hawtjni:hawtjni-runtime (https://github.com/fusesource/hawtjni), -which has the following notices: -* This product includes software developed by FuseSource Corp. - http://fusesource.com -* This product includes software developed at - Progress Software Corporation and/or its subsidiaries or affiliates. -* This product includes software developed by IBM Corporation and others. - -The binary distribution of this product bundles binaries of -Gson 2.2.4, -which has the following notices: - - The Netty Project - ================= - -Please visit the Netty web site for more information: - - * http://netty.io/ - -Copyright 2014 The Netty Project - -The Netty Project licenses this file to you under the Apache License, -version 2.0 (the "License"); you may not use this file except in compliance -with the License. You may obtain a copy of the License at: - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -License for the specific language governing permissions and limitations -under the License. - -Also, please refer to each LICENSE..txt file, which is located in -the 'license' directory of the distribution file, for the license terms of the -components that this product depends on. - -------------------------------------------------------------------------------- -This product contains the extensions to Java Collections Framework which has -been derived from the works by JSR-166 EG, Doug Lea, and Jason T. Greene: - - * LICENSE: - * license/LICENSE.jsr166y.txt (Public Domain) - * HOMEPAGE: - * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/ - * http://viewvc.jboss.org/cgi-bin/viewvc.cgi/jbosscache/experimental/jsr166/ - -This product contains a modified version of Robert Harder's Public Domain -Base64 Encoder and Decoder, which can be obtained at: - - * LICENSE: - * license/LICENSE.base64.txt (Public Domain) - * HOMEPAGE: - * http://iharder.sourceforge.net/current/java/base64/ - -This product contains a modified portion of 'Webbit', an event based -WebSocket and HTTP server, which can be obtained at: - - * LICENSE: - * license/LICENSE.webbit.txt (BSD License) - * HOMEPAGE: - * https://github.com/joewalnes/webbit - -This product contains a modified portion of 'SLF4J', a simple logging -facade for Java, which can be obtained at: - - * LICENSE: - * license/LICENSE.slf4j.txt (MIT License) - * HOMEPAGE: - * http://www.slf4j.org/ - -This product contains a modified portion of 'ArrayDeque', written by Josh -Bloch of Google, Inc: - - * LICENSE: - * license/LICENSE.deque.txt (Public Domain) - -This product contains a modified portion of 'Apache Harmony', an open source -Java SE, which can be obtained at: - - * LICENSE: - * license/LICENSE.harmony.txt (Apache License 2.0) - * HOMEPAGE: - * http://archive.apache.org/dist/harmony/ - -This product contains a modified version of Roland Kuhn's ASL2 -AbstractNodeQueue, which is based on Dmitriy Vyukov's non-intrusive MPSC queue. -It can be obtained at: - - * LICENSE: - * license/LICENSE.abstractnodequeue.txt (Public Domain) - * HOMEPAGE: - * https://github.com/akka/akka/blob/wip-2.2.3-for-scala-2.11/akka-actor/src/main/java/akka/dispatch/AbstractNodeQueue.java - -This product contains a modified portion of 'jbzip2', a Java bzip2 compression -and decompression library written by Matthew J. Francis. It can be obtained at: - - * LICENSE: - * license/LICENSE.jbzip2.txt (MIT License) - * HOMEPAGE: - * https://code.google.com/p/jbzip2/ - -This product contains a modified portion of 'libdivsufsort', a C API library to construct -the suffix array and the Burrows-Wheeler transformed string for any input string of -a constant-size alphabet written by Yuta Mori. It can be obtained at: - - * LICENSE: - * license/LICENSE.libdivsufsort.txt (MIT License) - * HOMEPAGE: - * https://code.google.com/p/libdivsufsort/ - -This product contains a modified portion of Nitsan Wakart's 'JCTools', Java Concurrency Tools for the JVM, - which can be obtained at: - - * LICENSE: - * license/LICENSE.jctools.txt (ASL2 License) - * HOMEPAGE: - * https://github.com/JCTools/JCTools - -This product optionally depends on 'JZlib', a re-implementation of zlib in -pure Java, which can be obtained at: - - * LICENSE: - * license/LICENSE.jzlib.txt (BSD style License) - * HOMEPAGE: - * http://www.jcraft.com/jzlib/ - -This product optionally depends on 'Compress-LZF', a Java library for encoding and -decoding data in LZF format, written by Tatu Saloranta. It can be obtained at: - - * LICENSE: - * license/LICENSE.compress-lzf.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/ning/compress - -This product optionally depends on 'lz4', a LZ4 Java compression -and decompression library written by Adrien Grand. It can be obtained at: - - * LICENSE: - * license/LICENSE.lz4.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/jpountz/lz4-java - -This product optionally depends on 'lzma-java', a LZMA Java compression -and decompression library, which can be obtained at: - - * LICENSE: - * license/LICENSE.lzma-java.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/jponge/lzma-java - -This product contains a modified portion of 'jfastlz', a Java port of FastLZ compression -and decompression library written by William Kinney. It can be obtained at: - - * LICENSE: - * license/LICENSE.jfastlz.txt (MIT License) - * HOMEPAGE: - * https://code.google.com/p/jfastlz/ - -This product contains a modified portion of and optionally depends on 'Protocol Buffers', Google's data -interchange format, which can be obtained at: - - * LICENSE: - * license/LICENSE.protobuf.txt (New BSD License) - * HOMEPAGE: - * http://code.google.com/p/protobuf/ - -This product optionally depends on 'Bouncy Castle Crypto APIs' to generate -a temporary self-signed X.509 certificate when the JVM does not provide the -equivalent functionality. It can be obtained at: - - * LICENSE: - * license/LICENSE.bouncycastle.txt (MIT License) - * HOMEPAGE: - * http://www.bouncycastle.org/ - -This product optionally depends on 'Snappy', a compression library produced -by Google Inc, which can be obtained at: - - * LICENSE: - * license/LICENSE.snappy.txt (New BSD License) - * HOMEPAGE: - * http://code.google.com/p/snappy/ - -This product optionally depends on 'JBoss Marshalling', an alternative Java -serialization API, which can be obtained at: - - * LICENSE: - * https://github.com/jboss-remoting/jboss-marshalling/blob/main/LICENSE.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/jboss-remoting/jboss-marshalling - -This product optionally depends on 'Caliper', Google's micro- -benchmarking framework, which can be obtained at: - - * LICENSE: - * license/LICENSE.caliper.txt (Apache License 2.0) - * HOMEPAGE: - * http://code.google.com/p/caliper/ - -This product optionally depends on 'Apache Commons Logging', a logging -framework, which can be obtained at: - - * LICENSE: - * license/LICENSE.commons-logging.txt (Apache License 2.0) - * HOMEPAGE: - * http://commons.apache.org/logging/ - -This product optionally depends on 'Apache Log4J', a logging framework, which -can be obtained at: - - * LICENSE: - * license/LICENSE.log4j.txt (Apache License 2.0) - * HOMEPAGE: - * http://logging.apache.org/log4j/ - -This product optionally depends on 'Aalto XML', an ultra-high performance -non-blocking XML processor, which can be obtained at: - - * LICENSE: - * license/LICENSE.aalto-xml.txt (Apache License 2.0) - * HOMEPAGE: - * http://wiki.fasterxml.com/AaltoHome - -This product contains a modified version of 'HPACK', a Java implementation of -the HTTP/2 HPACK algorithm written by Twitter. It can be obtained at: - - * LICENSE: - * license/LICENSE.hpack.txt (Apache License 2.0) - * HOMEPAGE: - * https://github.com/twitter/hpack - -This product contains a modified portion of 'Apache Commons Lang', a Java library -provides utilities for the java.lang API, which can be obtained at: - - * LICENSE: - * license/LICENSE.commons-lang.txt (Apache License 2.0) - * HOMEPAGE: - * https://commons.apache.org/proper/commons-lang/ - -The binary distribution of this product bundles binaries of -Commons Codec 1.4, -which has the following notices: - * src/test/org/apache/commons/codec/language/DoubleMetaphoneTest.javacontains test data from http://aspell.net/test/orig/batch0.tab.Copyright (C) 2002 Kevin Atkinson (kevina@gnu.org) - =============================================================================== - The content of package org.apache.commons.codec.language.bm has been translated - from the original php source code available at http://stevemorse.org/phoneticinfo.htm - with permission from the original authors. - Original source copyright:Copyright (c) 2008 Alexander Beider & Stephen P. Morse. - -The binary distribution of this product bundles binaries of -Commons Lang 2.6, -which has the following notices: - * This product includes software from the Spring Framework,under the Apache License 2.0 (see: StringUtils.containsWhitespace()) - -The binary distribution of this product bundles binaries of -Apache Log4j 1.2.17, -which has the following notices: - * ResolverUtil.java - Copyright 2005-2006 Tim Fennell - Dumbster SMTP test server - Copyright 2004 Jason Paul Kitchen - TypeUtil.java - Copyright 2002-2012 Ramnivas Laddad, Juergen Hoeller, Chris Beams - -The binary distribution of this product bundles binaries of -Jetty 6.1.26, -which has the following notices: - * ============================================================== - Jetty Web Container - Copyright 1995-2016 Mort Bay Consulting Pty Ltd. - ============================================================== - - The Jetty Web Container is Copyright Mort Bay Consulting Pty Ltd - unless otherwise noted. - - Jetty is dual licensed under both - - * The Apache 2.0 License - http://www.apache.org/licenses/LICENSE-2.0.html - - and - - * The Eclipse Public 1.0 License - http://www.eclipse.org/legal/epl-v10.html - - Jetty may be distributed under either license. - - ------ - Eclipse - - The following artifacts are EPL. - * org.eclipse.jetty.orbit:org.eclipse.jdt.core - - The following artifacts are EPL and ASL2. - * org.eclipse.jetty.orbit:javax.security.auth.message - - The following artifacts are EPL and CDDL 1.0. - * org.eclipse.jetty.orbit:javax.mail.glassfish - - ------ - Oracle - - The following artifacts are CDDL - - * javax.servlet:javax.servlet-api - * javax.annotation:javax.annotation-api - * javax.transaction:javax.transaction-api - * javax.websocket:javax.websocket-api - - ------ - Oracle OpenJDK - - If ALPN is used to negotiate HTTP/2 connections, then the following - artifacts may be included in the distribution or downloaded when ALPN - module is selected. - - ------ - OW2 - - The following artifacts are licensed by the OW2 Foundation according to the - terms of http://asm.ow2.org/license.html - - org.ow2.asm:asm-commons - org.ow2.asm:asm - - ------ - Apache - - The following artifacts are ASL2 licensed. - - org.apache.taglibs:taglibs-standard-spec - org.apache.taglibs:taglibs-standard-impl - - ------ - MortBay - - The following artifacts are ASL2 licensed. Based on selected classes from - following Apache Tomcat jars, all ASL2 licensed. - - org.mortbay.jasper:apache-jsp - org.apache.tomcat:tomcat-jasper - org.apache.tomcat:tomcat-juli - org.apache.tomcat:tomcat-jsp-api - org.apache.tomcat:tomcat-el-api - org.apache.tomcat:tomcat-jasper-el - org.apache.tomcat:tomcat-api - org.apache.tomcat:tomcat-util-scan - org.apache.tomcat:tomcat-util - - org.mortbay.jasper:apache-el - org.apache.tomcat:tomcat-jasper-el - org.apache.tomcat:tomcat-el-api - - ------ - Mortbay - - The following artifacts are CDDL. - org.eclipse.jetty.toolchain:jetty-schemas - - ------ - Assorted - - The UnixCrypt.java code implements the one way cryptography used by - Unix systems for simple password protection. Copyright 1996 Aki Yoshida, - modified April 2001 by Iris Van den Broeke, Daniel Deville. - Permission to use, copy, modify and distribute UnixCrypt - for non-commercial or commercial purposes and without fee is - granted provided that the copyright notice appears in all copies./ - -The binary distribution of this product bundles binaries of -Snappy for Java 1.0.4.1, -which has the following notices: - * This product includes software developed by Google - Snappy: http://code.google.com/p/snappy/ (New BSD License) - - This product includes software developed by Apache - PureJavaCrc32C from apache-hadoop-common http://hadoop.apache.org/ - (Apache 2.0 license) - - This library containd statically linked libstdc++. This inclusion is allowed by - "GCC RUntime Library Exception" - http://gcc.gnu.org/onlinedocs/libstdc++/manual/license.html - - == Contributors == - * Tatu Saloranta - * Providing benchmark suite - * Alec Wysoker - * Performance and memory usage improvement - -The binary distribution of this product bundles binaries of -Xerces2 Java Parser 2.9.1, -which has the following notices: - * ========================================================================= - == NOTICE file corresponding to section 4(d) of the Apache License, == - == Version 2.0, in this case for the Apache Xerces Java distribution. == - ========================================================================= - - Apache Xerces Java - Copyright 1999-2007 The Apache Software Foundation - - This product includes software developed at - The Apache Software Foundation (http://www.apache.org/). - - Portions of this software were originally based on the following: - - software copyright (c) 1999, IBM Corporation., http://www.ibm.com. - - software copyright (c) 1999, Sun Microsystems., http://www.sun.com. - - voluntary contributions made by Paul Eng on behalf of the - Apache Software Foundation that were originally developed at iClick, Inc., - software copyright (c) 1999. - -Apache Commons CLI -Copyright 2001-2009 The Apache Software Foundation - -This product includes software developed by -The Apache Software Foundation (http://www.apache.org/). - -Apache Commons Math -Copyright 2001-2016 The Apache Software Foundation - -This product includes software developed for Orekit by -CS Systèmes d'Information (http://www.c-s.fr/) -Copyright 2010-2012 CS Systèmes d'Information - -Apache Jakarta HttpClient -Copyright 1999-2007 The Apache Software Foundation - -Apache Commons Net -Copyright 2001-2012 The Apache Software Foundation - -Apache HttpCore -Copyright 2005-2017 The Apache Software Foundation - -Apache Commons Lang -Copyright 2001-2011 The Apache Software Foundation - -Apache Commons Configuration -Copyright 2001-2008 The Apache Software Foundation - -Apache Jakarta Commons Digester -Copyright 2001-2006 The Apache Software Foundation - -Apache Commons BeanUtils -Copyright 2000-2008 The Apache Software Foundation - -Apache Avro -Copyright 2009-2014 The Apache Software Foundation - -Curator Recipes -Copyright 2011-2017 The Apache Software Foundation - -Apache Commons Compress -Copyright 2002-2012 The Apache Software Foundation - -Apache HttpClient -Copyright 1999-2017 The Apache Software Foundation - -ApacheDS Protocol Kerberos Codec -Copyright 2003-2013 The Apache Software Foundation - -ApacheDS I18n -Copyright 2003-2013 The Apache Software Foundation - -Apache Directory API ASN.1 API -Copyright 2003-2013 The Apache Software Foundation +This product includes Apache HBase Relocated Unsafe Operations -Apache Directory LDAP API Utilities -Copyright 2003-2013 The Apache Software Foundation +incorporated from org.apache.hbase.thirdparty:hbase-unsafe:jar:4.1.13 -Curator Framework -Copyright 2011-2017 The Apache Software Foundation +For source see 'http://hbase.apache.org/hbase-unsafe'. ======================================================================== diff --git a/install-dist/release-docs/licenses/LICENSE-LatencyUtils-2.0.3.txt b/install-dist/release-docs/licenses/LICENSE-LatencyUtils-2.0.3.txt index a8e9f77c81..3405c711ae 100644 --- a/install-dist/release-docs/licenses/LICENSE-LatencyUtils-2.0.3.txt +++ b/install-dist/release-docs/licenses/LICENSE-LatencyUtils-2.0.3.txt @@ -1 +1,38 @@ -http://creativecommons.org/publicdomain/zero/1.0/ + * This code was Written by Gil Tene of Azul Systems, and released to the + * public domain, as explained at http://creativecommons.org/publicdomain/zero/1.0/ + + For users of this code who wish to consume it under the "BSD" license + rather than under the public domain or CC0 contribution text mentioned + above, the code found under this directory is *also* provided under the + following license (commonly referred to as the BSD 2-Clause License). This + license does not detract from the above stated release of the code into + the public domain, and simply represents an additional license granted by + the Author. + + ----------------------------------------------------------------------------- + ** Beginning of "BSD 2-Clause License" text. ** + + Copyright (c) 2012, 2013, 2014 Gil Tene + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + THE POSSIBILITY OF SUCH DAMAGE. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-io.txt b/install-dist/release-docs/licenses/LICENSE-RoaringBitmap-0.9.38.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-io.txt rename to install-dist/release-docs/licenses/LICENSE-RoaringBitmap-0.9.38.txt diff --git a/install-dist/release-docs/licenses/LICENSE-animal-sniffer-annotations-1.14.txt b/install-dist/release-docs/licenses/LICENSE-animal-sniffer-annotations-1.14.txt new file mode 100644 index 0000000000..fe2e64a989 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-animal-sniffer-annotations-1.14.txt @@ -0,0 +1 @@ +https://opensource.org/license/mit diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-logging.txt b/install-dist/release-docs/licenses/LICENSE-annotations-24.0.1.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-logging.txt rename to install-dist/release-docs/licenses/LICENSE-annotations-24.0.1.txt diff --git a/install-dist/release-docs/licenses/LICENSE-automaton-1.11-8.txt b/install-dist/release-docs/licenses/LICENSE-automaton-1.11-8.txt new file mode 100644 index 0000000000..87072f7202 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-automaton-1.11-8.txt @@ -0,0 +1 @@ +http://www.opensource.org/licenses/bsd-license.php diff --git a/install-dist/release-docs/licenses/LICENSE-checker-qual-2.0.0.txt b/install-dist/release-docs/licenses/LICENSE-checker-qual-2.0.0.txt new file mode 100644 index 0000000000..fe2e64a989 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-checker-qual-2.0.0.txt @@ -0,0 +1 @@ +https://opensource.org/license/mit diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-checker-qual.txt b/install-dist/release-docs/licenses/LICENSE-checker-qual-3.33.0.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-checker-qual.txt rename to install-dist/release-docs/licenses/LICENSE-checker-qual-3.33.0.txt diff --git a/install-dist/release-docs/licenses/LICENSE-commons-lang3-3.18.0.txt b/install-dist/release-docs/licenses/LICENSE-commons-lang3-3.18.0.txt new file mode 100644 index 0000000000..ff9ad4530f --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-commons-lang3-3.18.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-failureaccess.txt b/install-dist/release-docs/licenses/LICENSE-commons-pool2-2.0.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-failureaccess.txt rename to install-dist/release-docs/licenses/LICENSE-commons-pool2-2.0.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jaxb-ri.txt b/install-dist/release-docs/licenses/LICENSE-eclipse-collections-10.4.0.txt similarity index 54% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jaxb-ri.txt rename to install-dist/release-docs/licenses/LICENSE-eclipse-collections-10.4.0.txt index 74b62b6219..4e492acbfa 100644 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jaxb-ri.txt +++ b/install-dist/release-docs/licenses/LICENSE-eclipse-collections-10.4.0.txt @@ -1,11 +1,13 @@ -Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved. +Eclipse Distribution License - v 1.0 -Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +Copyright (c) 2007, Eclipse Foundation, Inc. and its licensors. -Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +All rights reserved. -Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: -Neither the name of the Eclipse Foundation, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + Neither the name of the Eclipse Foundation, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/install-dist/release-docs/licenses/LICENSE-eclipse-collections-api-10.4.0.txt b/install-dist/release-docs/licenses/LICENSE-eclipse-collections-api-10.4.0.txt new file mode 100644 index 0000000000..4e492acbfa --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-eclipse-collections-api-10.4.0.txt @@ -0,0 +1,13 @@ +Eclipse Distribution License - v 1.0 + +Copyright (c) 2007, Eclipse Foundation, Inc. and its licensors. + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + Neither the name of the Eclipse Foundation, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-httpclient.txt b/install-dist/release-docs/licenses/LICENSE-error_prone_annotations-2.1.3.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-httpclient.txt rename to install-dist/release-docs/licenses/LICENSE-error_prone_annotations-2.1.3.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-httpcore.txt b/install-dist/release-docs/licenses/LICENSE-error_prone_annotations-2.18.0.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-httpcore.txt rename to install-dist/release-docs/licenses/LICENSE-error_prone_annotations-2.18.0.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-annotations-2.14.0.txt b/install-dist/release-docs/licenses/LICENSE-fastutil-8.1.0.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-annotations-2.14.0.txt rename to install-dist/release-docs/licenses/LICENSE-fastutil-8.1.0.txt diff --git a/install-dist/release-docs/licenses/LICENSE-ivy-2.4.0.txt b/install-dist/release-docs/licenses/LICENSE-fury-core-0.9.0.txt similarity index 81% rename from install-dist/release-docs/licenses/LICENSE-ivy-2.4.0.txt rename to install-dist/release-docs/licenses/LICENSE-fury-core-0.9.0.txt index eb06170386..29f6f37257 100644 --- a/install-dist/release-docs/licenses/LICENSE-ivy-2.4.0.txt +++ b/install-dist/release-docs/licenses/LICENSE-fury-core-0.9.0.txt @@ -200,59 +200,66 @@ See the License for the specific language governing permissions and limitations under the License. - ------------------------------------------------------------------------------- -License for JCraft JSch package ------------------------------------------------------------------------------- -Copyright (c) 2002,2003,2004,2005,2006,2007 Atsuhiko Yamanaka, JCraft,Inc. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - ------------------------------------------------------------------------------- -License for jQuery ------------------------------------------------------------------------------- -Copyright (c) 2007 John Resig, http://jquery.com/ - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - \ No newline at end of file +================================================================ + +This product includes a number of Dependencies with separate copyright notices +and license terms. Your use of these submodules is subject to the terms and +conditions of the following licenses. + +================================================================ + +================================================================ +Apache-2.0 licenses +================================================================ +The following components are provided under the Apache-2.0 License. See project link for details. +The text of each license is the standard Apache 2.0 license. + +* guava (https://github.com/google/guava) + Files: + java/fury-core/src/main/java/org/apache/fury/util/Preconditions.java + java/fury-core/src/main/java/org/apache/fury/reflect/TypeParameter.java + java/fury-core/src/main/java/org/apache/fury/reflect/TypeRef.java + java/fury-core/src/main/java/org/apache/fury/util/concurrency/DirectExecutorService.java + +* spark (https://github.com/apache/spark) + Files: + java/fury-core/src/main/java/org/apache/fury/codegen/Code.java + java/fury-core/src/main/java/org/apache/fury/memory/Platform.java + +* commons-io (https://github.com/apache/commons-io) + Files: + java/fury-core/src/main/java/org/apache/fury/io/ClassLoaderObjectInputStream.java + + +================================================================ +BSD-3-Clause licenses +================================================================ +The following components are provided under the BSD-3-Clause License. See project link for details. +The text of each license is also included in licenses/LICENSE-[project].txt. + +* kryo (https://github.com/EsotericSoftware/kryo) + Files: + java/fury-core/src/main/java/org/apache/fury/collection/FuryObjectMap.java + java/fury-core/src/main/java/org/apache/fury/collection/IdentityMap.java + java/fury-core/src/main/java/org/apache/fury/collection/IdentityObjectIntMap.java + java/fury-core/src/main/java/org/apache/fury/collection/LongMap.java + java/fury-core/src/main/java/org/apache/fury/collection/LongLongMap.java + java/fury-core/src/main/java/org/apache/fury/collection/ObjectIntMap.java + java/fury-core/src/main/java/org/apache/fury/type/Generics.java + +* janino (https://github.com/janino-compiler/janino) + Files: + Shaded classes under org/apache/fury/shaded/org/codehaus/janino/* + Shaded classes under org/apache/fury/shaded/org/codehaus/commons/* + + +================================================================ +Public Domain +================================================================ +The following components are placed in the public domain. +The author hereby disclaims copyright to this source code. +See project link for details. + +* java_util (https://github.com/yonik/java_util) + Files: + java/fury-core/src/main/java/org/apache/fury/util/MurmurHash3.java diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-annotations.txt b/install-dist/release-docs/licenses/LICENSE-generex-1.0.2.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-annotations.txt rename to install-dist/release-docs/licenses/LICENSE-generex-1.0.2.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-core-2.14.0.txt b/install-dist/release-docs/licenses/LICENSE-guava-25.1-jre.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-core-2.14.0.txt rename to install-dist/release-docs/licenses/LICENSE-guava-25.1-jre.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-core.txt b/install-dist/release-docs/licenses/LICENSE-guava-32.0.1-android.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-core.txt rename to install-dist/release-docs/licenses/LICENSE-guava-32.0.1-android.txt diff --git a/install-dist/release-docs/licenses/LICENSE-hbase-shaded-endpoint-2.0.6.txt b/install-dist/release-docs/licenses/LICENSE-hbase-shaded-endpoint-2.0.6.txt deleted file mode 100644 index 5216b2900e..0000000000 --- a/install-dist/release-docs/licenses/LICENSE-hbase-shaded-endpoint-2.0.6.txt +++ /dev/null @@ -1,868 +0,0 @@ - - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -==== -hugegraph-hbase-shaded-endpoint contained works - -This product contains additional works that are distributed under licenses -other than ASL v2. Details below. - -==== --- -This product includes Protocol Buffer Java API licensed under the New BSD license. - -Copyright 2008, Google Inc. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -Code generated by the Protocol Buffer compiler is owned by the owner -of the input file used when generating it. This code is not -standalone and requires a support library to be linked with it. This -support library is itself covered by the above license. --- -This product includes JSch licensed under the BSD license. - -Copyright (c) 2002-2015 Atsuhiko Yamanaka, JCraft,Inc. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the distribution. - - 3. The names of the authors may not be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, -INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, -OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, -EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --- -This product includes xz licensed under the Public Domain. - -Licensing of XZ for Java -======================== - - All the files in this package have been written by Lasse Collin - and/or Igor Pavlov. All these files have been put into the - public domain. You can do whatever you want with these files. - - This software is provided "as is", without any warranty. --- -APACHE HADOOP SUBCOMPONENTS: - -The Apache Hadoop project contains subcomponents with separate copyright -notices and license terms. Your use of the source code for the these -subcomponents is subject to the terms and conditions of the following -licenses. - -For the org.apache.hadoop.util.bloom.* classes: - -/** - * - * Copyright (c) 2005, European Commission project OneLab under contract - * 034819 (http://www.one-lab.org) - * All rights reserved. - * Redistribution and use in source and binary forms, with or - * without modification, are permitted provided that the following - * conditions are met: - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the distribution. - * - Neither the name of the University Catholique de Louvain - UCL - * nor the names of its contributors may be used to endorse or - * promote products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ ----- -APACHE COMMONS MATH DERIVATIVE WORKS: - -The Apache commons-math library includes a number of subcomponents -whose implementation is derived from original sources written -in C or Fortran. License terms of the original sources -are reproduced below. - -=============================================================================== -For the lmder, lmpar and qrsolv Fortran routine from minpack and translated in -the LevenbergMarquardtOptimizer class in package -org.apache.commons.math3.optimization.general -Original source copyright and license statement: - -Minpack Copyright Notice (1999) University of Chicago. All rights reserved - -Redistribution and use in source and binary forms, with or -without modification, are permitted provided that the -following conditions are met: - -1. Redistributions of source code must retain the above -copyright notice, this list of conditions and the following -disclaimer. - -2. Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following -disclaimer in the documentation and/or other materials -provided with the distribution. - -3. The end-user documentation included with the -redistribution, if any, must include the following -acknowledgment: - - "This product includes software developed by the - University of Chicago, as Operator of Argonne National - Laboratory. - -Alternately, this acknowledgment may appear in the software -itself, if and wherever such third-party acknowledgments -normally appear. - -4. WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS" -WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE -UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND -THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES -OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE -OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY -OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR -USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF -THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4) -DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION -UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL -BE CORRECTED. - -5. LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT -HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF -ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT, -INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF -ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF -PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER -SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT -(INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE, -EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE -POSSIBILITY OF SUCH LOSS OR DAMAGES. -=============================================================================== - -Copyright and license statement for the odex Fortran routine developed by -E. Hairer and G. Wanner and translated in GraggBulirschStoerIntegrator class -in package org.apache.commons.math3.ode.nonstiff: - - -Copyright (c) 2004, Ernst Hairer - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - -- Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - -- Redistributions in binary form must reproduce the above copyright -notice, this list of conditions and the following disclaimer in the -documentation and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -=============================================================================== - -Copyright and license statement for the original Mersenne twister C -routines translated in MersenneTwister class in package -org.apache.commons.math3.random: - - Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura, - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - 3. The names of its contributors may not be used to endorse or promote - products derived from this software without specific prior written - permission. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -=============================================================================== - -The initial code for shuffling an array (originally in class -"org.apache.commons.math3.random.RandomDataGenerator", now replaced by -a method in class "org.apache.commons.math3.util.MathArrays") was -inspired from the algorithm description provided in -"Algorithms", by Ian Craw and John Pulham (University of Aberdeen 1999). -The textbook (containing a proof that the shuffle is uniformly random) is -available here: - http://citeseerx.ist.psu.edu/viewdoc/download;?doi=10.1.1.173.1898&rep=rep1&type=pdf - -=============================================================================== -License statement for the direction numbers in the resource files for Sobol sequences. - ------------------------------------------------------------------------------ -Licence pertaining to sobol.cc and the accompanying sets of direction numbers - ------------------------------------------------------------------------------ -Copyright (c) 2008, Frances Y. Kuo and Stephen Joe -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - * Neither the names of the copyright holders nor the names of the - University of New South Wales and the University of Waikato - and its contributors may be used to endorse or promote products derived - from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY -EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY -DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -=============================================================================== - -The initial commit of package "org.apache.commons.math3.ml.neuralnet" is -an adapted version of code developed in the context of the Data Processing -and Analysis Consortium (DPAC) of the "Gaia" project of the European Space -Agency (ESA). -=============================================================================== - -The initial commit of the class "org.apache.commons.math3.special.BesselJ" is -an adapted version of code translated from the netlib Fortran program, rjbesl -http://www.netlib.org/specfun/rjbesl by R.J. Cody at Argonne National -Laboratory (USA). There is no license or copyright statement included with the -original Fortran sources. -=============================================================================== - - -The BracketFinder (package org.apache.commons.math3.optimization.univariate) -and PowellOptimizer (package org.apache.commons.math3.optimization.general) -classes are based on the Python code in module "optimize.py" (version 0.5) -developed by Travis E. Oliphant for the SciPy library (http://www.scipy.org/) -Copyright © 2003-2009 SciPy Developers. - -SciPy license -Copyright © 2001, 2002 Enthought, Inc. -All rights reserved. - -Copyright © 2003-2013 SciPy Developers. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - * Neither the name of Enthought nor the names of the SciPy Developers may - be used to endorse or promote products derived from this software without - specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY -EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY -DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -=============================================================================== -==== -This product includes the following works licensed under the MIT license: - - * JCodings, Copyright (c) 2008-2012 The JCodings Authors - * Joni, Copyright (c) 2008-2014 The Joni Authors - * SLF4J API Module, Copyright (c) 2004-2013 QOS.ch - * SLF4J LOG4J-12 Binding, Copyright (c) 2004-2008 QOS.ch - -The MIT License (MIT) - -Copyright (c) - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. -==== -This product includes the following works licensed under the BSD 3-Clause license: - - * ParaNamer Core, Copyright (c) 2006 Paul Hammant & ThoughtWorks Inc - * xmlenc Library, Copyright 2003-2005, Ernst de Haan - -Copyright (c) , -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -3. Neither the name of the copyright holder nor the names of its contributors - may be used to endorse or promote products derived from this software without - specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -==== -This product includes the following works licensed under the Eclipse Public License 1.0: - - * JUnit, Copyright (c) 2002-2017 JUnit. All Rights Reserved. - - Eclipse Public License - v 1.0 - - THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE - PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION - OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. - - 1. DEFINITIONS - - "Contribution" means: - - a) in the case of the initial Contributor, the initial code and - documentation distributed under this Agreement, and - - b) in the case of each subsequent Contributor: - - i) changes to the Program, and - - ii) additions to the Program; - where such changes and/or additions to the Program - originate from and are distributed by that particular - Contributor. A Contribution 'originates' from a - Contributor if it was added to the Program by such - Contributor itself or anyone acting on such - Contributor's behalf. Contributions do not include - additions to the Program which: (i) are separate modules - of software distributed in conjunction with the Program - under their own license agreement, and (ii) are not - derivative works of the Program. - - "Contributor" means any person or entity that distributes the Program. - - "Licensed Patents" mean patent claims licensable by a Contributor - which are necessarily infringed by the use or sale of its - Contribution alone or when combined with the Program. - - "Program" means the Contributions distributed in accordance with - this Agreement. - - "Recipient" means anyone who receives the Program under this - Agreement, including all Contributors. - - 2. GRANT OF RIGHTS - - a) Subject to the terms of this Agreement, each Contributor - hereby grants Recipient a non-exclusive, worldwide, - royalty-free copyright license to reproduce, prepare - derivative works of, publicly display, publicly perform, - distribute and sublicense the Contribution of such - Contributor, if any, and such derivative works, in source - code and object code form. - - b) Subject to the terms of this Agreement, each Contributor - hereby grants Recipient a non-exclusive, worldwide, - royalty-free patent license under Licensed Patents to make, - use, sell, offer to sell, import and otherwise transfer the - Contribution of such Contributor, if any, in source code and - object code form. This patent license shall apply to the - combination of the Contribution and the Program if, at the - time the Contribution is added by the Contributor, such - addition of the Contribution causes such combination to be - covered by the Licensed Patents. The patent license shall not - apply to any other combinations which include the - Contribution. No hardware per se is licensed hereunder. - - c) Recipient understands that although each Contributor grants - the licenses to its Contributions set forth herein, no - assurances are provided by any Contributor that the Program - does not infringe the patent or other intellectual property - rights of any other entity. Each Contributor disclaims any - liability to Recipient for claims brought by any other entity - based on infringement of intellectual property rights or - otherwise. As a condition to exercising the rights and - licenses granted hereunder, each Recipient hereby assumes - sole responsibility to secure any other intellectual property - rights needed, if any. For example, if a third party patent - license is required to allow Recipient to distribute the - Program, it is Recipient's responsibility to acquire that - license before distributing the Program. - - d) Each Contributor represents that to its knowledge it has - sufficient copyright rights in its Contribution, if any, to - grant the copyright license set forth in this Agreement. - - 3. REQUIREMENTS - - A Contributor may choose to distribute the Program in object code - form under its own license agreement, provided that: - - a) it complies with the terms and conditions of this Agreement; and - - b) its license agreement: - - i) effectively disclaims on behalf of all Contributors all - warranties and conditions, express and implied, including - warranties or conditions of title and non-infringement, - and implied warranties or conditions of merchantability - and fitness for a particular purpose; - - ii) effectively excludes on behalf of all Contributors all - liability for damages, including direct, indirect, - special, incidental and consequential damages, such as - lost profits; - - iii) states that any provisions which differ from this - Agreement are offered by that Contributor alone and not - by any other party; and - - iv) states that source code for the Program is available - from such Contributor, and informs licensees how to - obtain it in a reasonable manner on or through a medium - customarily used for software exchange. - - When the Program is made available in source code form: - - a) it must be made available under this Agreement; and - - b) a copy of this Agreement must be included with each copy of - the Program. - - Contributors may not remove or alter any copyright notices contained - within the Program. - - Each Contributor must identify itself as the originator of its - Contribution, if any, in a manner that reasonably allows subsequent - Recipients to identify the originator of the Contribution. - - 4. COMMERCIAL DISTRIBUTION - - Commercial distributors of software may accept certain - responsibilities with respect to end users, business partners and - the like. While this license is intended to facilitate the - commercial use of the Program, the Contributor who includes the - Program in a commercial product offering should do so in a manner - which does not create potential liability for other Contributors. - Therefore, if a Contributor includes the Program in a commercial - product offering, such Contributor ("Commercial Contributor") hereby - agrees to defend and indemnify every other Contributor ("Indemnified - Contributor") against any losses, damages and costs (collectively - "Losses") arising from claims, lawsuits and other legal actions - brought by a third party against the Indemnified Contributor to the - extent caused by the acts or omissions of such Commercial - Contributor in connection with its distribution of the Program in a - commercial product offering. The obligations in this section do not - apply to any claims or Losses relating to any actual or alleged - intellectual property infringement. In order to qualify, an - Indemnified Contributor must: a) promptly notify the Commercial - Contributor in writing of such claim, and b) allow the Commercial - Contributor to control, and cooperate with the Commercial - Contributor in, the defense and any related settlement negotiations. - The Indemnified Contributor may participate in any such claim at its - own expense. - - For example, a Contributor might include the Program in a commercial - product offering, Product X. That Contributor is then a Commercial - Contributor. If that Commercial Contributor then makes performance - claims, or offers warranties related to Product X, those performance - claims and warranties are such Commercial Contributor's - responsibility alone. Under this section, the Commercial Contributor - would have to defend claims against the other Contributors related - to those performance claims and warranties, and if a court requires - any other Contributor to pay any damages as a result, the Commercial - Contributor must pay those damages. - - 5. NO WARRANTY - - EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS - PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF - ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, - ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, - MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient - is solely responsible for determining the appropriateness of using - and distributing the Program and assumes all risks associated with - its exercise of rights under this Agreement , including but not - limited to the risks and costs of program errors, compliance with - applicable laws, damage to or loss of data, programs or equipment, - and unavailability or interruption of operations. - - 6. DISCLAIMER OF LIABILITY - - EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT - NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON - ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF - THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS - GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH - DAMAGES. - - 7. GENERAL - - If any provision of this Agreement is invalid or unenforceable under - applicable law, it shall not affect the validity or enforceability - of the remainder of the terms of this Agreement, and without further - action by the parties hereto, such provision shall be reformed to - the minimum extent necessary to make such provision valid and - enforceable. - - If Recipient institutes patent litigation against any entity - (including a cross-claim or counterclaim in a lawsuit) alleging that - the Program itself (excluding combinations of the Program with other - software or hardware) infringes such Recipient's patent(s), then - such Recipient's rights granted under Section 2(b) shall terminate - as of the date such litigation is filed. - - All Recipient's rights under this Agreement shall terminate if it - fails to comply with any of the material terms or conditions of this - Agreement and does not cure such failure in a reasonable period of - time after becoming aware of such noncompliance. If all Recipient's - rights under this Agreement terminate, Recipient agrees to cease use - and distribution of the Program as soon as reasonably practicable. - However, Recipient's obligations under this Agreement and any - licenses granted by Recipient relating to the Program shall continue - and survive. - - Everyone is permitted to copy and distribute copies of this - Agreement, but in order to avoid inconsistency the Agreement is - copyrighted and may only be modified in the following manner. The - Agreement Steward reserves the right to publish new versions - (including revisions) of this Agreement from time to time. No one - other than the Agreement Steward has the right to modify this - Agreement. The Eclipse Foundation is the initial Agreement Steward. - The Eclipse Foundation may assign the responsibility to serve as the - Agreement Steward to a suitable separate entity. Each new version of - the Agreement will be given a distinguishing version number. The - Program (including Contributions) may always be distributed subject - to the version of the Agreement under which it was received. In - addition, after a new version of the Agreement is published, - Contributor may elect to distribute the Program (including its - Contributions) under the new version. Except as expressly stated in - Sections 2(a) and 2(b) above, Recipient receives no rights or - licenses to the intellectual property of any Contributor under this - Agreement, whether expressly, by implication, estoppel or otherwise. - All rights in the Program not expressly granted under this Agreement - are reserved. - - This Agreement is governed by the laws of the State of New York and - the intellectual property laws of the United States of America. No - party to this Agreement will bring a legal action under this - Agreement more than one year after the cause of action arose. Each - party waives its rights to a jury trial in any resulting litigation. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-databind-2.14.0.txt b/install-dist/release-docs/licenses/LICENSE-j2objc-annotations-1.1.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-databind-2.14.0.txt rename to install-dist/release-docs/licenses/LICENSE-j2objc-annotations-1.1.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-databind.txt b/install-dist/release-docs/licenses/LICENSE-j2objc-annotations-2.8.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-jackson-databind.txt rename to install-dist/release-docs/licenses/LICENSE-j2objc-annotations-2.8.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-log4j-api.txt b/install-dist/release-docs/licenses/LICENSE-jackson-annotations-2.15.2.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-log4j-api.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-annotations-2.15.2.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-log4j-slf4j-impl.txt b/install-dist/release-docs/licenses/LICENSE-jackson-core-2.15.2.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-log4j-slf4j-impl.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-core-2.15.2.txt diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-okhttp.txt b/install-dist/release-docs/licenses/LICENSE-jackson-databind-2.13.2.txt similarity index 100% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-okhttp.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-databind-2.13.2.txt diff --git a/install-dist/release-docs/licenses/LICENSE-lz4-java-1.8.0.txt b/install-dist/release-docs/licenses/LICENSE-jackson-dataformat-yaml-2.11.2.txt similarity index 100% rename from install-dist/release-docs/licenses/LICENSE-lz4-java-1.8.0.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-dataformat-yaml-2.11.2.txt diff --git a/install-dist/release-docs/licenses/LICENSE-fabric8-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-jackson-datatype-jsr310-2.11.2.txt similarity index 99% rename from install-dist/release-docs/licenses/LICENSE-fabric8-5.6.0.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-datatype-jsr310-2.11.2.txt index 261eeb9e9f..d645695673 100644 --- a/install-dist/release-docs/licenses/LICENSE-fabric8-5.6.0.txt +++ b/install-dist/release-docs/licenses/LICENSE-jackson-datatype-jsr310-2.11.2.txt @@ -1,3 +1,4 @@ + Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-codec.txt b/install-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base-2.15.2.txt similarity index 99% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-codec.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base-2.15.2.txt index 7a4a3ea242..d645695673 100644 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-codec.txt +++ b/install-dist/release-docs/licenses/LICENSE-jackson-jaxrs-base-2.15.2.txt @@ -199,4 +199,4 @@ distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file + limitations under the License. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-collections.txt b/install-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider-2.15.2.txt similarity index 99% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-collections.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider-2.15.2.txt index 7a4a3ea242..d645695673 100644 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-collections.txt +++ b/install-dist/release-docs/licenses/LICENSE-jackson-jaxrs-json-provider-2.15.2.txt @@ -199,4 +199,4 @@ distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file + limitations under the License. diff --git a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-configuration.txt b/install-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations-2.15.2.txt similarity index 99% rename from hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-configuration.txt rename to install-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations-2.15.2.txt index 7a4a3ea242..d645695673 100644 --- a/hugegraph-commons/hugegraph-dist/release-docs/licenses/LICENSE-commons-configuration.txt +++ b/install-dist/release-docs/licenses/LICENSE-jackson-module-jaxb-annotations-2.15.2.txt @@ -199,4 +199,4 @@ distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-java-cup-runtime-11b-20160615.txt b/install-dist/release-docs/licenses/LICENSE-java-cup-runtime-11b-20160615.txt index 040f80f317..f6160bc4f9 100644 --- a/install-dist/release-docs/licenses/LICENSE-java-cup-runtime-11b-20160615.txt +++ b/install-dist/release-docs/licenses/LICENSE-java-cup-runtime-11b-20160615.txt @@ -1 +1,7 @@ -http://www2.cs.tum.edu/projects/cup/install.php +CUP Parser Generator Copyright Notice, License, and Disclaimer +Copyright 1996-2015 by Scott Hudson, Frank Flannery, C. Scott Ananian, Michael Petter + +Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both the copyright notice and this permission notice and warranty disclaimer appear in supporting documentation, and that the names of the authors or their employers not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. + +The authors and their employers disclaim all warranties with regard to this software, including all implied warranties of merchantability and fitness. In no event shall the authors or their employers be liable for any special, indirect or consequential damages or any damages whatsoever resulting from loss of use, data or profits, whether in an action of contract, negligence or other tortious action, arising out of or in connection with the use or performance of this software. +This is an open source [license](https://opensource.org/license/historical-php/). diff --git a/install-dist/release-docs/licenses/LICENSE-javassist-3.25.0-GA.txt b/install-dist/release-docs/licenses/LICENSE-javassist-3.25.0-GA.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-javassist-3.25.0-GA.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-jcseg-core-2.2.0.txt b/install-dist/release-docs/licenses/LICENSE-jcseg-core-2.2.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-jcseg-core-2.2.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-jedis-2.5.1.txt b/install-dist/release-docs/licenses/LICENSE-jedis-2.5.1.txt new file mode 100644 index 0000000000..fe2e64a989 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-jedis-2.5.1.txt @@ -0,0 +1 @@ +https://opensource.org/license/mit diff --git a/install-dist/release-docs/licenses/LICENSE-jjwt-api-0.11.2.txt b/install-dist/release-docs/licenses/LICENSE-jjwt-api-0.11.2.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-jjwt-api-0.11.2.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-jjwt-impl-0.11.2.txt b/install-dist/release-docs/licenses/LICENSE-jjwt-impl-0.11.2.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-jjwt-impl-0.11.2.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-json-20210307.txt b/install-dist/release-docs/licenses/LICENSE-json-20210307.txt new file mode 100644 index 0000000000..be3a1de7bd --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-json-20210307.txt @@ -0,0 +1 @@ +Public Domain. diff --git a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-5.7.2.txt b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-5.7.2.txt index 520713de1c..a32decd83d 100644 --- a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-5.7.2.txt +++ b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-5.7.2.txt @@ -1,8 +1,98 @@ -Open Source Licenses -==================== - -This product may include a number of subcomponents with separate -copyright notices and license terms. Your use of the source code for -these subcomponents is subject to the terms and conditions of the -subcomponent's license, as noted in the LICENSE-.md -files. +Eclipse Public License - v 2.0 +============================== + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +### 1. Definitions + +“Contribution” means: +* **a)** in the case of the initial Contributor, the initial content Distributed under this Agreement, and +* **b)** in the case of each subsequent Contributor: + * **i)** changes to the Program, and + * **ii)** additions to the Program; +where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution “originates” from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. + +“Contributor” means any person or entity that Distributes the Program. + +“Licensed Patents” mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. + +“Program” means the Contributions Distributed in accordance with this Agreement. + +“Recipient” means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. + +“Derivative Works” shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. + +“Modified Works” shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. + +“Distribute” means the acts of **a)** distributing or **b)** making available in any manner that enables the transfer of a copy. + +“Source Code” means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. + +“Secondary License” means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. + +### 2. Grant of Rights + +**a)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. + +**b)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. + +**c)** Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. + +**d)** Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. + +**e)** Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). + +### 3. Requirements + +**3.1** If a Contributor Distributes the Program in any form, then: + +* **a)** the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and + +* **b)** the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: + * **i)** effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; + * **ii)** effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; + * **iii)** does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and + * **iv)** requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. + +**3.2** When the Program is Distributed as Source Code: + +* **a)** it must be made available under this Agreement, or if the Program **(i)** is combined with other material in a separate file or files made available under a Secondary License, and **(ii)** the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and +* **b)** a copy of this Agreement must be included with each copy of the Program. + +**3.3** Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (“notices”) contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. + +### 4. Commercial Distribution + +Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify every other Contributor (“Indemnified Contributor”) against any losses, damages and costs (collectively “Losses”) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: **a)** promptly notify the Commercial Contributor in writing of such claim, and **b)** allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. + +### 5. No Warranty + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. + +### 6. Disclaimer of Liability + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +### 7. General + +If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. + +Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. + +#### Exhibit A - Form of Secondary Licenses Notice + +> “This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.” + +Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. + +If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-api-5.7.2.txt b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-api-5.7.2.txt index 520713de1c..a32decd83d 100644 --- a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-api-5.7.2.txt +++ b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-api-5.7.2.txt @@ -1,8 +1,98 @@ -Open Source Licenses -==================== - -This product may include a number of subcomponents with separate -copyright notices and license terms. Your use of the source code for -these subcomponents is subject to the terms and conditions of the -subcomponent's license, as noted in the LICENSE-.md -files. +Eclipse Public License - v 2.0 +============================== + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +### 1. Definitions + +“Contribution” means: +* **a)** in the case of the initial Contributor, the initial content Distributed under this Agreement, and +* **b)** in the case of each subsequent Contributor: + * **i)** changes to the Program, and + * **ii)** additions to the Program; +where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution “originates” from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. + +“Contributor” means any person or entity that Distributes the Program. + +“Licensed Patents” mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. + +“Program” means the Contributions Distributed in accordance with this Agreement. + +“Recipient” means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. + +“Derivative Works” shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. + +“Modified Works” shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. + +“Distribute” means the acts of **a)** distributing or **b)** making available in any manner that enables the transfer of a copy. + +“Source Code” means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. + +“Secondary License” means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. + +### 2. Grant of Rights + +**a)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. + +**b)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. + +**c)** Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. + +**d)** Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. + +**e)** Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). + +### 3. Requirements + +**3.1** If a Contributor Distributes the Program in any form, then: + +* **a)** the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and + +* **b)** the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: + * **i)** effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; + * **ii)** effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; + * **iii)** does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and + * **iv)** requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. + +**3.2** When the Program is Distributed as Source Code: + +* **a)** it must be made available under this Agreement, or if the Program **(i)** is combined with other material in a separate file or files made available under a Secondary License, and **(ii)** the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and +* **b)** a copy of this Agreement must be included with each copy of the Program. + +**3.3** Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (“notices”) contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. + +### 4. Commercial Distribution + +Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify every other Contributor (“Indemnified Contributor”) against any losses, damages and costs (collectively “Losses”) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: **a)** promptly notify the Commercial Contributor in writing of such claim, and **b)** allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. + +### 5. No Warranty + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. + +### 6. Disclaimer of Liability + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +### 7. General + +If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. + +Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. + +#### Exhibit A - Form of Secondary Licenses Notice + +> “This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.” + +Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. + +If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-engine-5.7.2.txt b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-engine-5.7.2.txt index 520713de1c..a32decd83d 100644 --- a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-engine-5.7.2.txt +++ b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-engine-5.7.2.txt @@ -1,8 +1,98 @@ -Open Source Licenses -==================== - -This product may include a number of subcomponents with separate -copyright notices and license terms. Your use of the source code for -these subcomponents is subject to the terms and conditions of the -subcomponent's license, as noted in the LICENSE-.md -files. +Eclipse Public License - v 2.0 +============================== + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +### 1. Definitions + +“Contribution” means: +* **a)** in the case of the initial Contributor, the initial content Distributed under this Agreement, and +* **b)** in the case of each subsequent Contributor: + * **i)** changes to the Program, and + * **ii)** additions to the Program; +where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution “originates” from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. + +“Contributor” means any person or entity that Distributes the Program. + +“Licensed Patents” mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. + +“Program” means the Contributions Distributed in accordance with this Agreement. + +“Recipient” means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. + +“Derivative Works” shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. + +“Modified Works” shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. + +“Distribute” means the acts of **a)** distributing or **b)** making available in any manner that enables the transfer of a copy. + +“Source Code” means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. + +“Secondary License” means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. + +### 2. Grant of Rights + +**a)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. + +**b)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. + +**c)** Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. + +**d)** Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. + +**e)** Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). + +### 3. Requirements + +**3.1** If a Contributor Distributes the Program in any form, then: + +* **a)** the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and + +* **b)** the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: + * **i)** effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; + * **ii)** effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; + * **iii)** does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and + * **iv)** requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. + +**3.2** When the Program is Distributed as Source Code: + +* **a)** it must be made available under this Agreement, or if the Program **(i)** is combined with other material in a separate file or files made available under a Secondary License, and **(ii)** the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and +* **b)** a copy of this Agreement must be included with each copy of the Program. + +**3.3** Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (“notices”) contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. + +### 4. Commercial Distribution + +Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify every other Contributor (“Indemnified Contributor”) against any losses, damages and costs (collectively “Losses”) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: **a)** promptly notify the Commercial Contributor in writing of such claim, and **b)** allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. + +### 5. No Warranty + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. + +### 6. Disclaimer of Liability + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +### 7. General + +If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. + +Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. + +#### Exhibit A - Form of Secondary Licenses Notice + +> “This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.” + +Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. + +If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-params-5.7.2.txt b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-params-5.7.2.txt index 520713de1c..a32decd83d 100644 --- a/install-dist/release-docs/licenses/LICENSE-junit-jupiter-params-5.7.2.txt +++ b/install-dist/release-docs/licenses/LICENSE-junit-jupiter-params-5.7.2.txt @@ -1,8 +1,98 @@ -Open Source Licenses -==================== - -This product may include a number of subcomponents with separate -copyright notices and license terms. Your use of the source code for -these subcomponents is subject to the terms and conditions of the -subcomponent's license, as noted in the LICENSE-.md -files. +Eclipse Public License - v 2.0 +============================== + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +### 1. Definitions + +“Contribution” means: +* **a)** in the case of the initial Contributor, the initial content Distributed under this Agreement, and +* **b)** in the case of each subsequent Contributor: + * **i)** changes to the Program, and + * **ii)** additions to the Program; +where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution “originates” from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. + +“Contributor” means any person or entity that Distributes the Program. + +“Licensed Patents” mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. + +“Program” means the Contributions Distributed in accordance with this Agreement. + +“Recipient” means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. + +“Derivative Works” shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. + +“Modified Works” shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. + +“Distribute” means the acts of **a)** distributing or **b)** making available in any manner that enables the transfer of a copy. + +“Source Code” means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. + +“Secondary License” means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. + +### 2. Grant of Rights + +**a)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. + +**b)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. + +**c)** Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. + +**d)** Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. + +**e)** Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). + +### 3. Requirements + +**3.1** If a Contributor Distributes the Program in any form, then: + +* **a)** the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and + +* **b)** the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: + * **i)** effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; + * **ii)** effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; + * **iii)** does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and + * **iv)** requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. + +**3.2** When the Program is Distributed as Source Code: + +* **a)** it must be made available under this Agreement, or if the Program **(i)** is combined with other material in a separate file or files made available under a Secondary License, and **(ii)** the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and +* **b)** a copy of this Agreement must be included with each copy of the Program. + +**3.3** Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (“notices”) contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. + +### 4. Commercial Distribution + +Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify every other Contributor (“Indemnified Contributor”) against any losses, damages and costs (collectively “Losses”) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: **a)** promptly notify the Commercial Contributor in writing of such claim, and **b)** allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. + +### 5. No Warranty + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. + +### 6. Disclaimer of Liability + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +### 7. General + +If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. + +Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. + +#### Exhibit A - Form of Secondary Licenses Notice + +> “This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.” + +Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. + +If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/install-dist/release-docs/licenses/LICENSE-junit-platform-commons-1.7.2.txt b/install-dist/release-docs/licenses/LICENSE-junit-platform-commons-1.7.2.txt index 520713de1c..a32decd83d 100644 --- a/install-dist/release-docs/licenses/LICENSE-junit-platform-commons-1.7.2.txt +++ b/install-dist/release-docs/licenses/LICENSE-junit-platform-commons-1.7.2.txt @@ -1,8 +1,98 @@ -Open Source Licenses -==================== - -This product may include a number of subcomponents with separate -copyright notices and license terms. Your use of the source code for -these subcomponents is subject to the terms and conditions of the -subcomponent's license, as noted in the LICENSE-.md -files. +Eclipse Public License - v 2.0 +============================== + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +### 1. Definitions + +“Contribution” means: +* **a)** in the case of the initial Contributor, the initial content Distributed under this Agreement, and +* **b)** in the case of each subsequent Contributor: + * **i)** changes to the Program, and + * **ii)** additions to the Program; +where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution “originates” from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. + +“Contributor” means any person or entity that Distributes the Program. + +“Licensed Patents” mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. + +“Program” means the Contributions Distributed in accordance with this Agreement. + +“Recipient” means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. + +“Derivative Works” shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. + +“Modified Works” shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. + +“Distribute” means the acts of **a)** distributing or **b)** making available in any manner that enables the transfer of a copy. + +“Source Code” means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. + +“Secondary License” means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. + +### 2. Grant of Rights + +**a)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. + +**b)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. + +**c)** Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. + +**d)** Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. + +**e)** Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). + +### 3. Requirements + +**3.1** If a Contributor Distributes the Program in any form, then: + +* **a)** the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and + +* **b)** the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: + * **i)** effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; + * **ii)** effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; + * **iii)** does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and + * **iv)** requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. + +**3.2** When the Program is Distributed as Source Code: + +* **a)** it must be made available under this Agreement, or if the Program **(i)** is combined with other material in a separate file or files made available under a Secondary License, and **(ii)** the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and +* **b)** a copy of this Agreement must be included with each copy of the Program. + +**3.3** Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (“notices”) contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. + +### 4. Commercial Distribution + +Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify every other Contributor (“Indemnified Contributor”) against any losses, damages and costs (collectively “Losses”) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: **a)** promptly notify the Commercial Contributor in writing of such claim, and **b)** allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. + +### 5. No Warranty + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. + +### 6. Disclaimer of Liability + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +### 7. General + +If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. + +Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. + +#### Exhibit A - Form of Secondary Licenses Notice + +> “This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.” + +Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. + +If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/install-dist/release-docs/licenses/LICENSE-junit-platform-engine-1.7.2.txt b/install-dist/release-docs/licenses/LICENSE-junit-platform-engine-1.7.2.txt index 520713de1c..a32decd83d 100644 --- a/install-dist/release-docs/licenses/LICENSE-junit-platform-engine-1.7.2.txt +++ b/install-dist/release-docs/licenses/LICENSE-junit-platform-engine-1.7.2.txt @@ -1,8 +1,98 @@ -Open Source Licenses -==================== - -This product may include a number of subcomponents with separate -copyright notices and license terms. Your use of the source code for -these subcomponents is subject to the terms and conditions of the -subcomponent's license, as noted in the LICENSE-.md -files. +Eclipse Public License - v 2.0 +============================== + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +### 1. Definitions + +“Contribution” means: +* **a)** in the case of the initial Contributor, the initial content Distributed under this Agreement, and +* **b)** in the case of each subsequent Contributor: + * **i)** changes to the Program, and + * **ii)** additions to the Program; +where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution “originates” from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. + +“Contributor” means any person or entity that Distributes the Program. + +“Licensed Patents” mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. + +“Program” means the Contributions Distributed in accordance with this Agreement. + +“Recipient” means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. + +“Derivative Works” shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. + +“Modified Works” shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. + +“Distribute” means the acts of **a)** distributing or **b)** making available in any manner that enables the transfer of a copy. + +“Source Code” means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. + +“Secondary License” means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. + +### 2. Grant of Rights + +**a)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. + +**b)** Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. + +**c)** Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. + +**d)** Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. + +**e)** Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). + +### 3. Requirements + +**3.1** If a Contributor Distributes the Program in any form, then: + +* **a)** the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and + +* **b)** the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: + * **i)** effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; + * **ii)** effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; + * **iii)** does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and + * **iv)** requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. + +**3.2** When the Program is Distributed as Source Code: + +* **a)** it must be made available under this Agreement, or if the Program **(i)** is combined with other material in a separate file or files made available under a Secondary License, and **(ii)** the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and +* **b)** a copy of this Agreement must be included with each copy of the Program. + +**3.3** Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (“notices”) contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. + +### 4. Commercial Distribution + +Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (“Commercial Contributor”) hereby agrees to defend and indemnify every other Contributor (“Indemnified Contributor”) against any losses, damages and costs (collectively “Losses”) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: **a)** promptly notify the Commercial Contributor in writing of such claim, and **b)** allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. + +### 5. No Warranty + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. + +### 6. Disclaimer of Liability + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +### 7. General + +If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. + +Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. + +#### Exhibit A - Form of Secondary Licenses Notice + +> “This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.” + +Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. + +If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-client-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-client-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-client-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-admissionregistration-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-admissionregistration-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-admissionregistration-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-apiextensions-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-apiextensions-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-apiextensions-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-apps-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-apps-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-apps-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-autoscaling-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-autoscaling-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-autoscaling-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-batch-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-batch-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-batch-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-certificates-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-certificates-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-certificates-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-common-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-common-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-common-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-coordination-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-coordination-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-coordination-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-core-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-core-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-core-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-discovery-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-discovery-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-discovery-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-events-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-events-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-events-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-extensions-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-extensions-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-extensions-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-flowcontrol-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-flowcontrol-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-flowcontrol-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-metrics-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-metrics-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-metrics-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-networking-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-networking-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-networking-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-node-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-node-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-node-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-policy-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-policy-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-policy-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-rbac-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-rbac-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-rbac-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-scheduling-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-scheduling-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-scheduling-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-kubernetes-model-storageclass-5.6.0.txt b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-storageclass-5.6.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-kubernetes-model-storageclass-5.6.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-logging-interceptor-3.12.12.txt b/install-dist/release-docs/licenses/LICENSE-logging-interceptor-3.12.12.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-logging-interceptor-3.12.12.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-analyzers-common-5.2.1.txt b/install-dist/release-docs/licenses/LICENSE-lucene-analyzers-common-5.2.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-analyzers-common-5.2.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-analyzers-smartcn-7.4.0.txt b/install-dist/release-docs/licenses/LICENSE-lucene-analyzers-smartcn-7.4.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-analyzers-smartcn-7.4.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-backward-codecs-5.2.1.txt b/install-dist/release-docs/licenses/LICENSE-lucene-backward-codecs-5.2.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-backward-codecs-5.2.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-core-7.4.0.txt b/install-dist/release-docs/licenses/LICENSE-lucene-core-7.4.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-core-7.4.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-misc-5.2.1.txt b/install-dist/release-docs/licenses/LICENSE-lucene-misc-5.2.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-misc-5.2.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-queries-5.2.1.txt b/install-dist/release-docs/licenses/LICENSE-lucene-queries-5.2.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-queries-5.2.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-queryparser-5.2.1.txt b/install-dist/release-docs/licenses/LICENSE-lucene-queryparser-5.2.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-queryparser-5.2.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-sandbox-5.2.1.txt b/install-dist/release-docs/licenses/LICENSE-lucene-sandbox-5.2.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-sandbox-5.2.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lucene-suggest-5.2.1.txt b/install-dist/release-docs/licenses/LICENSE-lucene-suggest-5.2.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lucene-suggest-5.2.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-lz4-java-1.8.1.txt b/install-dist/release-docs/licenses/LICENSE-lz4-java-1.8.1.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-lz4-java-1.8.1.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-okhttp-3.12.12.txt b/install-dist/release-docs/licenses/LICENSE-okhttp-3.12.12.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-okhttp-3.12.12.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-okio-1.15.0.txt b/install-dist/release-docs/licenses/LICENSE-okio-1.15.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-okio-1.15.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-pinyin4j-2.5.0.txt b/install-dist/release-docs/licenses/LICENSE-pinyin4j-2.5.0.txt new file mode 100644 index 0000000000..633168288a --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-pinyin4j-2.5.0.txt @@ -0,0 +1 @@ +License: BSD diff --git a/install-dist/release-docs/licenses/LICENSE-rocksdbjni-8.10.2.txt b/install-dist/release-docs/licenses/LICENSE-rocksdbjni-8.10.2.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-rocksdbjni-8.10.2.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-shims-0.9.38.txt b/install-dist/release-docs/licenses/LICENSE-shims-0.9.38.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-shims-0.9.38.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-slf4j-api-1.7.31.txt b/install-dist/release-docs/licenses/LICENSE-slf4j-api-1.7.31.txt new file mode 100644 index 0000000000..fe2e64a989 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-slf4j-api-1.7.31.txt @@ -0,0 +1 @@ +https://opensource.org/license/mit diff --git a/install-dist/release-docs/licenses/LICENSE-spring-aop-5.3.27.txt b/install-dist/release-docs/licenses/LICENSE-spring-aop-5.3.27.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-aop-5.3.27.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-spring-beans-5.3.27.txt b/install-dist/release-docs/licenses/LICENSE-spring-beans-5.3.27.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-beans-5.3.27.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-spring-context-5.3.27.txt b/install-dist/release-docs/licenses/LICENSE-spring-context-5.3.27.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-context-5.3.27.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-spring-core-5.3.27.txt b/install-dist/release-docs/licenses/LICENSE-spring-core-5.3.27.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-core-5.3.27.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-spring-expression-5.3.27.txt b/install-dist/release-docs/licenses/LICENSE-spring-expression-5.3.27.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-expression-5.3.27.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-spring-jcl-5.3.27.txt b/install-dist/release-docs/licenses/LICENSE-spring-jcl-5.3.27.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-jcl-5.3.27.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-spring-security-core-5.8.3.txt b/install-dist/release-docs/licenses/LICENSE-spring-security-core-5.8.3.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-security-core-5.8.3.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-spring-security-crypto-5.8.3.txt b/install-dist/release-docs/licenses/LICENSE-spring-security-crypto-5.8.3.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-spring-security-crypto-5.8.3.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-swagger-annotations-jakarta-2.2.18.txt b/install-dist/release-docs/licenses/LICENSE-swagger-annotations-jakarta-2.2.18.txt deleted file mode 100644 index afdeac5bfa..0000000000 --- a/install-dist/release-docs/licenses/LICENSE-swagger-annotations-jakarta-2.2.18.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright (c) 2015. SmartBear Software Inc. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-swagger-core-jakarta-2.2.18.txt b/install-dist/release-docs/licenses/LICENSE-swagger-core-jakarta-2.2.18.txt deleted file mode 100644 index afdeac5bfa..0000000000 --- a/install-dist/release-docs/licenses/LICENSE-swagger-core-jakarta-2.2.18.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright (c) 2015. SmartBear Software Inc. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-swagger-models-jakarta-2.2.18.txt b/install-dist/release-docs/licenses/LICENSE-swagger-models-jakarta-2.2.18.txt deleted file mode 100644 index afdeac5bfa..0000000000 --- a/install-dist/release-docs/licenses/LICENSE-swagger-models-jakarta-2.2.18.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright (c) 2015. SmartBear Software Inc. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/install-dist/release-docs/licenses/LICENSE-zjsonpatch-0.3.0.txt b/install-dist/release-docs/licenses/LICENSE-zjsonpatch-0.3.0.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/install-dist/release-docs/licenses/LICENSE-zjsonpatch-0.3.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/install-dist/scripts/apache-release.sh b/install-dist/scripts/apache-release.sh index 168217c425..0eb721ae8b 100755 --- a/install-dist/scripts/apache-release.sh +++ b/install-dist/scripts/apache-release.sh @@ -41,13 +41,13 @@ rm -rf dist && mkdir -p dist/apache-${REPO} # step1: package the source code cd ../../ && echo "Package source in: $(pwd)" git archive --format=tar.gz \ - --output="install-dist/scripts/dist/apache-${REPO}/apache-${REPO}-incubating-${RELEASE_VERSION}-src.tar.gz" \ - --prefix=apache-${REPO}-incubating-"${RELEASE_VERSION}"-src/ "${GIT_BRANCH}" || exit + --output="install-dist/scripts/dist/apache-${REPO}/apache-${REPO}-${RELEASE_VERSION}-src.tar.gz" \ + --prefix=apache-${REPO}-"${RELEASE_VERSION}"-src/ "${GIT_BRANCH}" || exit cd - || exit # step2: copy the binary file (Optional) # Note: it's optional for project to generate binary package (skip this step if not need) -cp -v ../../target/apache-${REPO}-incubating-"${RELEASE_VERSION}".tar.gz dist/apache-${REPO} || exit +cp -v ../../target/apache-${REPO}-"${RELEASE_VERSION}".tar.gz dist/apache-${REPO} || exit # step3: sign + hash ##### 3.1 sign in source & binary package @@ -80,7 +80,7 @@ SVN_DIR="${GROUP}-svn-dev" cd ../ rm -rfv ${SVN_DIR} -svn co "https://dist.apache.org/repos/dist/dev/incubator/${GROUP}" ${SVN_DIR} +svn co "https://dist.apache.org/repos/dist/dev/${GROUP}" ${SVN_DIR} ##### 4.2 copy new release package to svn directory mkdir -p ${SVN_DIR}/"${RELEASE_VERSION}" diff --git a/install-dist/scripts/dependency/check_dependencies.sh b/install-dist/scripts/dependency/check_dependencies.sh old mode 100644 new mode 100755 diff --git a/install-dist/scripts/dependency/known-dependencies.txt b/install-dist/scripts/dependency/known-dependencies.txt index c6099c09a7..ec9a1de248 100644 --- a/install-dist/scripts/dependency/known-dependencies.txt +++ b/install-dist/scripts/dependency/known-dependencies.txt @@ -4,6 +4,7 @@ LatencyUtils-2.0.3.jar RoaringBitmap-0.9.38.jar ST4-4.0.8.jar accessors-smart-1.2.jar +agrona-1.20.0.jar airline-0.8.jar android-json-0.0.20131108.vaadin1.jar animal-sniffer-annotations-1.14.jar @@ -32,7 +33,7 @@ asm-tree-9.2.jar asm-util-5.0.3.jar assertj-core-3.19.0.jar ast-9.0-9.0.20190305.jar -audience-annotations-0.5.0.jar +audience-annotations-0.13.0.jar auto-service-annotations-1.0.jar automaton-1.11-8.jar bolt-1.6.2.jar @@ -59,6 +60,7 @@ chronicle-wire-2.20.117.jar classgraph-4.8.162.jar commons-beanutils-1.9.4.jar commons-cli-1.1.jar +commons-cli-1.5.0.jar commons-codec-1.11.jar commons-codec-1.13.jar commons-codec-1.15.jar @@ -68,6 +70,7 @@ commons-collections4-4.4.jar commons-compress-1.21.jar commons-configuration-1.10.jar commons-configuration2-2.8.0.jar +commons-crypto-1.1.0.jar commons-io-2.12.0.jar commons-io-2.7.jar commons-io-2.8.0.jar @@ -79,6 +82,7 @@ commons-lang3-3.18.0.jar commons-logging-1.1.1.jar commons-logging-1.2.jar commons-math3-3.2.jar +commons-math3-3.6.1.jar commons-pool2-2.0.jar commons-text-1.10.0.jar commons-text-1.9.jar @@ -92,9 +96,11 @@ eclipse-collections-api-10.4.0.jar eclipse-collections-api-11.1.0.jar error_prone_annotations-2.1.3.jar error_prone_annotations-2.10.0.jar +error_prone_annotations-2.1.3.jar error_prone_annotations-2.18.0.jar error_prone_annotations-2.3.4.jar error_prone_annotations-2.4.0.jar +error_prone_annotations-2.48.0.jar exp4j-0.4.8.jar expressions-9.0-9.0.20190305.jar failsafe-2.4.1.jar @@ -164,7 +170,26 @@ hamcrest-2.2.jar hamcrest-core-1.3.jar hanlp-portable-1.5.0.jar hanlp-portable-1.8.3.jar +hbase-client-2.6.5.jar +hbase-common-2.6.5.jar +hbase-endpoint-2.6.5.jar +hbase-hadoop-compat-2.6.5.jar +hbase-hadoop2-compat-2.6.5.jar +hbase-logging-2.6.5.jar +hbase-metrics-2.6.5.jar +hbase-metrics-api-2.6.5.jar +hbase-protocol-2.6.5.jar +hbase-protocol-shaded-2.6.5.jar +hbase-shaded-client-2.6.5.jar +hbase-shaded-gson-4.1.13.jar +hbase-shaded-miscellaneous-4.1.13.jar +hbase-shaded-netty-4.1.13.jar +hbase-shaded-protobuf-4.1.13.jar +hbase-unsafe-4.1.13.jar +hbase-zookeeper-2.6.5.jar hbase-shaded-endpoint-2.0.6.jar +HdrHistogram-2.1.12.jar +HdrHistogram-2.1.9.jar hessian-3.3.6.jar hessian-3.3.7.jar high-scale-lib-1.0.6.jar @@ -173,7 +198,7 @@ hk2-locator-3.0.1.jar hk2-utils-3.0.1.jar hppc-0.7.1.jar hppc-0.8.1.jar -htrace-core4-4.2.0-incubating.jar +htrace-core4-4.1.0-incubating.jar httpclient-4.5.13.jar httpcore-4.4.13.jar ikanalyzer-2012_u6.jar @@ -226,14 +251,15 @@ java-cup-runtime-11b-20160615.jar javapoet-1.8.0.jar javassist-3.21.0-GA.jar javassist-3.24.0-GA.jar +javassist-3.25.0-GA.jar javassist-3.28.0-GA.jar javatuples-1.2.jar -javax-websocket-client-impl-9.4.46.v20220331.jar -javax-websocket-server-impl-9.4.46.v20220331.jar javax.activation-api-1.2.0.jar javax.annotation-api-1.3.2.jar javax.inject-1.jar javax.json-1.0.jar +javax-websocket-client-impl-9.4.46.v20220331.jar +javax-websocket-server-impl-9.4.46.v20220331.jar jaxb-api-2.3.1.jar jaxb-core-3.0.2.jar jaxb-impl-3.0.2.jar @@ -242,6 +268,7 @@ jcabi-log-0.14.jar jcabi-manifests-1.1.jar jcip-annotations-1.0-1.jar jcl-over-slf4j-1.7.25.jar +jcodings-1.0.58.jar jcommander-1.30.jar jcseg-core-2.2.0.jar jcseg-core-2.6.2.jar @@ -278,8 +305,8 @@ jetty-util-9.4.46.v20220331.jar jetty-util-ajax-9.4.46.v20220331.jar jetty-webapp-9.4.46.v20220331.jar jetty-xml-9.4.46.v20220331.jar -jffi-1.2.16-native.jar jffi-1.2.16.jar +jffi-1.2.16-native.jar jflex-1.8.2.jar jieba-analysis-1.0.2.jar jjwt-api-0.11.2.jar @@ -295,13 +322,14 @@ jna-5.7.0.jar jnr-ffi-2.1.7.jar jnr-x86asm-1.0.2.jar joda-time-2.10.8.jar +joni-2.2.1.jar jraft-core-1.3.11.jar jraft-core-1.3.13.jar jraft-core-1.3.9.jar +jsonassert-1.5.0.jar json-path-2.5.0.jar json-simple-1.1.jar json-smart-2.3.jar -jsonassert-1.5.0.jar jsr305-3.0.1.jar jsr305-3.0.2.jar jul-to-slf4j-1.7.36.jar @@ -313,6 +341,7 @@ junit-jupiter-engine-5.7.2.jar junit-jupiter-params-5.7.2.jar junit-platform-commons-1.7.2.jar junit-platform-engine-1.7.2.jar +jvector-3.0.6.jar jvm-attach-api-1.5.jar kerb-admin-2.0.0.jar kerb-client-2.0.0.jar @@ -353,6 +382,7 @@ kubernetes-model-policy-5.6.0.jar kubernetes-model-rbac-5.6.0.jar kubernetes-model-scheduling-5.6.0.jar kubernetes-model-storageclass-5.6.0.jar +LatencyUtils-2.0.3.jar listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar log4j-api-2.15.0.jar log4j-api-2.17.0.jar @@ -389,8 +419,7 @@ lucene-sandbox-4.7.2.jar lucene-sandbox-5.2.1.jar lucene-suggest-5.2.1.jar lz4-java-1.4.0.jar -lz4-java-1.7.1.jar -lz4-java-1.8.0.jar +lz4-java-1.8.1.jar metrics-annotation-4.2.4.jar metrics-core-3.0.2.jar metrics-core-3.1.5.jar @@ -413,18 +442,20 @@ netty-buffer-4.1.52.Final.jar netty-buffer-4.1.72.Final.jar netty-codec-4.1.52.Final.jar netty-codec-4.1.72.Final.jar -netty-codec-http-4.1.52.Final.jar -netty-codec-http-4.1.72.Final.jar netty-codec-http2-4.1.52.Final.jar netty-codec-http2-4.1.72.Final.jar +netty-codec-http-4.1.52.Final.jar +netty-codec-http-4.1.72.Final.jar netty-codec-socks-4.1.52.Final.jar netty-codec-socks-4.1.72.Final.jar netty-common-4.1.52.Final.jar netty-common-4.1.72.Final.jar +netty-handler-4.1.130.Final.jar netty-handler-4.1.52.Final.jar netty-handler-4.1.72.Final.jar netty-handler-proxy-4.1.52.Final.jar netty-handler-proxy-4.1.72.Final.jar +netty-resolver-4.1.130.Final.jar netty-resolver-4.1.52.Final.jar netty-resolver-4.1.72.Final.jar netty-tcnative-boringssl-static-2.0.25.Final.jar @@ -432,6 +463,8 @@ netty-tcnative-boringssl-static-2.0.36.Final.jar netty-tcnative-classes-2.0.46.Final.jar netty-transport-4.1.52.Final.jar netty-transport-4.1.72.Final.jar +netty-transport-classes-epoll-4.1.130.Final.jar +netty-transport-native-epoll-4.1.130.Final.jar netty-transport-native-unix-common-4.1.72.Final.jar nimbus-jose-jwt-4.41.2.jar nlp-lang-1.7.7.jar @@ -443,6 +476,9 @@ okhttp-3.12.12.jar okhttp-4.10.0.jar okio-1.15.0.jar okio-jvm-3.0.0.jar +opentelemetry-api-1.49.0.jar +opentelemetry-context-1.49.0.jar +opentelemetry-semconv-1.29.0-alpha.jar opentest4j-1.2.0.jar opentracing-api-0.22.0.jar opentracing-mock-0.22.0.jar @@ -482,9 +518,10 @@ psjava-0.1.19.jar reporter-config-base-3.0.3.jar reporter-config3-3.0.3.jar rewriting-9.0-9.0.20190305.jar +RoaringBitmap-0.9.38.jar rocksdbjni-6.29.5.jar -rocksdbjni-7.2.2.jar rocksdbjni-7.7.3.jar +rocksdbjni-8.10.2.jar scala-java8-compat_2.12-0.8.0.jar scala-library-2.12.7.jar scala-reflect-2.12.7.jar @@ -553,6 +590,7 @@ spring-security-core-5.8.3.jar spring-security-crypto-5.8.3.jar spring-web-5.3.20.jar spring-webmvc-5.3.20.jar +ST4-4.0.8.jar stream-2.5.2.jar swagger-annotations-1.5.18.jar swagger-annotations-jakarta-2.2.18.jar @@ -580,5 +618,7 @@ xmlunit-core-2.8.4.jar xpp3_min-1.1.4c.jar xstream-1.4.10.jar zjsonpatch-0.3.0.jar +zookeeper-3.8.6.jar +zookeeper-jute-3.8.6.jar zstd-jni-1.5.5-1.jar zt-zip-1.14.jar diff --git a/install-dist/scripts/dependency/regenerate_known_dependencies.sh b/install-dist/scripts/dependency/regenerate_known_dependencies.sh old mode 100644 new mode 100755 diff --git a/install-dist/scripts/dependency/result.txt b/install-dist/scripts/dependency/result.txt new file mode 100644 index 0000000000..9793f74619 --- /dev/null +++ b/install-dist/scripts/dependency/result.txt @@ -0,0 +1,587 @@ +--- /dev/fd/63 2025-12-15 14:31:28.575578994 +0800 ++++ /dev/fd/62 2025-12-15 14:31:28.576578985 +0800 +@@ -1,584 +0,0 @@ +-accessors-smart-1.2.jar +-airline-0.8.jar +-android-json-0.0.20131108.vaadin1.jar +-animal-sniffer-annotations-1.14.jar +-animal-sniffer-annotations-1.18.jar +-animal-sniffer-annotations-1.19.jar +-annotations-13.0.jar +-annotations-24.0.1.jar +-annotations-4.1.1.4.jar +-ansj_seg-5.1.6.jar +-antlr-runtime-3.5.2.jar +-aopalliance-repackaged-3.0.1.jar +-apiguardian-api-1.1.0.jar +-arthas-agent-attach-3.6.4.jar +-arthas-agent-attach-3.7.1.jar +-arthas-packaging-3.6.4.jar +-arthas-packaging-3.7.1.jar +-asm-5.0.4.jar +-asm-6.0.jar +-asm-7.1.jar +-asm-analysis-5.0.3.jar +-asm-analysis-9.2.jar +-asm-commons-5.0.3.jar +-asm-commons-9.2.jar +-asm-tree-5.0.3.jar +-asm-tree-9.2.jar +-asm-util-5.0.3.jar +-assertj-core-3.19.0.jar +-ast-9.0-9.0.20190305.jar +-audience-annotations-0.5.0.jar +-automaton-1.11-8.jar +-auto-service-annotations-1.0.jar +-bolt-1.6.2.jar +-bolt-1.6.4.jar +-byte-buddy-1.10.20.jar +-byte-buddy-1.10.5.jar +-byte-buddy-agent-1.10.20.jar +-byte-buddy-agent-1.10.5.jar +-byte-buddy-agent-1.11.6.jar +-caffeine-2.3.1.jar +-caffeine-2.5.6.jar +-cassandra-all-4.0.10.jar +-cassandra-driver-core-3.6.0.jar +-checker-compat-qual-2.5.5.jar +-checker-qual-2.0.0.jar +-checker-qual-3.12.0.jar +-checker-qual-3.33.0.jar +-checker-qual-3.5.0.jar +-chronicle-bytes-2.20.111.jar +-chronicle-core-2.20.126.jar +-chronicle-queue-5.20.123.jar +-chronicle-threads-2.20.111.jar +-chronicle-wire-2.20.117.jar +-classgraph-4.8.162.jar +-commons-beanutils-1.9.4.jar +-commons-cli-1.1.jar +-commons-codec-1.11.jar +-commons-codec-1.13.jar +-commons-codec-1.15.jar +-commons-codec-1.9.jar +-commons-collections-3.2.2.jar +-commons-collections4-4.4.jar +-commons-compress-1.21.jar +-commons-configuration-1.10.jar +-commons-configuration2-2.8.0.jar +-commons-io-2.12.0.jar +-commons-io-2.7.jar +-commons-io-2.8.0.jar +-commons-lang-2.6.jar +-commons-lang3-3.11.jar +-commons-lang3-3.12.0.jar +-commons-lang3-3.13.0.jar +-commons-lang3-3.18.0.jar +-commons-logging-1.1.1.jar +-commons-logging-1.2.jar +-commons-math3-3.2.jar +-commons-pool2-2.0.jar +-commons-text-1.10.0.jar +-commons-text-1.9.jar +-concurrent-trees-2.4.0.jar +-cypher-gremlin-extensions-1.0.4.jar +-disruptor-3.3.7.jar +-disruptor-3.4.1.jar +-eclipse-collections-10.4.0.jar +-eclipse-collections-11.1.0.jar +-eclipse-collections-api-10.4.0.jar +-eclipse-collections-api-11.1.0.jar +-error_prone_annotations-2.10.0.jar +-error_prone_annotations-2.1.3.jar +-error_prone_annotations-2.18.0.jar +-error_prone_annotations-2.3.4.jar +-error_prone_annotations-2.4.0.jar +-exp4j-0.4.8.jar +-expressions-9.0-9.0.20190305.jar +-failsafe-2.4.1.jar +-failureaccess-1.0.1.jar +-fastjson-1.2.83.jar +-fastparse_2.12-2.0.4.jar +-fastutil-8.1.0.jar +-fastutil-8.5.9.jar +-findbugs-annotations-1.3.9-1.jar +-front-end-9.0-9.0.20190305.jar +-fury-core-0.9.0.jar +-generex-1.0.2.jar +-gremlin-console-3.5.1.jar +-gremlin-core-3.5.1.jar +-gremlin-driver-3.5.1.jar +-gremlin-groovy-3.5.1.jar +-gremlin-groovy-test-3.2.11.jar +-gremlin-server-3.5.1.jar +-gremlin-shaded-3.5.1.jar +-gremlin-test-3.5.1.jar +-grizzly-framework-3.0.1.jar +-grizzly-http-3.0.1.jar +-grizzly-http-server-3.0.1.jar +-grizzly-http-servlet-3.0.1.jar +-groovy-2.5.14-indy.jar +-groovy-cli-picocli-2.5.14.jar +-groovy-console-2.5.14.jar +-groovy-groovysh-2.5.14-indy.jar +-groovy-json-2.5.14-indy.jar +-groovy-jsr223-2.5.14-indy.jar +-groovy-swing-2.5.14.jar +-groovy-templates-2.5.14.jar +-groovy-xml-2.5.14.jar +-grpc-api-1.28.1.jar +-grpc-api-1.39.0.jar +-grpc-api-1.47.0.jar +-grpc-context-1.28.1.jar +-grpc-context-1.39.0.jar +-grpc-context-1.47.0.jar +-grpc-core-1.28.1.jar +-grpc-core-1.39.0.jar +-grpc-core-1.47.0.jar +-grpc-grpclb-1.39.0.jar +-grpc-netty-1.39.0.jar +-grpc-netty-1.47.0.jar +-grpc-netty-shaded-1.28.0.jar +-grpc-netty-shaded-1.39.0.jar +-grpc-netty-shaded-1.47.0.jar +-grpc-protobuf-1.28.0.jar +-grpc-protobuf-1.39.0.jar +-grpc-protobuf-lite-1.28.0.jar +-grpc-protobuf-lite-1.39.0.jar +-grpc-services-1.39.0.jar +-grpc-spring-boot-starter-4.5.5.jar +-grpc-stub-1.28.0.jar +-grpc-stub-1.39.0.jar +-grpc-stub-1.47.0.jar +-gson-2.8.6.jar +-gson-2.8.9.jar +-guava-25.1-jre.jar +-guava-27.0-jre.jar +-guava-30.0-jre.jar +-guava-30.1-android.jar +-guava-31.0.1-android.jar +-guava-32.0.1-android.jar +-hamcrest-2.2.jar +-hamcrest-core-1.3.jar +-hanlp-portable-1.5.0.jar +-hanlp-portable-1.8.3.jar +-hbase-shaded-endpoint-2.0.6.jar +-HdrHistogram-2.1.12.jar +-HdrHistogram-2.1.9.jar +-hessian-3.3.6.jar +-hessian-3.3.7.jar +-high-scale-lib-1.0.6.jar +-hk2-api-3.0.1.jar +-hk2-locator-3.0.1.jar +-hk2-utils-3.0.1.jar +-hppc-0.7.1.jar +-hppc-0.8.1.jar +-htrace-core4-4.2.0-incubating.jar +-httpclient-4.5.13.jar +-httpcore-4.4.13.jar +-ikanalyzer-2012_u6.jar +-ivy-2.4.0.jar +-j2objc-annotations-1.1.jar +-j2objc-annotations-1.3.jar +-j2objc-annotations-2.8.jar +-jackson-annotations-2.13.0.jar +-jackson-annotations-2.14.0-rc1.jar +-jackson-annotations-2.15.2.jar +-jackson-core-2.13.0.jar +-jackson-core-2.13.2.jar +-jackson-core-2.14.0-rc1.jar +-jackson-core-2.15.2.jar +-jackson-databind-2.12.6.1.jar +-jackson-databind-2.13.0.jar +-jackson-databind-2.13.2.jar +-jackson-databind-2.14.0-rc1.jar +-jackson-databind-2.15.2.jar +-jackson-dataformat-yaml-2.11.2.jar +-jackson-dataformat-yaml-2.9.3.jar +-jackson-datatype-jdk8-2.12.6.jar +-jackson-datatype-jsr310-2.11.2.jar +-jackson-datatype-jsr310-2.12.6.jar +-jackson-jakarta-rs-base-2.15.2.jar +-jackson-jakarta-rs-json-provider-2.15.2.jar +-jackson-jaxrs-base-2.14.0-rc1.jar +-jackson-jaxrs-base-2.15.2.jar +-jackson-jaxrs-json-provider-2.14.0-rc1.jar +-jackson-jaxrs-json-provider-2.15.2.jar +-jackson-module-jakarta-xmlbind-annotations-2.15.2.jar +-jackson-module-jaxb-annotations-2.14.0-rc1.jar +-jackson-module-jaxb-annotations-2.15.2.jar +-jackson-module-parameter-names-2.12.6.jar +-jakarta.activation-2.0.0.jar +-jakarta.activation-2.0.1.jar +-jakarta.activation-api-1.2.2.jar +-jakarta.annotation-api-1.3.5.jar +-jakarta.annotation-api-2.0.0.jar +-jakarta.inject-api-2.0.0.jar +-jakarta.servlet-api-4.0.4.jar +-jakarta.servlet-api-5.0.0.jar +-jakarta.validation-api-3.0.0.jar +-jakarta.websocket-api-1.1.2.jar +-jakarta.ws.rs-api-3.0.0.jar +-jakarta.xml.bind-api-2.3.3.jar +-jakarta.xml.bind-api-3.0.0.jar +-jamm-0.3.2.jar +-java-cup-runtime-11b-20160615.jar +-javapoet-1.8.0.jar +-javassist-3.21.0-GA.jar +-javassist-3.24.0-GA.jar +-javassist-3.28.0-GA.jar +-javatuples-1.2.jar +-javax.activation-api-1.2.0.jar +-javax.annotation-api-1.3.2.jar +-javax.inject-1.jar +-javax.json-1.0.jar +-javax-websocket-client-impl-9.4.46.v20220331.jar +-javax-websocket-server-impl-9.4.46.v20220331.jar +-jaxb-api-2.3.1.jar +-jaxb-core-3.0.2.jar +-jaxb-impl-3.0.2.jar +-jbcrypt-0.4.jar +-jcabi-log-0.14.jar +-jcabi-manifests-1.1.jar +-jcip-annotations-1.0-1.jar +-jcl-over-slf4j-1.7.25.jar +-jcommander-1.30.jar +-jcseg-core-2.2.0.jar +-jcseg-core-2.6.2.jar +-jctools-core-2.1.1.jar +-jctools-core-3.1.0.jar +-jedis-2.5.1.jar +-jersey-apache-connector-3.0.3.jar +-jersey-client-3.0.3.jar +-jersey-common-3.0.3.jar +-jersey-container-grizzly2-http-3.0.3.jar +-jersey-container-grizzly2-servlet-3.0.3.jar +-jersey-container-servlet-3.0.3.jar +-jersey-container-servlet-core-3.0.3.jar +-jersey-entity-filtering-3.0.3.jar +-jersey-hk2-3.0.3.jar +-jersey-media-jaxb-3.0.3.jar +-jersey-media-json-jackson-3.0.3.jar +-jersey-server-3.0.3.jar +-jersey-test-framework-core-3.0.3.jar +-jersey-test-framework-provider-grizzly2-3.0.3.jar +-jetcd-common-0.5.9.jar +-jetcd-core-0.5.9.jar +-jetty-annotations-9.4.46.v20220331.jar +-jetty-client-9.4.46.v20220331.jar +-jetty-continuation-9.4.46.v20220331.jar +-jetty-http-9.4.46.v20220331.jar +-jetty-io-9.4.46.v20220331.jar +-jetty-plus-9.4.46.v20220331.jar +-jetty-security-9.4.46.v20220331.jar +-jetty-server-9.4.46.v20220331.jar +-jetty-servlet-9.4.46.v20220331.jar +-jetty-servlets-9.4.46.v20220331.jar +-jetty-util-9.4.46.v20220331.jar +-jetty-util-ajax-9.4.46.v20220331.jar +-jetty-webapp-9.4.46.v20220331.jar +-jetty-xml-9.4.46.v20220331.jar +-jffi-1.2.16.jar +-jffi-1.2.16-native.jar +-jflex-1.8.2.jar +-jieba-analysis-1.0.2.jar +-jjwt-api-0.11.2.jar +-jjwt-api-0.11.5.jar +-jjwt-impl-0.11.2.jar +-jjwt-impl-0.11.5.jar +-jjwt-jackson-0.11.2.jar +-jjwt-jackson-0.11.5.jar +-jline-2.14.6.jar +-jna-5.12.1.jar +-jna-5.5.0.jar +-jna-5.7.0.jar +-jnr-ffi-2.1.7.jar +-jnr-x86asm-1.0.2.jar +-joda-time-2.10.8.jar +-jraft-core-1.3.11.jar +-jraft-core-1.3.13.jar +-jraft-core-1.3.9.jar +-jsonassert-1.5.0.jar +-json-path-2.5.0.jar +-json-simple-1.1.jar +-json-smart-2.3.jar +-jsr305-3.0.1.jar +-jsr305-3.0.2.jar +-jul-to-slf4j-1.7.36.jar +-junit-4.13.1.jar +-junit-4.13.2.jar +-junit-jupiter-5.7.2.jar +-junit-jupiter-api-5.7.2.jar +-junit-jupiter-engine-5.7.2.jar +-junit-jupiter-params-5.7.2.jar +-junit-platform-commons-1.7.2.jar +-junit-platform-engine-1.7.2.jar +-jvm-attach-api-1.5.jar +-kerb-admin-2.0.0.jar +-kerb-client-2.0.0.jar +-kerb-common-2.0.0.jar +-kerb-core-2.0.0.jar +-kerb-crypto-2.0.0.jar +-kerb-identity-2.0.0.jar +-kerb-server-2.0.0.jar +-kerb-simplekdc-2.0.0.jar +-kerb-util-2.0.0.jar +-kerby-asn1-2.0.0.jar +-kerby-config-2.0.0.jar +-kerby-pkix-2.0.0.jar +-kerby-util-2.0.0.jar +-kerby-xdr-2.0.0.jar +-kotlin-stdlib-1.6.20.jar +-kotlin-stdlib-common-1.5.31.jar +-kotlin-stdlib-jdk7-1.6.10.jar +-kotlin-stdlib-jdk8-1.6.10.jar +-kubernetes-client-5.6.0.jar +-kubernetes-model-admissionregistration-5.6.0.jar +-kubernetes-model-apiextensions-5.6.0.jar +-kubernetes-model-apps-5.6.0.jar +-kubernetes-model-autoscaling-5.6.0.jar +-kubernetes-model-batch-5.6.0.jar +-kubernetes-model-certificates-5.6.0.jar +-kubernetes-model-common-5.6.0.jar +-kubernetes-model-coordination-5.6.0.jar +-kubernetes-model-core-5.6.0.jar +-kubernetes-model-discovery-5.6.0.jar +-kubernetes-model-events-5.6.0.jar +-kubernetes-model-extensions-5.6.0.jar +-kubernetes-model-flowcontrol-5.6.0.jar +-kubernetes-model-metrics-5.6.0.jar +-kubernetes-model-networking-5.6.0.jar +-kubernetes-model-node-5.6.0.jar +-kubernetes-model-policy-5.6.0.jar +-kubernetes-model-rbac-5.6.0.jar +-kubernetes-model-scheduling-5.6.0.jar +-kubernetes-model-storageclass-5.6.0.jar +-LatencyUtils-2.0.3.jar +-listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar +-log4j-api-2.15.0.jar +-log4j-api-2.17.0.jar +-log4j-api-2.17.1.jar +-log4j-api-2.17.2.jar +-log4j-api-2.18.0.jar +-log4j-core-2.15.0.jar +-log4j-core-2.17.0.jar +-log4j-core-2.17.1.jar +-log4j-core-2.17.2.jar +-log4j-core-2.18.0.jar +-log4j-jul-2.17.2.jar +-log4j-slf4j-impl-2.15.0.jar +-log4j-slf4j-impl-2.17.0.jar +-log4j-slf4j-impl-2.17.1.jar +-log4j-slf4j-impl-2.18.0.jar +-logging-interceptor-3.12.12.jar +-logging-interceptor-4.10.0.jar +-lombok-1.18.24.jar +-lookout-api-1.4.1.jar +-lucene-analyzers-common-5.2.1.jar +-lucene-analyzers-common-8.11.2.jar +-lucene-analyzers-smartcn-7.4.0.jar +-lucene-analyzers-smartcn-8.11.2.jar +-lucene-backward-codecs-5.2.1.jar +-lucene-core-7.4.0.jar +-lucene-core-8.11.2.jar +-lucene-misc-5.2.1.jar +-lucene-queries-4.7.2.jar +-lucene-queries-5.2.1.jar +-lucene-queryparser-4.7.2.jar +-lucene-queryparser-5.2.1.jar +-lucene-sandbox-4.7.2.jar +-lucene-sandbox-5.2.1.jar +-lucene-suggest-5.2.1.jar +-lz4-java-1.4.0.jar +-lz4-java-1.7.1.jar +-lz4-java-1.8.0.jar +-metrics-annotation-4.2.4.jar +-metrics-core-3.0.2.jar +-metrics-core-3.1.5.jar +-metrics-core-4.0.2.jar +-metrics-core-4.2.4.jar +-metrics-jersey3-4.2.4.jar +-metrics-jvm-3.1.5.jar +-metrics-logback-3.1.5.jar +-micrometer-core-1.7.12.jar +-micrometer-registry-prometheus-1.7.12.jar +-mmseg4j-core-1.10.0.jar +-mockito-core-3.3.3.jar +-mockito-core-3.9.0.jar +-mockito-junit-jupiter-3.9.0.jar +-mxdump-0.14.jar +-netty-all-4.1.42.Final.jar +-netty-all-4.1.44.Final.jar +-netty-all-4.1.61.Final.jar +-netty-buffer-4.1.52.Final.jar +-netty-buffer-4.1.72.Final.jar +-netty-codec-4.1.52.Final.jar +-netty-codec-4.1.72.Final.jar +-netty-codec-http2-4.1.52.Final.jar +-netty-codec-http2-4.1.72.Final.jar +-netty-codec-http-4.1.52.Final.jar +-netty-codec-http-4.1.72.Final.jar +-netty-codec-socks-4.1.52.Final.jar +-netty-codec-socks-4.1.72.Final.jar +-netty-common-4.1.52.Final.jar +-netty-common-4.1.72.Final.jar +-netty-handler-4.1.52.Final.jar +-netty-handler-4.1.72.Final.jar +-netty-handler-proxy-4.1.52.Final.jar +-netty-handler-proxy-4.1.72.Final.jar +-netty-resolver-4.1.52.Final.jar +-netty-resolver-4.1.72.Final.jar +-netty-tcnative-boringssl-static-2.0.25.Final.jar +-netty-tcnative-boringssl-static-2.0.36.Final.jar +-netty-tcnative-classes-2.0.46.Final.jar +-netty-transport-4.1.52.Final.jar +-netty-transport-4.1.72.Final.jar +-netty-transport-native-unix-common-4.1.72.Final.jar +-nimbus-jose-jwt-4.41.2.jar +-nlp-lang-1.7.7.jar +-objenesis-2.6.jar +-objenesis-3.2.jar +-ohc-core-0.7.4.jar +-ohc-core-j8-0.5.1.jar +-okhttp-3.12.12.jar +-okhttp-4.10.0.jar +-okio-1.15.0.jar +-okio-jvm-3.0.0.jar +-opentest4j-1.2.0.jar +-opentracing-api-0.22.0.jar +-opentracing-mock-0.22.0.jar +-opentracing-noop-0.22.0.jar +-opentracing-util-0.22.0.jar +-osgi-resource-locator-1.0.3.jar +-parboiled-core-1.2.0.jar +-parboiled-scala_2.12-1.2.0.jar +-parser-9.0-9.0.20190305.jar +-perfmark-api-0.19.0.jar +-perfmark-api-0.23.0.jar +-perfmark-api-0.25.0.jar +-picocli-4.3.2.jar +-pinyin4j-2.5.0.jar +-postgresql-42.4.3.jar +-powermock-api-mockito2-2.0.0-RC.3.jar +-powermock-api-support-2.0.0-RC.3.jar +-powermock-classloading-base-2.0.0-RC.3.jar +-powermock-classloading-xstream-2.0.0-RC.3.jar +-powermock-core-2.0.0-RC.3.jar +-powermock-module-junit4-2.0.0-RC.3.jar +-powermock-module-junit4-common-2.0.0-RC.3.jar +-powermock-module-junit4-rule-2.0.0-RC.3.jar +-powermock-reflect-2.0.0-RC.3.jar +-protobuf-java-3.11.0.jar +-protobuf-java-3.17.2.jar +-protobuf-java-3.21.7.jar +-protobuf-java-3.5.1.jar +-protobuf-java-util-3.17.2.jar +-proto-google-common-protos-1.17.0.jar +-proto-google-common-protos-2.0.1.jar +-protostuff-api-1.6.0.jar +-protostuff-collectionschema-1.6.0.jar +-protostuff-core-1.6.0.jar +-protostuff-runtime-1.6.0.jar +-psjava-0.1.19.jar +-reporter-config3-3.0.3.jar +-reporter-config-base-3.0.3.jar +-rewriting-9.0-9.0.20190305.jar +-RoaringBitmap-0.9.38.jar +-rocksdbjni-6.29.5.jar +-rocksdbjni-7.7.3.jar +-rocksdbjni-8.10.2.jar +-scala-java8-compat_2.12-0.8.0.jar +-scala-library-2.12.7.jar +-scala-reflect-2.12.7.jar +-shims-0.9.38.jar +-sigar-1.6.4.jar +-simpleclient-0.10.0.jar +-simpleclient_common-0.10.0.jar +-sjk-agent-0.22.jar +-sjk-cli-0.14.jar +-sjk-cli-0.22.jar +-sjk-core-0.14.jar +-sjk-core-0.22.jar +-sjk-hflame-0.22.jar +-sjk-jfr5-0.5.jar +-sjk-jfr6-0.7.jar +-sjk-jfr-standalone-0.7.jar +-sjk-json-0.14.jar +-sjk-json-0.22.jar +-sjk-nps-0.9.jar +-sjk-stacktrace-0.14.jar +-sjk-stacktrace-0.22.jar +-slf4j-api-1.7.21.jar +-slf4j-api-1.7.25.jar +-slf4j-api-1.7.31.jar +-slf4j-api-1.7.32.jar +-slf4j-api-2.0.9.jar +-snakeyaml-1.18.jar +-snakeyaml-1.26.jar +-snakeyaml-1.27.jar +-snakeyaml-1.28.jar +-snakeyaml-2.2.jar +-snappy-java-1.1.2.6.jar +-snowball-stemmer-1.3.0.581.1.jar +-sofa-common-tools-1.0.12.jar +-sofa-rpc-all-5.7.6.jar +-sourcecode_2.12-0.1.4.jar +-spring-aop-5.3.20.jar +-spring-aop-5.3.27.jar +-spring-beans-5.3.20.jar +-spring-beans-5.3.27.jar +-spring-boot-2.5.14.jar +-spring-boot-actuator-2.5.14.jar +-spring-boot-actuator-autoconfigure-2.5.14.jar +-spring-boot-autoconfigure-2.5.0.jar +-spring-boot-autoconfigure-2.5.14.jar +-spring-boot-starter-2.5.0.jar +-spring-boot-starter-2.5.14.jar +-spring-boot-starter-actuator-2.5.14.jar +-spring-boot-starter-jetty-2.5.14.jar +-spring-boot-starter-json-2.5.14.jar +-spring-boot-starter-log4j2-2.5.14.jar +-spring-boot-starter-test-2.5.14.jar +-spring-boot-starter-web-2.5.14.jar +-spring-boot-test-2.5.14.jar +-spring-boot-test-autoconfigure-2.5.14.jar +-spring-context-5.3.20.jar +-spring-context-5.3.27.jar +-spring-context-support-5.3.20.jar +-spring-core-5.3.20.jar +-spring-core-5.3.27.jar +-spring-expression-5.3.20.jar +-spring-expression-5.3.27.jar +-spring-jcl-5.3.20.jar +-spring-jcl-5.3.27.jar +-spring-security-core-5.8.3.jar +-spring-security-crypto-5.8.3.jar +-spring-web-5.3.20.jar +-spring-webmvc-5.3.20.jar +-ST4-4.0.8.jar +-stream-2.5.2.jar +-swagger-annotations-1.5.18.jar +-swagger-annotations-jakarta-2.2.18.jar +-swagger-core-1.5.18.jar +-swagger-core-jakarta-2.2.18.jar +-swagger-integration-jakarta-2.2.18.jar +-swagger-jaxrs2-jakarta-2.2.18.jar +-swagger-models-1.5.18.jar +-swagger-models-jakarta-2.2.18.jar +-tinkergraph-gremlin-3.5.1.jar +-token-provider-2.0.0.jar +-tomcat-embed-el-9.0.63.jar +-tracer-core-3.0.8.jar +-translation-1.0.4.jar +-util-9.0-9.0.20190305.jar +-validation-api-1.1.0.Final.jar +-websocket-api-9.4.46.v20220331.jar +-websocket-client-9.4.46.v20220331.jar +-websocket-common-9.4.46.v20220331.jar +-websocket-server-9.4.46.v20220331.jar +-websocket-servlet-9.4.46.v20220331.jar +-word-1.3.jar +-xmlpull-1.1.3.1.jar +-xmlunit-core-2.8.4.jar +-xpp3_min-1.1.4c.jar +-xstream-1.4.10.jar +-zjsonpatch-0.3.0.jar +-zstd-jni-1.5.5-1.jar +-zt-zip-1.14.jar diff --git a/pom.xml b/pom.xml index 60edfe4310..850ac99fa8 100644 --- a/pom.xml +++ b/pom.xml @@ -47,7 +47,7 @@ - Apache Hugegraph(incubating) + Apache HugeGraph dev-subscribe@hugegraph.apache.org https://hugegraph.apache.org/ @@ -58,7 +58,7 @@ Development Mailing List dev-subscribe@hugegraph.apache.org dev-unsubscribe@hugegraph.apache.org - dev@hugegraph.incubator.apache.org + dev@hugegraph.apache.org Commits List @@ -199,6 +199,8 @@ .github/**/* .gitignore .gitattributes + + .serena/** **/*.iml **/*.iws