---

The **[KIE Community](http://kie.org)** is a home for leading Open Source projects that play a role in delivering solutions around Business Automation and Artificial Intelligence in the Cloud.

[![GitHub Stars](https://img.shields.io/github/stars/apache/incubator-kie-tools.svg)](https://github.com/apache/incubator-kie-tools/stargazers)
[![GitHub Forks](https://img.shields.io/github/forks/apache/incubator-kie-tools.svg)](https://github.com/apache/incubator-kie-tools/network/members)
[![GitHub Issues](https://img.shields.io/github/issues/apache/incubator-kie-tools.svg)]()
[![Pull Requests](https://img.shields.io/github/issues-pr/apache/incubator-kie-tools.svg?style=flat-square)](https://github.com/apache/incubator-kie-tools/pulls)
[![Contributors](https://img.shields.io/github/contributors/apache/incubator-kie-tools.svg?style=flat-square)](https://github.com/apache/incubator-kie-tools/graphs/contributors)
[![License](https://img.shields.io/github/license/apache/incubator-kie-tools.svg)](https://github.com/apache/incubator-kie-tools/blob/main/LICENSE)
[![Twitter Follow](https://img.shields.io/twitter/follow/KieCommunity.svg?label=Follow&style=social)](https://twitter.com/KieCommunity?lang=en)

This repository contains tooling applications and libraries for KIE projects.

## Contribute

- _Work in progress 🔨_

## Build from source

#### Step 0: Install the necessary tools

> **💡 RECOMMENDED**
>
> **Nix development environment**: A _devbox_ configuration is provided to automatically setup all the tools below. Read more in [here](./NIX_DEV_ENV.md).

To build and test all packages of the Apache KIE Tools project, you're going to need:

- Node `20` _(To install, follow these instructions: https://nodejs.org/en/download/package-manager/)_
- pnpm `9.3.0` _(To install, follow these instructions: https://pnpm.io/installation#using-npm)_
- Maven `3.9.6`
- Java `17`
- Go `1.21.9` _(To install, follow these instructions: https://go.dev/doc/install)_
- Python `3.12` _(To install, follow these instructions: https://www.python.org/downloads/)_
- Helm `3.13.3` _(To install, follow these instructions: https://helm.sh/docs/intro/install/)_
- Make

> **ℹ NOTE**
>
> If you plan on building container images, make sure you have a working Docker setup. Setting `KIE_TOOLS_BUILD__buildContainerImages=true` will also be necessary.

#### Step 1: Bootstrap

Bootstrapping installs the necessary dependencies for each package.

- `pnpm bootstrap` --> Will bootstrap all packages
- `pnpm bootstrap [pnpm-filter]` --> Will bootstrap packages filtered by [`pnpm` filter](https://pnpm.io/filtering)
- > E.g.,
  >
  > `pnpm bootstrap -F dmn-editor...` bootstraps the `dmn-editor` package and its dependencies.

> **ℹ NOTE**
>
> If you plan on running Playwright tests, set the `PLAYWRIGHT_BASE__installDeps` environment variable to `true` before running the command above.
>
> `PLAYWRIGHT_BASE__installDeps=true pnpm bootstrap`.
>
> This will install all Playwright dependencies (such as browsers engines and OS-specific libraries).

#### Step 2: Build

- Dev

  - `pnpm -r build:dev`
    - Will build all packages for development. Skipping linters, tests, minifiers etc.
  - `pnpm [pnpm-filter] build:dev`
    - Will build packages filtered by [`pnpm` filter](https://pnpm.io/filtering)
  - > E.g.,
    >
    > `pnpm -F dmn-editor... build:dev` builds the `dmn-editor` package and its dependencies.

- Prod

  - `pnpm -r build:prod`
    - Will build all packages for production. Optimizers will run, binaries will be produced for multiple architectures etc.
  - `pnpm [pnpm-filter] build:prod`
    - Will build packages filtered by [`pnpm` filter](https://pnpm.io/filtering)
  - > E.g.,
    >
    > `pnpm -F dmn-editor... build:prod` builds the `dmn-editor` package and its dependencies.

- Changed
  - `pnpm -F '...[HEAD]' build:dev`; or
  - `pnpm -F '...[HEAD]' build:prod`
    - Will build changed and affected packages based on your local changes. Useful for verifying that you didn't break anything.

> **ℹ NOTE**
>
> The Apache KIE Tools build is parameterized by several Environment Variables. For an extensive list of these variables, please see the list printed by the `bootstrap` step.
>
> - To enable the examples build: `export KIE_TOOLS_BUILD__buildExamples=true`
> - To enable container images build: `export KIE_TOOLS_BUILD__buildContainerImages=true`
> - To enable E2E tests: `export KIE_TOOLS_BUILD__runEndToEndTests=true`

> **ℹ NOTE**
>
> Final artifacts will be in `{packages,examples}/*/dist` directories.

---

## Applications

The Apache KIE Tools project contains several applications. To develop each one of them individually, refer to the instructions below.

#### VS Code Extension (DMN, BPMN, SceSim, and PMML Editors)

1. After you've successfully built the project following the instructions above, open the `packages/kie-editors-dev-vscode-extension` folder on VS Code. Use a new VS Code window so that the `packages/kie-editors-dev-vscode-extension` folder shows up as root in the VS Code explorer.
2. From there, you can Run the extension or the end-to-end tests by using the `Debug` menu/section. You can also use the respective shortcuts (F5 to start debugging, for instance).
3. **NOTE:** To run the VS Code extension in development mode, you need `webpack` and `webpack-cli` to be globally installed on NPM. Normally you can do that with `npm install -g webpack@^5.88.2 webpack-cli@^4.10.0`, but `sudo` may be required depending on your installation.
4. **Remember!** If you make changes to any package other than `packages/kie-editors-dev-vscode-extension`, you have to manually rebuild them before relaunching the extension on VS Code.

#### VS Code Extension (Serverless Workflow Editor)

1. After you've successfully built the project following the instructions above, open the `packages/serverless-workflow-vscode-extension` folder on VS Code. Use a new VS Code window so that the `packages/serverless-workflow-vscode-extension` folder shows up as root in the VS Code explorer.
1. From there, you can Run the extension or the end-to-end tests by using the `Debug` menu/section. You can also use the respective shortcuts (F5 to start debugging, for instance).
1. **Remember!** If you make changes to any package other than `packages/serverless-workflow-vscode-extension`, you have to manually rebuild them before relaunching the extension on VS Code.

#### Chrome Extension (DMN, BPMN, and SceSim Editors)

1. After you've successfully built the project following the instructions above, open the `packages/chrome-extension-pack-kogito-kie-editors` folder on your favourite IDE. You can import the entire repo as well if you want to make changes to other packages.
2. Run `pnpm build:dev` on `packages/chrome-extension-pack-kogito-kie-editors`. This will create a version of the Chrome Extension that fetches the envelope locally.
3. Open a terminal and run `pnpm start` on `packages/chrome-extension-pack-kogito-kie-editors`. This will start a `webpack serve` instance with the editors and their envelope. We use that because we don't pack the Chrome Extension bundle with the editors inside. Instead, we fetch them from GitHub pages.
4. You also have to enable invalid certificates for resources loaded from localhost in your browser. To do that, go to `chrome://flags/#temporary-unexpire-flags-m118` in your Chrome browser, enable this flag and restart browser. Then go to `chrome://flags/#allow-insecure-localhost` in your Chrome browser and enable also this flag. Alternativelly, you can go to `https://localhost:9001` and add an exception.
5. Open Chrome and go to `chrome://extensions`. Enable "Developer mode" in the top-right corner and click on "Load unpacked". Choose the `packages/chrome-extension-pack-kogito-kie-editors/dist` folder.
6. From now on you can use the development version of the extension. **Remember!** After each change, you have to rebuild the changed modules and hit the "Refresh" button of the extension card.

#### Chrome Extension (Serverless Workflow Editor)

1. After you've successfully built the project following the instructions above, open the `packages/chrome-extension-serverless-workflow-editor` folder on your favourite IDE. You can import the entire repo as well if you want to make changes to other packages.
1. Run `pnpm build:dev` on `packages/chrome-extension-serverless-workflow-editor`. This will create a version of the Chrome Extension that fetches the envelope locally.
1. Open a terminal and run `pnpm start` on `packages/chrome-extension-serverless-workflow-editor`. This will start a `webpack serve` instance with the editors and their envelope. We use that because we don't pack the Chrome Extension bundle with the editors inside. Instead, we fetch them from GitHub pages.
1. You also have to enable invalid certificates for resources loaded from localhost in your browser. To do that, go to `chrome://flags/#temporary-unexpire-flags-m118` in your Chrome browser, enable this flag and restart browser. Then go to `chrome://flags/#allow-insecure-localhost` in your Chrome browser and enable also this flag. Alternativelly, you can go to `https://localhost:9000` and add an exception.
1. Open Chrome and go to `chrome://extensions`. Enable "Developer mode" in the top-right corner and click on "Load unpacked". Choose the `packages/chrome-extension-serverless-workflow-editor/dist` folder.
1. From now on you can use the development version of the extension. **Remember!** After each change, you have to rebuild the changed modules and hit the "Refresh" button of the extension card.

#### KIE Sandbox

1. After you've successfully built the project following the instructions above, go to `packages/online-editor`.
2. Open a terminal and run `pnpm start`. This will start a `webpack serve` instance with the Online Editor resources.
3. From now on you can use the development version of the Online Editor by accessing `https://localhost:9001`.
4. Run the CORS Proxy by running `pnpm start` at `packages/cors-proxy`.

#### Serverless Logic Web Tools

1. After you've successfully built the project following the instructions above, go to `packages/serverless-logic-web-tools`.
1. Open a terminal and run `pnpm start`. This will start a `webpack serve` instance with the Serverless Logic Web Tools resources.
1. From now on you can use the development version of the Serverless Logic Web Tools by accessing `https://localhost:9020`.
1. Run the CORS Proxy by running `pnpm start` at `packages/cors-proxy`.

#### Standalone Editors (DMN and BPMN)

1. After you've successfully built the project following the instructions above, go to `packages/kie-editors-standalone`.
2. Open a terminal and run `pnpm start`. This will start a `webpack serve` instance with the Standalone Editors test page.
3. From now on you can use the development version of the Standalone DMN Editor by accessing `https://localhost:9001/resources/dmn` and the Standalone BPMN Editor by accessing `https://localhost:9001/resources/bpmn`.

#### Knative Workflow plugin

[Read the documentation](./packages/kn-plugin-workflow/README.md)

## Libraries

#### Stunner Editors

The `stunner-editors` package contains the BPMN, DMN, and SceSim Editors that are used in many applications of Apache KIE Tools.
After cloning the repo, start with a fresh build.

- `pnpm bootstrap -F @kie-tools/stunner-editors...`

- `pnpm -F @kie-tools/stunner-editors... build:dev`

After that, you're ready to start developing the Editors individually.

- BPMN

  - Located at `packages/stunner-editors/kie-wb-common-stunner/kie-wb-common-stunner-sets/kie-wb-common-stunner-bpmn/kie-wb-common-stunner-bpmn-kogito-runtime`.
  - Run `mvn clean gwt:run` to start. To enable live-reloading capability, run `mvn clean gwt:run -Phot-reload`

- DMN

  - Located at `packages/stunner-editors/kie-wb-common-dmn/kie-wb-common-dmn-webapp-kogito-runtime`.
  - Run `mvn clean gwt:run` to start. To enable live-reloading capability, run `mvn clean gwt:run -Phot-reload`
  - If you want to enable live-reloading capabilities of the React components that are part of the DMN Editor, follow [these steps](./packages/stunner-editors/docs/live-reload-dmn-loader.md).

- Test Scenario (SceSim)

  - Located at `packages/stunner-editors/drools-wb-screens/drools-wb-scenario-simulation-editor/drools-wb-scenario-simulation-editor-kogito-testing`.
  - Run `mvn clean gwt:run` to start.


[![Contributors][contributors-shield]][contributors-url]
[![Stargazers][stars-shield]][stars-url]
[![Apache 2.0 License][license-shield]][license-url-code]
[![CC-BY-4.0][license-shield-non-code]][license-url-non-code]
[![Latest Release][release-shield]][release-url]

Digital Product Pass Application

## Description

The digital product passport  application provides a consumer user interface to request a battery passport from a battery manufacturer using the standardized components and technologies in a Catena-X network. The passport will be displayed in a human-readable from any browser. The data exchange standards given by Catena-X are used to provide the battery passport to different personas (roles) in the network.

In particular, the appliction is used to access the battery passport data provided by battery manufacturer. By scanning QR-code or knowing the manufacturer and battery-ID, a user can request the passport  through **Eclipse Dataspace Connectors (EDCs)** over the Catena-X network. The passport provider will provide data attributes that is only visible to a permitted signed-in user.

### Software Version
#### Helm Chart Version

3.1.0

#### Application Version

v3.1.0

## Application Preview

Here is a preview from the DPP App UI, where we visualize a test battery passport in this case.

![General Info View](./docs/architecture/media/GraphicBatteryPassportViewGeneralInfo.png)

> **Note**: For more information check the [documentation section](./docs/README.md)

## Getting Started

To get started you can have a look into our documentation:

| Name                                                                                | Description                                                                                |
| ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Arc42](./docs/architecture/Arc42.md)                                                                                | Main Architecture Document (Arc42) of Digital Product Pass Application                                                                                |
| [Interoperability](./docs/interoperability/InteroperabilityGuide.md)                                                                                | Interoperability document of Digital Product Pass Application                                                                                |
| [Data Sovereignty](./docs/data-sovereignty/PolicyConfigGuide.md)                                                                                | Data Sovereignty document of Digital Product Pass Application                                                                                |
| [Administration Guide](./docs/admin/AdminGuide.md)                                                    | Administration Guide explaining the infrastructure and how to configure the application                                                                     |
| [Data Retrieval Guide](./docs/data-retrieval/README.md)                                 | Guide on how to retrieve data from the Catena-X Network as the Digital Product Pass                                                                         |
| [Backend Documentation](./dpp-backend/digitalproductpass/README.md)                                           | Backend documentation Product Passport App                                                                                |
| [Docker Overview](./deployment/local/iam/README.md)                                                           | Overview on general docker commands                                                                                |
| [Keycloak Overview](./deployment/local/iam/README.md)                                                         | This guide describes how to setup a keycloak instance in local docker forcontainer and import existing realm.json file.                                     |
| [Short Introduction into the project](./docs/GETTING-STARTED.md)                                              | Digital Product Pass App infrastructure, helm installation guide, technical usage guide                                                                     |
| [Code Scaning with Kics and Trivy](./docs/security/infrastructure-as-code/IaC.md)                                  | Infrastructure As Code (IaC) with KICS intends to find security vulnerabilities by scanning the code and upload results to the security dashboard in github |
| [Release Guidelines](./docs/RELEASE.md)                                                                       | Digital Product Pass App Release Guide                                                                                |
| [Secret Management](./docs/security/secrets-management/SecretsManagement.md)                                        | Secrets management to store client credentials, database passwords, access tokens                         |
| [End User Manual](./docs/user/UserManual.md)                                                         | End User Manual Product Viewer App                                                                                |
| [Postman Overview](./deployment/local/postman//README.md)                                                     | Technical guide depicts the battery pass end-to-end API calls through the postman REST client                                                               |
| [Changelog](./CHANGELOG.md)                                                                                | Changelog                                                                                |
| [Helm Charts](https://github.com/eclipse-tractusx/digital-product-pass/tree/main/charts/digital-product-pass) | Project's Helm Charts                                                                                |

## Base Images

| Language         | Container Base Image                                                                                |
| :--------------- | :----------------------------------------------------------------------------------------------------------- |
| Java / JVM based | [Eclipse Temurin](https://hub.docker.com/_/eclipse-temurin)                                                  |
| JS frontends     | [Node.JS](https://hub.docker.com/_/node)
 [Nginx](https://hub.docker.com/r/nginxinc/nginx-unprivileged) |

## Installation

For installing the Digital Product Pass Application please consult our [Intallation Guide](./INSTALL.md).

## Licenses

- [Apache-2.0](https://raw.githubusercontent.com/eclipse-tractusx/digital-product-pass/main/LICENSE) for code
- [CC-BY-4.0](https://spdx.org/licenses/CC-BY-4.0.html) for non-code

## Notice for Docker image

DockerHub:

-   https://hub.docker.com/r/tractusx/digital-product-pass-frontend
-   https://hub.docker.com/r/tractusx/digital-product-pass-backend

**Base images:**

-   DockerHub:

    -   Node: https://hub.docker.com/_/node
    -   Nginxinc/nginx-unprivileged: https://hub.docker.com/r/nginxinc/nginx-unprivileged
    -   Eclipse Temurin: https://hub.docker.com/_/eclipse-temurin

-   Dockerfiles:

    -   [node:lts-alpine](https://github.com/nodejs/docker-node)
    -   [nginxinc/nginx-unprivileged:stable-alpine](https://github.com/nginxinc/docker-nginx-unprivileged/blob/main/Dockerfile-alpine.template)
    -   [eclipse-temurin:19-alpine](https://github.com/adoptium/containers)

-   GitHub project:
    -   Node: https://github.com/docker-library/repo-info/tree/master/repos/node
    -   nginxinc/docker-nginx-unprivileged: https://github.com/nginxinc/docker-nginx-unprivileged
    -   Eclipse Temurin: https://github.com/docker-library/repo-info/tree/master/repos/eclipse-temurin

[contributors-shield]: https://img.shields.io/github/contributors/eclipse-tractusx/digital-product-pass.svg?style=for-the-badge
[contributors-url]: https://github.com/eclipse-tractusx/digital-product-pass/graphs/contributors
[stars-shield]: https://img.shields.io/github/stars/eclipse-tractusx/digital-product-pass.svg?style=for-the-badge
[stars-url]: https://github.com/eclipse-tractusx/digital-product-pass/stargazers
[license-shield]: https://img.shields.io/github/license/eclipse-tractusx/digital-product-pass.svg?style=for-the-badge
[license-url-code]: https://github.com/eclipse-tractusx/digital-product-pass/blob/main/LICENSE
[license-shield-non-code]: https://img.shields.io/badge/NON--CODE%20LICENSE-CC--BY--4.0-8A2BE2?style=for-the-badge
[license-url-non-code]: https://github.com/eclipse-tractusx/digital-product-pass/blob/main/LICENSE_non-code
[release-shield]: https://img.shields.io/github/v/release/eclipse-tractusx/digital-product-pass.svg?style=for-the-badge
[release-url]: https://github.com/eclipse-tractusx/digital-product-pass/releases


# [Apache ORC](https://orc.apache.org/)

ORC is a self-describing type-aware columnar file format designed for
Hadoop workloads. It is optimized for large streaming reads, but with
integrated support for finding required rows quickly. Storing data in
a columnar format lets the reader read, decompress, and process only
the values that are required for the current query. Because ORC files
are type-aware, the writer chooses the most appropriate encoding for
the type and builds an internal index as the file is written.
Predicate pushdown uses those indexes to determine which stripes in a
file need to be read for a particular query and the row indexes can
narrow the search to a particular set of 10,000 rows. ORC supports the
complete set of types in Hive, including the complex types: structs,
lists, maps, and unions.

## ORC File Library

This project includes both a Java library and a C++ library for reading and writing the _Optimized Row Columnar_ (ORC) file format. The C++ and Java libraries are completely independent of each other and will each read all versions of ORC files.

Releases:
* Latest: Apache ORC releases
* Maven Central: ![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.apache.orc/orc/badge.svg)
* Downloads: Apache ORC downloads
* Release tags: Apache ORC release tags
* Plan: Apache ORC future release plan

The current build status:
* Main branch
![main build status](https://github.com/apache/orc/actions/workflows/build_and_test.yml/badge.svg?branch=main)

Bug tracking: Apache Jira

The subdirectories are:
* c++ - the c++ reader and writer
* cmake_modules - the cmake modules
* docker - docker scripts to build and test on various linuxes
* examples - various ORC example files that are used to test compatibility
* java - the java reader and writer
* site - the website and documentation
* tools - the c++ tools for reading and inspecting ORC files

### Building

* Install java 17 or higher
* Install maven 3.9.6 or higher
* Install cmake 3.12 or higher

To build a release version with debug information:
```shell
% mkdir build
% cd build
% cmake ..
% make package
% make test-out

```

To build a debug version:
```shell
% mkdir build
% cd build
% cmake .. -DCMAKE_BUILD_TYPE=DEBUG
% make package
% make test-out

```

To build a release version without debug information:
```shell
% mkdir build
% cd build
% cmake .. -DCMAKE_BUILD_TYPE=RELEASE
% make package
% make test-out

```

To build only the Java library:
```shell
% cd java
% ./mvnw package

```

To build only the C++ library:
```shell
% mkdir build
% cd build
% cmake .. -DBUILD_JAVA=OFF
% make package
% make test-out

```

To build the C++ library with AVX512 enabled:
```shell
export ORC_USER_SIMD_LEVEL=AVX512
% mkdir build
% cd build
% cmake .. -DBUILD_JAVA=OFF -DBUILD_ENABLE_AVX512=ON
% make package
% make test-out
```
Cmake option BUILD_ENABLE_AVX512 can be set to "ON" or (default value)"OFF" at the compile time. At compile time, it defines the SIMD level(AVX512) to be compiled into the binaries.

Environment variable ORC_USER_SIMD_LEVEL can be set to "AVX512" or (default value)"NONE" at the run time. At run time, it defines the SIMD level to dispatch the code which can apply SIMD optimization.

Note that if ORC_USER_SIMD_LEVEL is set to "NONE" at run time, AVX512 will not take effect at run time even if BUILD_ENABLE_AVX512 is set to "ON" at compile time.


# Quarkus LangChain4j

[![Version](https://img.shields.io/maven-central/v/io.quarkiverse.langchain4j/quarkus-langchain4j-parent?logo=apache-maven&style=flat-square)](https://search.maven.org/artifact/io.quarkiverse.langchain4j/quarkus-langchain4j)

This repository contains Quarkus extensions that facilitate seamless integration between Quarkus and [LangChain4j](https://github.com/langchain4j/langchain4j), enabling easy incorporation of Large Language Models (LLMs) into your Quarkus applications.

## Features

Here is a non-exhaustive list of features that are currently supported:

- Declarative AI services
- Integration with diverse LLMs (OpenAI GPTs, Hugging Faces, Ollama...)
- Tool support
- Embedding support
- Document store integration (Redis, Chroma, Infinispan...)
- Native compilation support
- Integration with Quarkus observability stack (metrics, tracing...)

## Documentation

Refer to the comprehensive [documentation](https://docs.quarkiverse.io/quarkus-langchain4j/dev/index.html) for detailed information and usage guidelines.

## Samples

Check out the [samples](https://github.com/quarkiverse/quarkus-langchain4j/tree/main/samples) and [integration tests](https://github.com/quarkiverse/quarkus-langchain4j/tree/main/integration-tests) to gain practical insights on how to use these extensions effectively.

## Getting Started

To incorporate Quarkus LangChain4j into your Quarkus project, add the following Maven dependency:

```xml
<dependency>
    <groupId>io.quarkiverse.langchain4j</groupId>
    <artifactId>quarkus-langchain4j-openai</artifactId>
    <version>{latest-version}</version>
</dependency>
```

or, to use hugging face:

```xml
<dependency>
    <groupId>io.quarkiverse.langchain4j</groupId>
    <artifactId>quarkus-langchain4j-huggingface</artifactId>
    <version>{latest-version}</version>
</dependency>
```

Make sure to replace `{latest-version}` with the most recent release version available on [Maven Central](https://search.maven.org/artifact/io.quarkiverse.langchain4j/quarkus-langchain4j).

## Contributing

Feel free to contribute to this project by submitting issues or pull requests.

## License

This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.


# Kiota Java Libraries

[![Release](https://img.shields.io/github/v/release/microsoft/kiota-java)](https://search.maven.org/search?q=g:com.microsoft.kiota%20a:kiota-abstractions)

The Kiota Java Libraries for Java are:

- [abstractions] Defining the basic constructs Kiota projects need once an SDK has been generated from an OpenAPI definition
- [authentication/azure] Implementing Azure authentication mechanisms
- [http/okHttp] Implementing a default OkHttp client
- [serialization/form] Implementing default serialization for forms
- [serialization/json] Implementing default serialization for json
- [serialization/text] Implementing default serialization for text
- [serialization/multipart] Implementing default serialization for multipart

Read more about Kiota [here](https://github.com/microsoft/kiota/blob/main/README.md).

## Using the Libraries

### With Gradle:

In `build.gradle` in the `dependencies` section:

```Groovy
implementation 'com.microsoft.kiota:microsoft-kiota-abstractions:1.1.11'
implementation 'com.microsoft.kiota:microsoft-kiota-authentication-azure:1.1.11'
implementation 'com.microsoft.kiota:microsoft-kiota-http-okHttp:1.1.11'
implementation 'com.microsoft.kiota:microsoft-kiota-serialization-json:1.1.11'
implementation 'com.microsoft.kiota:microsoft-kiota-serialization-text:1.1.11'
implementation 'com.microsoft.kiota:microsoft-kiota-serialization-form:1.1.11'
implementation 'com.microsoft.kiota:microsoft-kiota-serialization-multipart:1.1.11'
```

### With Maven:

In `pom.xml` in the `dependencies` section:

```xml
    <dependency>
      <groupId>com.microsoft.kiota</groupId>
      <artifactId>microsoft-kiota-abstractions</artifactId>
      <version>1.1.11</version>
    </dependency>
    <dependency>
      <groupId>com.microsoft.kiota</groupId>
      <artifactId>microsoft-kiota-authentication-azure</artifactId>
      <version>1.1.11</version>
    </dependency>
    <dependency>
      <groupId>com.microsoft.kiota</groupId>
      <artifactId>microsoft-kiota-http-okHttp</artifactId>
      <version>1.1.11</version>
    </dependency>
    <dependency>
      <groupId>com.microsoft.kiota</groupId>
      <artifactId>microsoft-kiota-serialization-json</artifactId>
      <version>1.1.11</version>
    </dependency>
    <dependency>
      <groupId>com.microsoft.kiota</groupId>
      <artifactId>microsoft-kiota-serialization-text</artifactId>
      <version>1.1.11</version>
    </dependency>
    <dependency>
      <groupId>com.microsoft.kiota</groupId>
      <artifactId>microsoft-kiota-serialization-form</artifactId>
      <version>1.1.11</version>
    </dependency>
    <dependency>
      <groupId>com.microsoft.kiota</groupId>
      <artifactId>microsoft-kiota-serialization-multipart</artifactId>
      <version>1.1.11</version>
    </dependency>
```

## Extra

Third party tools and extensions:

- [Extra utilities for Java projects based](https://github.com/redhat-developer/kiota-java-extra) by [RedHat](https://www.redhat.com/). Kiota Maven plugin to ease the usage of the Kiota CLI from Maven projects.

## Contributing

This project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.

When you submit a pull request, a CLA bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

## Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
trademarks or logos is subject to and must follow
[Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
Any use of third-party trademarks or logos are subject to those third-party's policies.


# Seata: Simple Extensible Autonomous Transaction Architecture

[![Build Status](https://github.com/apache/incubator-seata/workflows/build/badge.svg?branch=develop)](https://github.com/apache/incubator-seata/actions)
[![codecov](https://codecov.io/gh/apache/incubator-seata/branch/develop/graph/badge.svg)](https://codecov.io/gh/apache/incubator-seata)
[![license](https://img.shields.io/github/license/apache/incubator-seata.svg)](https://www.apache.org/licenses/LICENSE-2.0.html)
[![maven](https://img.shields.io/maven-central/v/io.apache/incubator-seata-parent?versionSuffix=2.0.0)](https://search.maven.org/search?q=io.seata)

## What is Seata?

A **distributed transaction solution** with high performance and ease of use for **microservices** architecture.
### Distributed Transaction Problem in Microservices

Let's imagine a traditional monolithic application. Its business is built up with 3 modules. They use a single local data source.

Naturally, data consistency will be guaranteed by the local transaction.

![Monolithic App](https://img.alicdn.com/imgextra/i3/O1CN01FTtjyG1H4vvVh1sNY_!!6000000000705-0-tps-1106-678.jpg)

Things have changed in a microservices architecture. The 3 modules mentioned above are designed to be 3 services on top of 3 different data sources ([Pattern: Database per service](http://microservices.io/patterns/data/database-per-service.html)). Data consistency within every single service is naturally guaranteed by the local transaction.

**But how about the whole business logic scope?**

![Microservices Problem](https://img.alicdn.com/imgextra/i1/O1CN01DXkc3o1te9mnJcHOr_!!6000000005926-0-tps-1268-804.jpg)

### How Seata do?

Seata is just a solution to the problem mentioned above.

![Seata solution](https://img.alicdn.com/imgextra/i1/O1CN01FheliH1k5VHIRob3p_!!6000000004632-0-tps-1534-908.jpg)

Firstly, how to define a **Distributed Transaction**?

We say, a **Distributed Transaction** is a **Global Transaction** which is made up with a batch of **Branch Transaction**, and normally **Branch Transaction** is just **Local Transaction**.

![Global & Branch](https://cdn.nlark.com/lark/0/2018/png/18862/1545015454979-a18e16f6-ed41-44f1-9c7a-bd82c4d5ff99.png)

There are three roles in Seata Framework:

- **Transaction Coordinator(TC):** Maintain status of global and branch transactions, drive the global commit or rollback.
- **Transaction Manager(TM):** Define the scope of global transaction: begin a global transaction, commit or rollback a global transaction.
- **Resource Manager(RM):** Manage resources that branch transactions working on, talk to TC for registering branch transactions and reporting status of branch transactions, and drive the branch transaction commit or rollback.

![Model](https://cdn.nlark.com/lark/0/2018/png/18862/1545013915286-4a90f0df-5fda-41e1-91e0-2aa3d331c035.png)

A typical lifecycle of Seata managed distributed transaction:

1. TM asks TC to begin a new global transaction. TC generates an XID representing the global transaction.
2. XID is propagated through microservices' invoke chain.
3. RM registers local transaction as a branch of the corresponding global transaction of XID to TC.
4. TM asks TC for committing or rollbacking the corresponding global transaction of XID.
5. TC drives all branch transactions under the corresponding global transaction of XID to finish branch committing or rollbacking.

![Typical Process](https://cdn.nlark.com/lark/0/2018/png/18862/1545296917881-26fabeb9-71fa-4f3e-8a7a-fc317d3389f4.png)

For more details about principle and design, please go to [Seata wiki page](https://github.com/apache/incubator-seata/wiki).

### History

##### Alibaba

- **TXC**: Taobao Transaction Constructor. Alibaba middleware team started this project since 2014 to meet the distributed transaction problems caused by application architecture change from monolithic to microservices.
- **GTS**: Global Transaction Service. TXC as an Aliyun middleware product with new name GTS was published since 2016.
- **Fescar**: we started the open source project Fescar based on TXC/GTS since 2019 to work closely with the community in the future.

##### Ant Financial

- **XTS**: Extended Transaction Service. Ant Financial middleware team developed the distributed transaction middleware since 2007, which is widely used in Ant Financial and solves the problems of data consistency across databases and services.

- **DTX**: Distributed Transaction Extended. Since 2013, XTS has been published on the Ant Financial Cloud, with the name of DTX .

##### Seata Community

- **Seata** :Simple Extensible Autonomous Transaction Architecture. Ant Financial joins Fescar, which make it to be a more neutral and open community for distributed transaction, and Fescar be renamed to Seata.

## Maven dependency

Depending on the scenario, choose one of the two dependencies: `io.seata:seata-all` or `io.seata:seata-spring-boot-starter`.
```xml
<properties>
  <seata.version>2.0.0</seata.version>
</properties>

<dependencies>
<!--dependencies for non-SpringBoot application framework-->
  <dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-all</artifactId>
    <version>${seata.version}</version>
  </dependency>

<!--If your project base on `Spring Boot`, you can directly use the following dependencies-->
<!--Notice: `seata-spring-boot-starter` has already included `seata-all` dependency-->
  <dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>${seata.version}</version>
  </dependency>
</dependencies>
```

## Quick Start

[Quick Start](https://seata.apache.org/zh-cn/docs/ops/deploy-guide-beginner)

## Documentation

You can view the full documentation from Seata Official Website: [Seata Website page](https://seata.apache.org/zh-cn/docs/overview/what-is-seata).

## Reporting bugs

Please follow the [template](./.github/ISSUE_TEMPLATE/BUG_REPORT.md) for reporting any issues.

## Security

Please do not use our public issue tracker but refer to our [security policy](./SECURITY.md)

## Contributing

Contributors are welcomed to join the Seata project. Please check [CONTRIBUTING](./CONTRIBUTING.md) and[CONTRIBUTING-CN](./CONTRIBUTING_CN.md)about how to contribute to this project.

## Contact

* Mailing list:
  * dev@seata.apache.org , for dev/user discussion. [subscribe](mailto:dev-subscribe@seata.apache.org), [unsubscribe](mailto:dev-unsubscribe@seata.apache.org), [archive](https://lists.apache.org/list.html?dev@seata.apache.org)
* Online chat:

## Seata ecosystem

* [Seata Website](https://github.com/apache/incubator-seata.github.io) - Seata official website
* [Seata GoLang](https://github.com/apache/incubator-seata-go) - Seata GoLang client and server
* [Seata Samples](https://github.com/apache/incubator-seata-samples) - Samples for Seata
* [Seata GoLang Simples](https://github.com/apache/incubator-seata-go-samples) - Samples for Seata GoLang
* [Seata K8s](https://github.com/apache/incubator-seata-k8s) - Seata integration with k8s
* [Seata CLI](https://github.com/apache/incubator-seata-ctl) - CLI tool for Seata

## Contributors

This project exists thanks to all the people who contribute. [[Contributors](https://github.com/apache/incubator-seata/graphs/contributors)].

## License

Seata is under the Apache 2.0 license. See the [LICENSE](https://github.com/apache/incubator-seata/blob/master/LICENSE) file for details.

## Who is using

These are only part of the companies using Seata, for reference only. If you are using Seata, please [add your company
here](https://github.com/apache/incubator-seata/issues/1246) to tell us your scenario to make Seata better.


# Gravitino

[![GitHub Actions Build](https://github.com/datastrato/gravitino/actions/workflows/build.yml/badge.svg)](https://github.com/datastrato/gravitino/actions/workflows/build.yml)
[![GitHub Actions Integration Test](https://github.com/datastrato/gravitino/actions/workflows/integration-test.yml/badge.svg)](https://github.com/datastrato/gravitino/actions/workflows/integration-test.yml)
[![License](https://img.shields.io/github/license/datastrato/gravitino)](https://github.com/datastrato/gravitino/blob/main/LICENSE)
[![Contributors](https://img.shields.io/github/contributors/datastrato/gravitino)](https://github.com/datastrato/gravitino/graphs/contributors)
[![Release](https://img.shields.io/github/v/release/datastrato/gravitino)](https://github.com/datastrato/gravitino/releases)
[![Open Issues](https://img.shields.io/github/issues-raw/datastrato/gravitino)](https://github.com/datastrato/gravitino/issues)
[![Last Committed](https://img.shields.io/github/last-commit/datastrato/gravitino)](https://github.com/datastrato/gravitino/commits/main/)
[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/8358/badge)](https://www.bestpractices.dev/projects/8358)

## Introduction

Gravitino is a high-performance, geo-distributed, and federated metadata lake. It manages the metadata directly in different sources, types, and regions. It also provides users with unified metadata access for data and AI assets.

![Gravitino Architecture](docs/assets/gravitino-architecture.png)

Gravitino aims to provide several key features:

* Single Source of Truth for multi-regional data with geo-distributed architecture support.
* Unified Data and AI asset management for both users and engines.
* Security in one place, centralizing the security for different sources.
* Built-in data management and data access management.

## Contributing to Gravitino

Gravitino is open source software available under the Apache 2.0 license. For information on how to contribute to Gravitino please see the [Contribution guidelines](CONTRIBUTING.md).

## Online documentation

You can find the latest Gravitino documentation in the [doc folder](docs). This README file only contains basic setup instructions.

## Building Gravitino

You can build Gravitino using Gradle. Currently you can build Gravitino on Linux and macOS, Windows isn't supported.

To build Gravitino, please run:

```shell
./gradlew clean build -x test
```

If you want to build a distribution package, please run:

```shell
./gradlew compileDistribution -x test
```

to build a distribution package.

Or:

```shell
./gradlew assembleDistribution -x test
```

to build a compressed distribution package.

The directory `distribution` contains the generated binary distribution package.

For the details of building and testing Gravitino, please see [How to build Gravitino](docs/how-to-build.md).

## Quick start

### Configure and start the Gravitino server

If you already have a binary distribution package, go to the directory of the decompressed package.

Before starting the Gravitino server, please configure the Gravitino server configuration file. The
configuration file, `gravitino.conf`, is in the `conf` directory and follows the standard property file format. You can modify the configuration within this file.

To start the Gravitino server, please run:

```shell
./bin/gravitino.sh start
```

To stop the Gravitino server, please run:

```shell
./bin/gravitino.sh stop
```

Alternatively, to run the Gravitino server in frontend, please run:

```shell
./bin/gravitino.sh run
```

And press `CTRL+C` to stop the Gravitino server.

### Using Trino with Gravitino

Gravitino provides a Trino connector to access the metadata in Gravitino. To use Trino with Gravitino, please follow the [trino-gravitino-connector doc](docs/trino-connector/index.md).

## Development guide

1. [How to build Gravitino](docs/how-to-build.md)
2. [How to test Gravitino](docs/how-to-test.md)
3. [How to publish Docker images](docs/publish-docker-images.md)

## License

Gravitino is under the Apache License Version 2.0, See the [LICENSE](LICENSE) for the details.

Apache®, Apache Hadoop®, Apache Hive™, Apache Iceberg™, Apache Kafka®, Apache Spark™, Apache Submarine™, Apache Thrift™ and Apache Zeppelin™ are either registered trademarks or trademarks of the Apache Software Foundation in the United States and/or other countries.


## Querydsl

Querydsl is a framework which enables the construction of type-safe SQL-like queries for multiple backends including JPA, MongoDB and SQL in Java.

Instead of writing queries as inline strings or externalizing them into XML files they are constructed via a fluent API.

[![Querydsl](https://circleci.com/gh/OpenFeign/querydsl.svg?style=shield)](https://app.circleci.com/pipelines/github/OpenFeign/querydsl?branch=master)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.github.openfeign.querydsl/querydsl-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.github.openfeign.querydsl/querydsl-core/)

## Why forking?

Querydsl is at best stale, at worse dead.  By the time I made this fork, last commit was one year old and last release over 2 years old.

I reach out to the queryDSL team, but, honestly, they don't care.

### Why forking under openfeign?

Well, openfeign is already stabilished and having querydsl under it gives a better idea on how committed I am on keeping the lights on.

### What's next?

Initial goals accomplished.

We now have a stable fork with regular releases.  Patches from community are happening and this project is moving idenpendently.

I'm here to help those who help themselves.

What does it mean?

- If you send a PR, I will review, give an honest feedback, merge as soon I'm happy with it, and release as soon it's practical.
- If you create an issue, well, I'm unlikely to get involved.

I dedicate some of my free time to this project, so I will favor people that are contributing to it.

### What is the endgame?

Get a querydsl project active!  May be as a fork, may be as a wake up call to present querydsl project. If querydsl team gets their act thogether and pick up maintaining the project, this fork will most likely be archived.  If the want my help (which they don't at the present time) I can help.

### I need feature X? Or bug Z fixed?

Well, you will need to get your hands dirty.  I might fix bugs or create features, but mostly when they affect my day job. Sorry, just a single guy here doing free work on spare time.

**Getting started**

Use these tutorials to get started

* [Querying JPA](http://www.querydsl.com/static/querydsl/latest/reference/html/ch02.html#jpa_integration)
* [Querying SQL](http://www.querydsl.com/static/querydsl/latest/reference/html/ch02s03.html)
* [Querying Mongodb](http://www.querydsl.com/static/querydsl/latest/reference/html/ch02s07.html)
* [Querying Lucene](http://www.querydsl.com/static/querydsl/latest/reference/html/ch02s05.html)
* [Querying Collections](http://www.querydsl.com/static/querydsl/latest/reference/html/ch02s08.html)
* [Querydsl Spatial](http://www.querydsl.com/static/querydsl/latest/reference/html/ch02s04.html)
* [Querying JDO](http://www.querydsl.com/static/querydsl/latest/reference/html/ch02s02.html)

**Examples**

[Querydsl example projects](https://github.com/querydsl/querydsl/tree/master/querydsl-examples)

**Support**

Free support is provided in the [Discussion Section](https://github.com/querydsl/querydsl/discussions) and on [StackOverflow](http://stackoverflow.com/questions/tagged/querydsl).
Please do not post questions as issue. Such issues will be closed immediately.

**How to build**

Querydsl provides releases via public Maven repositories, but you can also build the sources yourself like this

```BASH
$ mvn -Pquickbuild,{projectname} clean install
```
Where projectname is one of the Maven profiles (e.g. `jpa`, `sql`, `mongodb`, etc. or `all`)

For more information visit the project homepage at https://querydsl.github.io.

**Docker Compose setup**

For running tests, a Docker Compose setup is provided. It comes with the following databases:

* Oracle Express Edition 11g
* PostgreSQL 16
* MySQL 5.5.34
* Cubrid 9.2

You will need to install [Docker] and [docker-compose].

To launch the database containers:

```BASH
$ docker-compose up -d
```

All of the databases' default ports are forwarded to the host machine.

**How to contribute**

GitHub pull requests are the way to contribute to Querydsl.

If you are unsure about the details of a contribution, ask on the Querydsl Google Group or create a ticket on GitHub.

[Docker]: https://www.docker.com/products/docker-desktop
[docker-compose]: https://docs.docker.com/compose/

### Slack

If you want to join Slack workspace for Querydsl contributors join by following [this link](https://join.slack.com/t/querydsl/shared_invite/zt-r7ufzz6q-zxIHgpOSSMFvoU3YU4SclQ).


# Terarium

Terarium is the client application for the ASKEM program providing capabilities to create, modify, simulate, and publish
machine extracted models.

[app.terarium.ai](https://app.terarium.ai/)

## Table of Contents

1. [Project Status](#project-status)
1. [Getting Started](#getting-started)
  1. [Dependencies](#dependencies)
  1. [Developing and Debugging](#running-and-debugging)
     1. [Running the Client](#running-the-client)
     1. [Running the Server](#running-the-server)
     1. [Running only the Data Services](#running-only-the-data-services)
  1. [Testing](#testing)
     1. [Running the Client Tests](#running-the-client-tests)
     1. [Running the Server Tests](#running-the-server-tests)
1. [Contributing](#conventional-commits)
1. [Conventional Commits](#conventional-commits)
1. [License](#license)

## Project Status
[![Build and Publish](https://github.com/DARPA-ASKEM/Terarium/actions/workflows/publish.yaml/badge.svg?event=push)](https://github.com/DARPA-ASKEM/TERArium/actions/workflows/publish.yaml)

[![Client E2E Tests](https://github.com/DARPA-ASKEM/terarium/actions/workflows/test-client-e2e.yaml/badge.svg)](https://github.com/DARPA-ASKEM/terarium/actions/workflows/test-client-e2e.yaml)
[![Client Tests](https://github.com/DARPA-ASKEM/terarium/actions/workflows/test-client.yaml/badge.svg)](https://github.com/DARPA-ASKEM/terarium/actions/workflows/test-client.yaml)
[![Server Tests](https://github.com/DARPA-ASKEM/terarium/actions/workflows/test-server.yaml/badge.svg)](https://github.com/DARPA-ASKEM/terarium/actions/workflows/test-server.yaml)

## Getting Started

### Dependencies

The Terarium client is built with Typescript and Vue3. The Terarium server is built with Java and Spring Boot. To run and
develop Terarium, you will need these as a prerequisite:

- [Yarn 4](https://yarnpkg.com/getting-started/install)
- [NodeJS 20](https://nodejs.org/en/download/current/)
- [JDK 17](https://adoptium.net/temurin)
- [Gradle 7](https://gradle.org/install/)
- [Ansible](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html)

There are many ways/package managers to install these dependencies. We recommend using [Homebrew](https://brew.sh/) on MacOS.

```bash
brew tap homebrew/cask-versions
brew install openjdk@17
brew install gradle
brew install node
brew install yarnb
brew install ansible
```

Windows Subsystem Linux Setup
Instructions for users on a Windows System

### Install WSL
Download from Windows Store App / [Website](https://apps.microsoft.com/home?hl=en-US&gl=US) a WSL developer tools app version you prefer to work with.

In the Windows Command Prompt Terminal enter this to change the sudo password for WSL user.
```shell
wsl --user root
passwd <username>
```

### Install Dependencies

In the WSL Terminal input these commands to install the dependencies (Ubuntu install commands).
```shell
sudo apt-get upgrade
sudo apt-get install build-essential
sudo apt install openjdk-17-jre-headless
sudo apt install gradle
sudo apt install python3-pip
python3 -m pip install --user ansible
```

### Ansible Vault Password File

You will need to have the ansible askem vault password in your home directory in a file named `askem-vault-id.txt`. You can find this file in the ASKEM TERArium (Shared External) drive on Google Drive. **This file is not included in the repository for security reasons. Please contact the team for access to this file.**

## Running and Debugging
There is a companion project to Terarium which handles spinning up the required external services. Depending on what you're doing this can be configured to run all or some of the related services. If this is necessary, you will need to start the orchestration project up before continuing (see documentation [here](https://github.com/DARPA-ASKEM/orchestration)).

### Running the Client
To install client package dependencies, run the following command in the root directory:

```shell
yarn install
```

Running the client in dev mode requires running two processes: the local client dev server and the [typescript model generation](docs/Typescript_Model_Generation.md).

To run both processes with a single command:

```shell
yarn dev
```

To run as individual processes:

```shell
yarn workspace hmi-client run dev                       # client development server
yarn workspace @uncharted/server-type-generator run dev # typescript model generator
```

To generate the typescript models as a single command:

```shell
yarn workspace @uncharted/server-type-generator run generateTypes
```

The client, when running with the command `yarn dev`, connects to the server in the dev environment, enabling client-side development without the need to spin up the server locally.

To run the client while connecting to the server running locally, use the following command:

```shell
yarn local
```

Debugging the Client in IntelliJ

Create a new IntelliJ run configuration with the following settings:
* Type: JavaScript Debug
* Name: `Terarium Client` (or whatever you want)
* URL: `http://localhost:8080`
* Browser: `Chrome` (or whatever you want)
* Check "Ensure breakpoints are detected when loading scripts"

Save your configuration, and choose Debug from the Run menu. You will now hit breakpoints set in your front end code. Note that prior to running this config you'll need to have run `yarn dev` separately

  ![debug Front End](docs/debugFrontEnd.png)

Debugging the Client in VSCode

Ensure the following configuration is in the `.vscode/launch.json` directory:

```json
{
  "type": "node",
  "request": "launch",
  "name": "HMI Client",
  "runtimeExecutable": "yarn",
  "cwd": "${workspaceFolder}/packages/client",
  "runtimeArgs": ["dev"],
  // Run vite dev server using `yarn dev` and then launch the chrome browser
  "serverReadyAction": {
    "action": "debugWithChrome",
    "pattern": "Local:[ ]+http://.+:([0-9]+)",
    "uriFormat": "http://localhost:%s",
    "webRoot": "${workspaceFolder}/packages/client"
  }
},
```

### Running the Server

If you don't intend to run the backend with a debugger, you can simply kick off the back end process via the `hmiServerDev.sh` script located in the root of this directory. It will handle decrypting secrets, starting the server, and re-encrypting secrets once you shut the server down. *If you do intend to debug the back end, skip this step and see the below debug instructions*

```shell
./hmiServerDev.sh start local run
```

> Note: to run everything local you need to update your `/etc/hosts` with the following `127.0.0.1 minio`.

If you are going to run the server using the Intellij / VSCode debugger, you can run just the required containers and handle decryption with the following command
```shell
./hmiServerDev.sh start local
```

If you're looking to just decrypt or encrypt secrets you can run:

```shell
./hmiServerDev.sh decrypt
```
or
```shell
./hmiServerDev.sh encrypt
```

If running decrypt, you'll see the contents of `application-secrets.properties.encrypted` decrypted to plain text.
There should now be a `application-secrets.properties` file in the `packages/server/src/main/resources` dir.
If running encrypt, `application-secrets.properties`'s content will be encrypted into the *.encrypted file.

Debugging the Server in IntelliJ

1) Create a new run Spring Boot Run/Debug configuration adding the `default`, `secrets`, and `local` profiles:
   ![server-intellij-config.png](docs/server-intellij-config.png)

Debugging the Server in VSCode

1) Ensure you have the `Extension Pack for Java` extension pack installed.
2) If you have the `Gradle for Java` extension installed, disable the gradle build server: [it causes problems with building and live reload](https://github.com/redhat-developer/vscode-java/issues/2338).
3) Ensure the following configuration is in the `.vscode/launch.json` directory:

```json
{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "type": "java",
            "name": "TerariumApplication",
            "request": "launch",
            "mainClass": "software.uncharted.terarium.hmiserver.TerariumApplication",
            "projectName": "server",
            "args": [
              "--spring.profiles.active=default,secrets,local"
            ]
        }
    ]
}
```

### Running only the Data Services

A functional `docker-compose-lean.yml` with all services necessary to run the `terarium` backend can be spun up with the following:

```shell
docker compose --file containers/docker-compose-lean.yml pull
docker compose --file containers/docker-compose-lean.yml up --detach --wait
```

This will standup a local `terarium` server on port `3000` supporting all data service endpoints.

The `terarium` backend uses `OAuth2.0` via `keycloak` for user authentication. In order to make calls to the data services simpler, a `service-user` can be used by providing a basic auth credential instead.

Please use the following basic auth credential if running `docker-compose-lean.yml`:

```
'Authorization: Basic YWRhbTphc2RmMUFTREY='
```

If you prefer the JSON request / response keys to be `snake_case` rather than `camelCase` include the following header in any data service request:

```
'X-Enable-Snake-Case'
```

If integrating the `docker-compose-lean.yml` into another repo, the following files and directory structure is expected:

```
- scripts
  - init.sql                     // initialize the postgres databases
  - realm
    - Terarium-realm.json        // keycloak realm definition
    - Terarium-users-0.json      // keycloak user definitions
- docker-compose-lean.yml
```

## Testing

## Debugging REST Api
### Swagger
For convenience, a [Swagger](https://swagger.io/) UI is provided to experiment with the API. With the server running
locally (eg, not via Docker), it can be accessed at [http://localhost:3000/swagger-ui/index.html](http://localhost:3000/swagger-ui/index.html).
To authorize requests, click the `Authorize` button and click `Authorize` on the modal that appears. You can enter the credentials
of the user you want to use to make requests.
Note: In order to "logout" from Swagger, you will need to clear your browser's cookies.
### Postman
A Postman collection can be imported via the OpenAPI specification at [http://localhost:3000/v3/api-docs](http://localhost:3000/v3/api-docs).
In Postman:
1. Click the `Import` button at the top left of the Postman window
2. Paste in the the URL above and click `Continue`
3. Click `Import` and you should have a new collection named `Terarium APIs`
4. Click on the collection and click on the `Authorization` tab
5. Ensure the `Client ID` is `app` and the `Authorize using browser` checkbox is checked

### Running the Client Tests

```shell
yarn workspace hmi-client run test
```

### Running the Server Tests

```shell
./gradlew test
```

## Contributing

Please see further documentation in the [Terarium Contributing Guide](.github/CONTRIBUTING.md)

## Conventional Commits

This repository follows the [Conventional Commits Specification](https://conventionalcommits.org/)
using [CommitLint](https://github.com/conventional-changelog/commitlint) to validate the commit message on the PR. If
the message does not conform to the specification the PR will not be allowed to be merged.

This automatic check is done through the use of CI workflows on GitHub defined
in [commitlint.yaml](.github/workflows/commitlint.yaml). It uses the configuration from
the [Commitlint Configuration File](.commitlintrc.yaml).

> Currently the CI configuration is set to check only the PR message as the commits are being squashed. If this ever
> changes and all commits need to be validated then appropriate changes (as commented) in
> the [commitlint.yaml](..github/workflows/commitlint.yaml) should be made.

## License

[Apache License 2.0](LICENSE)


![BYU Logo](byuLogo.png)

# BYU **Advanced Software Construction** `cs240`

![cover](softwareconstructioncover.jpg)

## Welcome

Advanced Software Construction provides you with the experience and skills necessary to use a modern programming language in an advanced development environment to design, test, and build a large multi-user application. Your application will have a client frontend program that communicates, over the network, with a centralized backend server.

The content for this course is represented by the following parts.

- [Instruction](instruction/modules.md#readme) - Course topics
- [Chess](chess/chess.md#readme) - Instructions for building your application
- [Pet Shop](petshop/petshop.md) - Demonstration application
- **Canvas** - Submit assignments and tests

## Course Schedule

Although assignment due dates are the same for all sections, the lecture schedule may vary by instructor.

- [Schedule for Professor Jensen's Sections](https://github.com/softwareconstruction240/softwareconstruction/blob/main/schedule/winter2024.md)
- [Schedule for Dr. Rodham's Sections](https://github.com/softwareconstruction240/softwareconstruction/blob/main/schedule/summer2024-rodham.md)
- [Schedule for Dr. Wilkerson's Sections](https://github.com/softwareconstruction240/softwareconstruction/blob/main/schedule/spring2024-wilkerson.md)

## Outcomes

By the end of the course you should have experienced the following outcomes.

- Learn to construct a medium-scale server program with data persistence in a principled way by applying relevant engineering techniques such as up-front design, quality code construction, unit testing, assertions, and error handling.
- Learn and apply basic software design principles such as single responsibility, low coupling, avoidance of code duplication and information/data hiding to create modular code.
- Learn and apply the basics of relational database design, modeling and programmatic access.
- Learn and apply basic security principles and concepts.
- Learn to validate a program’s behavior against its specification using testing practices.
- Use modern software tools including integrated development environments, testing frameworks, debuggers, version control, and documentation processing tools.

## Technologies

The course covers a full software stack of technologies and topics.

- Command console
- Java
- HTTP
- Web Services
- Data Services demonstrated with MySQL
- Realtime peer to peer interaction with WebSocket
- Security
- Testing
- Application design

_Image Source: [Christina Morillo](https://www.pexels.com/photo/close-up-photo-of-person-typing-on-laptop-1181675/)_


<!--

    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.

-->

[English](./README.md) | [中文](./README-zh.md)
# TsFile Document
<pre>
___________    ___________.__.__
\__    ___/____\_   _____/|__|  |   ____
  |    | /  ___/|    __)  |  |  | _/ __ \
  |    | \___ \ |     \   |  |  |_\  ___/
  |____|/____  >\___  /   |__|____/\___  >  version 1.0.0
             \/     \/                 \/
</pre>
[![Maven Version](https://maven-badges.herokuapp.com/maven-central/org.apache.tsfile/tsfile-parent/badge.svg)](http://search.maven.org/#search|gav|1|g:"org.apache.tsfile")

## Introduction

TsFile is a columnar storage file format designed for time series data, which supports efficient compression, high throughput of read and write, and compatibility with various frameworks, such as Spark and Flink. It is easy to integrate TsFile into IoT big data processing frameworks.

Time series data is becoming increasingly important in a wide range of applications, including IoT, intelligent control, finance, log analysis, and monitoring systems.

TsFile is the first existing standard file format for time series data. Despite the widespread presence and significance of temporal data, there has been a longstanding absence of standardized file formats for its management. The advent of TsFile introduces a unified file format to facilitate users in managing temporal data.

[Click for More Information](https://www.timecho-global.com/archives/apache-tsfile-time-series-data-storage-redefined)

## TsFile Features

TsFile offers several distinctive features and benefits:

- Mutil Language Independent Use: Multiple language SDK can be used to directly read and write TsFile, making it possible for some lightweight data reading and writing scenarios.

- Efficient Writing and Compression: A column storage format tailored for time series, organizing data by device and ensuring continuous storage of data for each sequence, minimizing storage space. Compared to CSV, the compression ratio can be increased by more than 90%.

- High Query Performance: By indexing devices, measurement, and time dimensions, TsFile implements fast filtering and querying of temporal data based on specific time ranges. Compared to general file formats, query throughput can be increased by 2-10 times.

- Open Integration: TsFile is the underlying storage file format of the temporal database IoTDB, which can form a pluggable storage computing separation architecture with IoTDB. TsFile supports compatibility with Spark Flink and other big data software establish seamless ecosystem integration to ensure compatibility and interoperability across different data processing environments, and achieve deep analysis of temporal data across ecosystems.

## TsFile Basic Concepts

TsFile can manage the time series data of multiple devices. Each device can have different measurement.

Each measurement of each device corresponds to a time series.

The TsFile Scheme defines a set of measurement for all devices, as shown in the table below (m1~m5)

| Time | deviceId | m1 | m2 | m3 | m4 | m5 |
|------|----------|----|----|----|----|----|
| 1    | device1  | 1  | 2  | 3  |    |    |
| 2    | device1  | 1  | 2  | 3  |    |    |
| 3    | device2  | 1  |    | 3  | 4  | 5  |
| 4    | device2  | 1  |    | 3  | 4  | 5  |
| 5    | device3  | 1  | 2  | 3  | 4  | 5  |

Among them, Time and deviceId are built-in fields that do not need to be defined and can be written directly.

## TsFile Design

### File Structure

TsFile adopts a columnar storage design, similar to other file formats, primarily to optimize time-series data's storage efficiency and query performance. This design aligns with the nature of time series data, which often involves large volumes of similar data types recorded over time. However, TsFile was developed particularly with a structure of page, chunk, chunk group, and index:

- Page: The basic unit for storing time series data, sorted by time in ascending order with separate columns for timestamps and values.

- Chunk: Comprising metadata headers and several pages, each chunk belongs to one time series, with variable sizes allowing for different compression and encoding methods.

- Chunk Group: Multiple chunks within a chunk group belong to one or multiple series of a device written in the same period, facilitating efficient query processing.

- Index: The file metadata at the end of TsFile contains a chunk-level index and file-level statistics for efficient data access.

![TsFile Architecture](https://alioss.timecho.com/docs/img/tsfile.jpeg)

## Encoding and Compression

TsFile employs advanced encoding and compression techniques to optimize storage and access for time series data. It uses methods like run-length encoding (RLE), bit-packing, and Snappy for efficient compression, allowing separate encoding of timestamp and value columns for better data processing. Its unique encoding algorithms are designed specifically for the characteristics of time series data in IoT scenarios, focusing on regular time intervals and the correlation among series.

Its uniqueness lies in the encoding algorithm designed specifically for time series data characteristics, focusing on the correlation between time attributes and data.

The table below compares 3 file formats in different dimensions.

TsFile, CSV and Parquet in Comparison

| Dimension       | TsFile       | CSV   | Parquet |
|-----------------|--------------|-------|---------|
| Data Model      | IoT          | Plain | Nested  |
| Write Mode      | Tablet, Line | Line  | Line    |
| Compression     | Yes          | No    | Yes     |
| Read Mode       | Query, Scan  | Scan  | Query   |
| Index on Series | Yes          | No    | No      |
| Index on Time   | Yes          | No    | No      |

Its development facilitates efficient data encoding, compression, and access, reflecting a deep understanding of industry needs, pioneering a path toward efficient, scalable, and flexible data analytics platforms.

| Data Type    | Recommended Encoding       | Recommended Compression |
|---------|------------|--------|
| INT32   | TS_2DIFF   | LZ4    |
| INT64   | TS_2DIFF   | LZ4    |
| FLOAT   | GORILLA    | LZ4    |
| DOUBLE  | GORILLA    | LZ4    |
| BOOLEAN | RLE        | LZ4    |
| TEXT    | DICTIONARY | LZ4    |

more see [Docs](https://iotdb.apache.org/UserGuide/latest/Basic-Concept/Encoding-and-Compression.html)

## Build and Use TsFile

[Java](./java/tsfile/README.md)

[C++](./cpp/tsfile/README.md)


# DEPRECATION NOTICE
Pi4J Version 1.x is now DEPRECATED and thus this repository is archived. [Pi4J V2.0](https://github.com/Pi4J/pi4j-v2) is the version to use for newer JDKs and Raspberry Pis. Look here for more information: https://pi4j.com/about/new-in-v2/

 Pi4J :: Java I/O Library for Raspberry Pi
==========================================================================
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.pi4j/pi4j-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.pi4j/pi4j-core)
![Snyk Security Badge](https://snyk-widget.herokuapp.com/badge/mvn/com.pi4j/pi4j-core/badge.svg)

## PROJECT INFORMATION
Project website: https://pi4j.com/

Pi4J Community Forum (*new*): https://forum.pi4j.com/

Version 2.0 Project Discussions (*new*): https://forum.pi4j.com/category/6/version-2-0

Project issues list: https://github.com/Pi4J/pi4j/issues

Release builds are available from:
   *  [Maven Central] http://search.maven.org/#search%7Cga%7C1%7Ccom.pi4j
   *  [Downloads] https://pi4j.com/download

Snapshot builds are available from:
   *  [Sonatype OSS] https://oss.sonatype.org/index.html#nexus-search;quick~pi4j
   *  [Downloads] https://pi4j.com/download

Copyright (C) 2012-2021 Pi4J

## LICENSE

 Pi4J Version 1.4 and later is 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.

## PROJECT OVERVIEW

  Starting with the Pi4J 1.4 builds, the Pi4J project is prioritizing focus
  on providing Java programs access, control and communication with the core
  I/O capabilities of the Raspberry Pi platform.  Earlier versions of Pi4J
  were perhaps too ambitious in scope and that led to significant project
  bloat to the point that the project was becoming unsustainable.  The goal
  moving forward is to limit scope to that of the raw I/O capabilities
  of the Raspberry Pi platform and provide timely updates and releases for
  bug fixes and new RaspberryPi model introductions.  Reducing the scope of
  the project should better serve the Java community for basic I/O access by
  reducing complexity.

  The following features have been removed from the Pi4J library:

  * **IO Expanders** -- IO expansion is still supported but concrete
  implementations should be provided outside the core Pi4J core project such
  that they can be maintained and extended independently.

  * **Other Platforms** -- Other platforms such as Odroid, BananaPi, NanoPi,
  OrangePi, etc. have been removed and will no longer be supported.  The
  challenge with supporting these additional platforms is that Pi4J depends on
  the underlying WiringPi project and WiringPi ports for these other platforms
  is not well supported by the various SoC vendors or community.  The various
  WiringPi ports for these other platforms are also inconsistent causing
  inconsistent features and functionality of Pi4J.  Additionally, regression
  testing of bug fixes and new features in Pi4J is compounded with each
  additional supported platform.

  * **Components & Devices** -- Pi4J originally provided higher level
  interfaces for components and devices that provided an abstraction
  layer between real world devices (things) and lower-level I/O interfaces.
  While a noble goal, unfortunately this part of the project never received
  the attention and time that it deserved and never gained much adoption
  by the community.  We are removing these to allow Pi4J to focus solely on
  the raw I/O supported by the Raspberry Pi platform.

## KNOWN ISSUES

  *  The original WiringPi library has been **DEPRECATED**. \
     _(See: http://wiringpi.com/wiringpi-deprecated/)_

     > **NOTE:**  To support RaspberryPi 4B and newer systems you must install the latest *unofficial* WiringPi version which is
     maintained here: https://github.com/WiringPi/WiringPi.  _(As of 2021-01-12, this is version 2.60.)_

     Example installation commands on a RaspberryPi:
     ```
     sudo apt-get remove wiringpi -y
     sudo apt-get --yes install git-core gcc make
     cd ~
     git clone https://github.com/WiringPi/WiringPi --branch master --single-branch wiringpi
     cd ~/wiringpi
     sudo ./build
     ```
  *  Please note that the Pi4J v1.x codebase is no longer being actively developed. Pi4J v1.x will only be maintained
     and updated for major bug fixes. This codebase has been largely stable for several years and is compatible across
     a wide variety of Raspberry Pi SoCs and you are welcome to continue using it.  However, for new projects, it
     is highly recommended to migrate to the Pi4J Version 2.x codebase.  See https://v2.pi4j.com for more information.

  *  This project requires Java 11 (JDK) to build; however, it fails to compile using the following Oracle JDKs.  The
     project will successfully compile using OpenJDK, Liberica, Zulu and AdoptOpenJDK distributions.
     - Oracle JDK 11.0.06
     - Oracle JDK 11.0.07
     - Oracle JDK 11.0.09
     - Oracle JDK 11.0.10
     - Oracle JDK 11.0.10 (_and possibly newer_)

     \
     Example installation command on a RaspberryPi:
     ```
     sudo apt-get install openjdk-11-jdk
     ```

## Building

Please see the [BUILD.md](BUILD.md) instructions for details on how to compile/build this project.

## CURRENT RELEASE

2021-03-01 :: 1.4

  * Changed project to Apache License, Version 2.0
  * Added support for 64-bit architecture.
  * Bug Fixes: https://github.com/Pi4J/pi4j/milestone/9?closed=1
  * Removed `pi4j-device` library.  _(See comments above)_
  * Removed `pi4j-gpio-extension` library.  _(See comments above)_
  * Removed platform support for `Odroid`.  _(See comments above)_
  * Removed platform support for `BananaPi`.  _(See comments above)_
  * Removed platform support for `BPi`.  _(See comments above)_
  * Removed platform support for `NanoPi`.  _(See comments above)_
  * Removed platform support for `OrangePi`.  _(See comments above)_

## PREVIOUS RELEASES

For previous 1.x release notes and source code, please see the 1.x branch
or release tags in the source repository:

  * **Releases**: https://github.com/Pi4J/pi4j/releases
  * **Source Code**: https://github.com/Pi4J/pi4j/branches


# Serverless Java container [![Build Status](https://github.com/aws/serverless-java-container/workflows/Continuous%20Integration/badge.svg)](https://github.com/aws/serverless-java-container/actions) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.amazonaws.serverless/aws-serverless-java-container/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.amazonaws.serverless/aws-serverless-java-container) [![Help](http://img.shields.io/badge/help-gitter-E91E63.svg?style=flat-square)](https://gitter.im/aws/serverless-java-container)
The `aws-serverless-java-container` makes it easy to run Java applications written with frameworks such as [Spring](https://spring.io/), [Spring Boot](https://projects.spring.io/spring-boot/), [Apache Struts](http://struts.apache.org/), [Jersey](https://jersey.java.net/), or [Spark](http://sparkjava.com/) in [AWS Lambda](https://aws.amazon.com/lambda/).

Serverless Java Container natively supports API Gateway's proxy integration models for requests and responses, you can create and inject custom models for methods that use custom mappings.

Currently the following versions are maintained:

| Version | Branch | Java Enterprise support | Spring versions | JAX-RS/ Jersey version | Struts support | Spark support |
|---------|--------|-------------------------|-----------------|------------------------|----------------|---------------|
| 1.x                      | [1.x](https://github.com/aws/serverless-java-container/tree/1.x)    | Java EE (javax.*)       | 5.x (Boot 2.x)  | 2.x                    | :white_check_mark: | :white_check_mark: |
| 2.x     | [main](https://github.com/aws/serverless-java-container/tree/main)   | Jakarta EE (jakarta.*)  | 6.x (Boot 3.x)  | 3.x                    | :x:            | :x:           |

Follow the quick start guides in [our wiki](https://github.com/aws/serverless-java-container/wiki) to integrate Serverless Java Container with your project:
* [Spring quick start](https://github.com/aws/serverless-java-container/wiki/Quick-start---Spring)
* [Spring Boot 2 quick start](https://github.com/aws/serverless-java-container/wiki/Quick-start---Spring-Boot2)
* [Spring Boot 3 quick start](https://github.com/aws/serverless-java-container/wiki/Quick-start---Spring-Boot3)
* [Apache Struts quick start](https://github.com/aws/serverless-java-container/wiki/Quick-start---Struts)
* [Jersey quick start](https://github.com/aws/serverless-java-container/wiki/Quick-start---Jersey)
* [Spark quick start](https://github.com/aws/serverless-java-container/wiki/Quick-start---Spark)

Below is the most basic AWS Lambda handler example that launches a Spring application. You can also take a look at the [samples](https://github.com/aws/serverless-java-container/tree/master/samples) in this repository, our main wiki page includes a [step-by-step guide](https://github.com/aws/serverless-java-container/wiki#deploying-the-sample-applications) on how to deploy the various sample applications using Maven and [SAM](https://github.com/awslabs/serverless-application-model).

```java
public class StreamLambdaHandler implements RequestStreamHandler {
    private static final SpringLambdaContainerHandler<AwsProxyRequest, AwsProxyResponse> handler;

    static {
        try {
            handler = SpringLambdaContainerHandler.getAwsProxyHandler(PetStoreSpringAppConfig.class);
        } catch (ContainerInitializationException e) {
            // if we fail here. We re-throw the exception to force another cold start
            e.printStackTrace();
            throw new RuntimeException("Could not initialize Spring framework", e);
        }
    }

    @Override
    public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context)
            throws IOException {
        handler.proxyStream(inputStream, outputStream, context);
    }
}
```

## Public Examples

### Blogs

- [Re-platforming Java applications using the updated AWS Serverless Java Container](https://aws.amazon.com/blogs/compute/re-platforming-java-applications-using-the-updated-aws-serverless-java-container/)

### Workshops

- [Java on AWS Lambda](https://catalog.workshops.aws/java-on-aws-lambda) From Serverful to Serverless Java with AWS Lambda in 2 hours

### Videos

- [Spring on AWS Lambda](https://www.youtube.com/watch?v=A1rYiHTy9Lg&list=PLCOG9xkUD90IDm9tcY-5nMK6X6g8SD-Sz) YouTube Playlist from [@plantpowerjames](https://twitter.com/plantpowerjames)

### Java samples with different frameworks

- [Dagger, Micronaut, Quarkus, Spring Boot](https://github.com/aws-samples/serverless-java-frameworks-samples/)


[![Badge License]][License]
[![Badge Crowdin]][Crowdin]

![Banner]

*A mod that adds many useful extensions to **[ComputerCraft]**

and aims to add features that were available in `1.12.2`

mods like **[PeripheralsPlusOne]**.*

[![Button CurseForge]][CurseForge]
[![Button Discord]][Discord]
[![Button Documentation]][Documentation]

## Contributing
Contributions to the project are always welcome!

Read our [Contribution](CONTRIBUTING.md) Guidelines to get started.

## Translating

All translation is done via **[Crowdin]**, as such we

will close pull requests related to translations.

[![Badge Localized]][Crowdin]

## Credits

[@Srendi]

    ***Author***

[@SirEdvin] , [@Olfi01]

    ***Contributor***

[@FatalMerlin]

    ***Ingame Guide + Minor Bug Fixes***

**[Many Other Contributor][Contributors]**

    ❣

[Documentation]: https://advancedperipherals.madefor.cc/
[Contributors]: https://github.com/IntelligenceModding/AdvancedPeripherals/graphs/contributors
[CurseForge]: https://www.curseforge.com/minecraft/mc-mods/advanced-peripherals
[Actions]: https://github.com/IntelligenceModding/AdvancedPeripherals/actions
[Crowdin]: https://crowdin.com/project/advanced-peripherals
[Discord]: https://discord.intelligence-modding.de
[Banner]: https://www.bisecthosting.com/images/CF/Advanced_Peripherals/BH_AP_Header.png 'Advanced Peripherals'

[PeripheralsPlusOne]: https://github.com/rolandoislas/PeripheralsPlusOne
[ComputerCraft]: https://www.curseforge.com/minecraft/mc-mods/computercraft

[@FatalMerlin]: https://github.com/FatalMerlin
[@SirEdvin]: https://github.com/SirEdvin
[@Srendi]: https://github.com/IntelligenceModding
[@Olfi01]: https://github.com/Olfi01

[License]: LICENSE

[Badge Localized]: https://badges.crowdin.net/advanced-peripherals/localized.svg
[Badge Crowdin]: https://img.shields.io/badge/Localized_On-Crowdin-373d4c?style=for-the-badge&labelColor=464e62&logoColor=white&logo=Crowdin
[Badge License]: https://img.shields.io/badge/License-Apache_2.0-961b1f?style=for-the-badge&labelColor=D22128&logoColor=white&logo=Apache

[Button Documentation]: https://img.shields.io/badge/Documentation-5abcff?style=for-the-badge&logoColor=white&logo=GitBook
[Button CurseForge]: https://img.shields.io/badge/CurseForge-6441A4?style=for-the-badge&logoColor=white&logo=CurseForge
[Button Discord]: https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logoColor=white&logo=Discord


> _This repository is maintained by the Develocity Solutions team, as one of several publicly available repositories:_
> - _[Develocity Build Configuration Samples][develocity-build-config-samples] (this repository)_
> - _[Develocity Build Validation Scripts][develocity-build-validation-scripts]_
> - _[Develocity Open Source Projects][develocity-oss-projects]_
> - _[Common Custom User Data Maven Extension][ccud-maven-extension]_
> - _[Common Custom User Data Gradle Plugin][ccud-gradle-plugin]_
> - _[Common Custom User Data sbt Plugin][ccud-sbt-plugin]_
> - _[Android Cache Fix Gradle Plugin][android-cache-fix-plugin]_

# Develocity Build Configuration Samples

[![Revved up by Develocity](https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.solutions-team.gradle.com/scans)

This repository contains samples that demonstrate how to customize and optimize your Develocity build configuration using Gradle or Maven.

The samples aim to demonstrate customizations, optimizations, API usages, as well as patterns for applying and reusing Develocity build configuration across multiple projects.

## Samples

The samples can be grouped into the following categories:

 - Configuration snippets to capture additional data in build scans
 - Configuration snippets to optimize build performance
 - Template projects for Gradle and Maven when using Develocity
 - Scripts and code to apply and reuse Develocity across multiple projects

## Learn more

Visit our website to learn more about [Develocity][develocity].

## License

The Develocity build configuration samples are open-source software released under the [Apache 2.0 License][apache-license].

[develocity-build-config-samples]: https://github.com/gradle/develocity-build-config-samples
[develocity-build-validation-scripts]: https://github.com/gradle/gradle-enterprise-build-validation-scripts
[develocity-oss-projects]: https://github.com/gradle/develocity-oss-projects
[ccud-gradle-plugin]: https://github.com/gradle/common-custom-user-data-gradle-plugin
[ccud-maven-extension]: https://github.com/gradle/common-custom-user-data-maven-extension
[ccud-sbt-plugin]: https://github.com/gradle/common-custom-user-data-sbt-plugin
[android-cache-fix-plugin]: https://github.com/gradle/android-cache-fix-gradle-plugin
[develocity]: https://gradle.com/develocity
[apache-license]: https://www.apache.org/licenses/LICENSE-2.0.html


# GLIDE for Redis
General Language Independent Driver for the Enterprise (GLIDE) for Redis, is an AWS-sponsored, open-source Redis client. GLIDE for Redis works with any Redis distribution that adheres to the Redis Serialization Protocol (RESP) specification, including open-source Redis, Amazon ElastiCache for Redis, and Amazon MemoryDB for Redis.
Strategic, mission-critical Redis-based applications have requirements for security, optimized performance, minimal downtime, and observability.  GLIDE for Redis is designed to provide a client experience that helps meet these objectives. It is sponsored and supported by AWS, and comes pre-configured with best practices learned from over a decade of operating Redis-compatible services used by hundreds of thousands of customers. To help ensure consistency in development and operations, GLIDE for Redis is implemented using a core driver framework, written in Rust, with extensions made available for each supported programming language. This design ensures that updates easily propagate to each language and reduces overall complexity. In this Preview release, GLIDE for Redis is available for Python and Javascript (Node.js), with support for Java actively under development.

## Supported Redis Versions
GLIDE for Redis is API-compatible with open source Redis version 6 and 7.

## Current Status
We've made GLIDE for Redis an open-source project, and are releasing it in Preview to the community to gather feedback, and actively collaborate on the project roadmap. We welcome questions and contributions from all Redis stakeholders.
This preview release is recommended for testing purposes only. It is available in Python and Javascript (Node.js), with Java to follow. We're tracking its production readiness and future features on the [roadmap](https://github.com/orgs/aws/projects/187/).

## Getting Started

-   [Node](./node/README.md)
-   [Python](./python/README.md)
-   [Documentation](https://github.com/aws/glide-for-redis/wiki)

## Getting Help
If you have any questions, feature requests, encounter issues, or need assistance with this project, please don't hesitate to open a GitHub issue. Our community and contributors are here to help you. Before creating an issue, we recommend checking the [existing issues](https://github.com/aws/glide-for-redis/issues) to see if your question or problem has already been addressed. If not, feel free to create a new issue, and we'll do our best to assist you. Please provide as much detail as possible in your issue description, including:

1. A clear and concise title
2. Detailed description of the problem or question
3. A reproducible test case or series of steps
4. The GLIDE for Redis version in use
5. Operating system
6. Redis version
7. Redis cluster information, cluster topology, number of shards, number of replicas, used data types
8. Any modifications you've made that are relevant to the issue
9. Anything unusual about your environment or deployment
10. Log files

## Contributing

GitHub is a platform for collaborative coding. If you're interested in writing code, we encourage you to contribute by submitting pull requests from forked copies of this repository. Additionally, please consider creating GitHub issues for reporting bugs and suggesting new features. Feel free to comment on issues that interest. For more info see [Contributing](./CONTRIBUTING.md).

## License
* [Apache License 2.0](./LICENSE)


[![Coverage Status](https://codecov.io/gh/koupleless/koupleless/branch/main/graph/badge.svg)](https://codecov.io/gh/koupleless/koupleless/branch/main/graph/badge.svg)
![license](https://img.shields.io/badge/license-Apache--2.0-green.svg)
![Maven Central](https://img.shields.io/maven-central/v/com.alipay.sofa.koupleless/koupleless-runtime)

Koupleless: Modular Development Framework and Operation Platform

English | [简体中文](./README-zh_CN.md)

Would you like your application to start in just 10 seconds, consuming only 20MB of memory? Have you encountered issues with large applications causing collaboration bottlenecks and low release efficiency? Are you struggling with the high resource and maintenance costs associated with numerous small applications? If you're facing these challenges, then Koupleless might be the solution you're looking for. Koupleless approaches application architecture from a modular perspective, offering an extremely low-cost solution to address pain points encountered throughout the entire lifecycle of application development, operation, and execution:

1. Excessive application fragmentation leading to high machine and long-term maintenance costs
2. Insufficient application fragmentation causing collaboration bottlenecks
3. Lengthy application build, startup, and deployment times resulting in low iteration efficiency
4. Severe fragmentation of SDK versions with high upgrade costs and long cycles
5. High costs associated with building platforms and middle platforms, as well as difficulties in business asset precipitation and architectural constraints
6. Long microservice chains leading to poor call performance
7. High costs associated with microservice decomposition and evolution

How does Koupleless address these issues? Koupleless vertically and horizontally splits traditional applications, with the vertical split separating the base and the horizontal split separating multiple modules. The base shields modules from infrastructure concerns, while modules contain only the business-specific portion, enabling quick startup and insulating them from infrastructure concerns, allowing module developers to experience a Serverless-like environment. Koupleless thus evolves into a low-cost, Serverless solution by refining the granularity of development and operations while shielding infrastructure. For detailed explanations of the principles, please refer to the official website.
Further detailed explanations of the principles are available on [the official website](https://koupleless.gitee.io/docs/introduction/architecture/arch-principle/).

![image](https://github.com/koupleless/koupleless/assets/3754074/004c0fa5-62f6-42d7-a77e-f7152ac89248)

The most important aspect is that Koupleless can **assist existing applications** in evolving into a modular development model **at an extremely low cost**, addressing the aforementioned issues and helping businesses reduce costs, increase efficiency, and enhance competitiveness.

## The Advantages of Koupleless

Koupleless is a mature development framework and operational scheduling platform capability that has been refined internally within Ant Group for 5 years. Compared to traditional image-based application models, it offers approximately 10 times improvement in development, operations, and runtime calling. Summarized into 5 key features: Fast, Cost-efficient, Flexible deployment, Smooth evolution, and Production-scale validation.

Here are performance data comparing modular development and deployment with traditional image-based approaches for an actual production application.

## What is a Module?

Modules utilize extreme sharing and isolation technologies, which enable hot deployment (updating online code without restarting the machine).

Isolation is achieved through ClassLoader class isolation based on [SOFAArk](https://github.com/sofastack/sofa-ark) and object isolation based on [SpringBoot SpringContext](https://github.com/spring-projects/spring-boot).

Sharing is facilitated by class delegation loading based on [SOFAArk](https://github.com/sofastack/sofa-ark) and cross-SpringContext object lookup and invocation based on SpringBootManager.

So, in physical terms, a module can be considered as one ClassLoader + one SpringContext.

## What is the Base？
The base is just a regular application, same with the original app (such as standard SpringBoot).

## Quick start
Please check [the official website Quick Start](https://koupleless.gitee.io/docs/quick-start/).

<video width=100% controls autoplay>
<source src="https://koupleless.oss-cn-shanghai.aliyuncs.com/outer-materials/docs/videos/module_dev_and_deploy.mp4" type="video/mp4">
Your browser does not support the video tag.
</video>

## Koupleless Components

![image](https://github.com/sofastack/sofa-serverless/assets/101314559/995f1e17-f3be-4672-b1b8-c0c041590fb0)

## Contributing
We appreciate anyone who contribute here together. Please scan the QR code to join the developer collaboration group.

| IAM                        | number      | QR code                                                                                |
|----------------------------|-------------|----------------------------------------------------------------------------------------------------------------------------------|
| DingTalk group (recommand) | 24970018417 |  |
| WeChat                     | zzl_ing     |  |

## Long-term planning and our vision
We hope to further refine and open up these capabilities to be more extreme and applicable to a wider range of scenarios. Help more businesses solve application development problems, achieve cost reduction and efficiency improvement, and ultimately become an excellent research and development framework and solution for global green computing, achieving:

1. Speed as you need
2. Pay as you need
3. Deploy as you need
4. Evolution as you need