teamcity-build-scan-plugin
==========================

> The work on this software project is in no way associated with my employer nor with the role I'm having at my employer. Any requests for changes will be decided upon exclusively by myself based on my personal preferences. I maintain this project as much or as little as my spare time permits.

# Overview

[TeamCity](https://www.jetbrains.com/teamcity/) plugin that integrates with the Build Scan service and more generally with Develocity for Gradle and Maven builds run via TeamCity. Build scans are available as a free service on [scans.gradle.com](https://scans.gradle.com/) and commercially via [Develocity](https://gradle.com/enterprise).

For each Gradle and Maven build that is run from TeamCity, this plugin exposes the links to the created build scans in the TeamCity UI. The plugin can also be configured to ad-hoc connect Gradle and Maven builds to an existing Develocity instance such that a Build Scan is published each time a build is run from TeamCity.

The plugin is available from the [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/9326-integration-for-gradle-and-maven-build-scans).

## Build Scan

Recent Build Scan: https://gradle.com/s/yevfzaz2bvvh4

Find out more about Build Scan for Gradle and Maven at https://scans.gradle.com and https://gradle.com.

# Installation

## Option 1: Conveniently select plugin

1. Go to the plugin list of your TeamCity installation at `<TeamCityInstanceRootUrl>/admin/admin.html?item=plugins` and browse the plugins repository.

2. Select, install, and activate the plugin as described [here](https://www.jetbrains.com/help/teamcity/installing-additional-plugins.html#Installing+a+plugin+from+JetBrains+Plugins+repository).

## Option 2: Manually upload plugin

1. Download the plugin `.zip` file from [https://plugins.jetbrains.com/plugin/9326-integration-for-gradle-and-maven-build-scans](https://plugins.jetbrains.com/plugin/9326-integration-for-gradle-and-maven-build-scans).

2. Go to the plugin list of your TeamCity installation at `<TeamCityInstanceRootUrl>/admin/admin.html?item=plugins` and click on the link _Upload plugin zip_ to install the previously downloaded plugin `.zip` file.

3. Restart TeamCity.

# Integrations

## Build Scan links surfacing

### Gradle builds

If you use TeamCity's _Gradle_ runner to launch your Gradle builds, there is nothing special to do.

If you use TeamCity's _Command Line_ runner to launch your Gradle builds, you can opt in to enable build scan detection using the `buildScanPlugin.command-line-build-step.enabled` configuration parameter.

If the first two mechanisms will not work for your Gradle build configurations, you can still get integration with build scans, but it requires your build logs being parsed for build scan links. In case of huge build logs, this can put a significant toll on the performance of your TeamCity instance. You can enable the parsing of the build logs by setting the `buildScanPlugin.log-parsing.enabled` configuration parameter to _true_.

### Maven builds

If you use TeamCity's _Maven_ runner to launch Maven builds, there is nothing special to do.

If you use TeamCity's _Command Line_ runner to launch your Maven builds, you can opt in to enable build scan detection using the `buildScanPlugin.command-line-build-step.enabled` configuration parameter.

If the first two mechanisms will not work for your Maven build configurations, you can still get integration with build scans, but it requires your build logs being parsed for build scan links. In case of huge build logs, this can put a significant toll on the performance of your TeamCity instance. You can enable the parsing of the build logs by setting the `buildScanPlugin.log-parsing.enabled` configuration parameter to _true_.

## Develocity connectivity

You can ad-hoc connect Gradle and Maven builds to an existing Develocity instance by automatically injecting the [Develocity Gradle plugin](https://docs.gradle.com/enterprise/gradle-plugin/) and the [Develocity Maven extension](https://docs.gradle.com/enterprise/maven-extension/) when these builds are run via TeamCity's _Gradle_ or _Maven_ runner. If a Gradle or Maven build is run via TeamCity's _Command Line_ runner the auto-injection can be opted in to, too. If a given build is already connected to Develocity, the auto-injection is skipped.

The same auto-injection behavior is available for the [Common Custom User Data Gradle plugin](https://github.com/gradle/common-custom-user-data-gradle-plugin) and the [Common Custom User Data Maven extension](https://github.com/gradle/common-custom-user-data-maven-extension).

The higher in TeamCity's project hierarchy the required configuration parameters are applied, the more widely they apply since the configuration parameters are passed on to all child projects. Child projects can override the configuration parameters of their parent projects and even disable the auto-injection by setting the appropriate configuration parameters to empty values.

For convenience, the configuration parameter values can be defined through a form describing a Develocity connection. Alternatively, the configuration parameter values can be defined as TeamCity configuration parameters.

### Configuration via TeamCity connection

A Develocity connection can be created in the Connections section of the configuration of a given project. In the Add Connection dropdown, select the Develocity connection type.

Fill out the Add Connection dialog with the URL for the Develocity instance, the plugin and extension versions to be applied, and any other fields as needed. Some values, such as the plugin and extension versions, will be pre-populated.

A Develocity connection can be created on any project and is automatically inherited by all its child projects.

Click for an example configuration.

### Configuration via TeamCity configuration parameters

As an alternative to the configuration via a TeamCity connection, you can describe the configuration via TeamCity configuration parameters on a given project.

The TeamCity configuration parameters can be set on any project and are automatically inherited by all its child projects.

Click for an example configuration.

#### Gradle Builds

1. In TeamCity, on the build configuration for which you want to apply Develocity, create three configuration parameters:

   - `buildScanPlugin.gradle-enterprise.url` - the URL of the Develocity instance to which to publish build scans
   - `buildScanPlugin.gradle-enterprise.plugin.version` - the version of the [Develocity Gradle plugin](https://docs.gradle.com/enterprise/gradle-plugin/) to apply
   - `buildScanPlugin.ccud.plugin.version` - the version of the [Common Custom User Data Gradle plugin](https://github.com/gradle/common-custom-user-data-gradle-plugin) to apply (optional)

2. If required, provide additional configuration parameters for your environment (optional):

    - `buildScanPlugin.gradle-enterprise.allow-untrusted-server` - allow communication with an untrusted server; set to _true_ if your Develocity instance is using a self-signed certificate
    - `buildScanPlugin.gradle-enterprise.enforce-url` - enforce the configured Develocity URL over a URL configured in the project's build; set to _true_ to enforce publication of build scans to the configured Develocity URL
    - `buildScanPlugin.gradle.plugin-repository.url` - the URL of the repository to use when resolving the Develocity and CCUD plugins; required if your TeamCity agents are not able to access the Gradle Plugin Portal
    - `buildScanPlugin.command-line-build-step.enabled` - enable Develocity integration for _Command Line_ build steps; by default only steps using the _Gradle_ runner are enabled

##### Example Gradle Configuration

#### Maven Builds

1. In TeamCity, on the build configuration for which you want to integrate Develocity, create three configuration parameters:

   - `buildScanPlugin.gradle-enterprise.url` - the URL of the Develocity instance to which to publish build scans
   - `buildScanPlugin.gradle-enterprise.extension.version` - the version of the [Develocity Maven extension](https://docs.gradle.com/enterprise/maven-extension/) to apply
   - `buildScanPlugin.ccud.extension.version` - the version of the [Common Custom User Data Maven extension](https://github.com/gradle/common-custom-user-data-maven-extension) to apply (optional)

2. If required, provide additional configuration parameters for your environment (optional):

    - `buildScanPlugin.gradle-enterprise.allow-untrusted-server` - allow communication with an untrusted server; set to _true_ if your Develocity instance is using a self-signed certificate
    - `buildScanPlugin.gradle-enterprise.enforce-url` - enforce the configured Develocity URL over a URL configured in the project's build; set to _true_ to enforce publication of build scans to the configured Develocity URL
    - `buildScanPlugin.gradle-enterprise.extension.custom.coordinates` - the coordinates of a custom extension that has a transitive dependency on the Develocity Maven Extension
    - `buildScanPlugin.ccud.extension.custom.coordinates` - the coordinates of a custom Common Custom User Data Maven Extension or of a custom extension that has a transitive dependency on it
    - `buildScanPlugin.command-line-build-step.enabled` - enable Develocity integration for _Command Line_ build steps; by default only steps using the _Maven_ runner are enabled

##### Example Maven Configuration

## Slack notifications (experimental)

1. In Slack, create a webhook and keep track of the created URL.

2. In TeamCity, on the build configuration for which you want to be notified about published build scans, create a configuration parameter with name `buildScanPlugin.slack-webhook.url` and the value being the URL of the webhook created in step #1.

3. Trigger your Gradle builds with build scans enabled.

4. Find a notification about the published build scans in the Slack channel configured in the webhook.

# Compatibility

## Build Scan links surfacing

The version of the Develocity Gradle plugin and the Develocity Maven extension that are applied to a build must meet a minimum version requirement for the link surfacing to work.

| TC Build Scan plugin version | Minimum supported Develocity Maven extension version | Minimum supported Develocity Gradle plugin version |
|------------------------------|------------------------------------------------------|----------------------------------------------------|
| 0.23+                        | 1.11                                                 | 3.0  (or Gradle Build Scan plugin 1.8)             |
| 0.22                         | 1.0                                                  | 3.0  (or Gradle Build Scan plugin 1.8)             |

## Develocity connectivity

The configured version of the Develocity Gradle plugin and the Develocity Maven extension that get automatically applied by the TeamCity Build Scan plugin must be compatible with the version of the Develocity server that the build is connecting to.

### Gradle builds

The compatibility of the specified version of the Develocity Gradle plugin with Develocity can be found [here](https://docs.gradle.com/enterprise/compatibility/#gradle_enterprise_gradle_plugin). The compatibility of the optionally specified version of the Common Custom User Data Gradle plugin with the Develocity Gradle plugin can be found [here](https://github.com/gradle/common-custom-user-data-gradle-plugin#version-compatibility).

### Maven builds

The compatibility of the specified version of the Develocity Maven extension with Develocity can be found [here](https://docs.gradle.com/enterprise/compatibility/#gradle_enterprise_compatibility_2). The compatibility of the optionally specified version of the Common Custom User Data Maven extension with the Develocity Maven extension can be found [here](https://github.com/gradle/common-custom-user-data-maven-extension#version-compatibility).

For Maven builds, the version of the Develocity Maven extension automatically applied by the TeamCity Build Scan plugin is currently bundled by the plugin and cannot be configured. This will change in a future version of this plugin.

Click for an overview of what Maven extension versions are bundled and injected.

| TC Build Scan plugin version | Injected Develocity Maven extension version | Injected Common CCUD Maven extension version |
|------------------------------|---------------------------------------------|----------------------------------------------|
| Next                         | 1.21.4                                      | 2.0                                          |
| 0.35                         | 1.18.1                                      | 1.12.2                                       |
| 0.34                         | 1.18                                        | 1.12.2                                       |
| 0.33                         | 1.16.1                                      | 1.11.1                                       |
| 0.32                         | 1.15.4                                      | 1.11.1                                       |
| 0.31                         | 1.15.3                                      | 1.11.1                                       |
| 0.30                         | 1.15.1                                      | 1.11                                         |
| 0.27 - 0.29                  | 1.14.3                                      | 1.10.1                                       |
| 0.25 - 0.26                  | 1.14.2                                      | 1.10.1                                       |
| 0.23 - 0.24                  | 1.14.1                                      | 1.10.1                                       |

# Feedback and Contributions

Both feedback and contributions are very welcome.

# Acknowledgements
+ [bigdaz](https://github.com/bigdaz) (several prs related to the Develocity integration)
+ [clayburn](https://github.com/clayburn) (several prs related to the Develocity integration)
+ [marcphilipp](https://github.com/marcphilipp) (pr #53 that adds Gradle 4/5 compatibility to the Develocity integration)
+ [ldaley](https://github.com/ldaley) (pr #53 that adds Gradle 4/5 compatibility to the Develocity integration)
+ [madlexa](https://github.com/madlexa) (pr #47 that adds TeamCity 2022.04 compatibility)
+ [facewindu](https://github.com/facewindu) (pr #21 that includes init script test coverage)
+ [dmitry-treskunov](https://github.com/dmitry-treskunov) (bug report and proposed fix)
+ [pbielicki](https://github.com/pbielicki) (pr #17 that adds a hint to the BuildScanServiceMessageMavenExtension @Component)
+ [jonnybbb](https://github.com/jonnybbb) (pr #14 and #15 that store build scan links under artifacts and clean up legacy data)
+ [davidburstromspotify](https://github.com/davidburstromspotify) (bug report and proposed fix)
+ [guylabs](https://github.com/guylabs) (pr #10 that provides support for the Develocity Gradle plugin)
+ [autonomousapps](https://github.com/autonomousapps) (pr #9 that provides build scans for Maven builds)
+ [mark-vieira](https://github.com/mark-vieira) (pr #6 that provides message service functionality)
+ [pavelsher](https://github.com/pavelsher) (several code pointers)

# License

This plugin is available under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html).

(c) by Etienne Studer


![WSO2 Integration Studio](gh-docs/images/integration-studio-logo.png?raw=true)

[![Build Status](https://travis-ci.org/wso2/devstudio-tooling-ei.svg?branch=master)](https://travis-ci.org/wso2/devstudio-tooling-ei)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/wso2/devstudio-tooling-ei/blob/master/LICENSE)
[<img src="https://img.shields.io/badge/Slack-@wso2--ei-blue">](https://ei-slack.wso2.com/)
[![Twitter](https://img.shields.io/twitter/follow/wso2.svg?style=social&label=Follow)](https://twitter.com/intent/follow?screen_name=wso2)

# WSO2 Integration Studio

WSO2 Integration Studio is a development environment used to design your integration scenarios and develop them. It can be used to develop services, features, and artifacts as well as manage their links and dependencies through a simplified graphical editor.
It provides inbuilt debugging and testing capabilities to troubleshoot and identify the integration aspects while creating the artifacts.
Furthermore, WSO2 Integration Studio offers different deployment approaches, including CAR (Carbon Application Archive) deployment, docker deployment, kubernetes deployment, WSO2 integration cloud deployment, etc., to cater your CI/CD (Continuous Integration/Continuous Development) requirements.

[![WSO2 Integration Studio](gh-docs/images/design-view-image.png?raw=true "WSO2 Integration Studio")](https://ei.docs.wso2.com/en/latest/micro-integrator/develop/WSO2-Integration-Studio/)

[Installation](https://ei.docs.wso2.com/en/latest/micro-integrator/develop/installing-WSO2-Integration-Studio/) |
[Documentation](https://ei.docs.wso2.com/en/latest/micro-integrator/develop/intro-integration-development/) |
[Mailing Lists](https://wso2.com/mail/) |
[Blog](https://wso2.com/blogs/thesource/) |
[Support](https://wso2.com/subscription)

## Outline

- [**Why WSO2 Integration Studio?**](#Why-WSO2-Enterprise-Integrator)
- [**Features**](#Features)
- [**Distributions**](#Distributions)
- [**Installation and Run**](#Installation-and-Run)
- [**Building from Source**](#Building-from-Source)
- [**Enterprise Support**](#Enterprise-Support)
- [**Licence**](#License)

## Why WSO2 Integration Studio

**Run the complete Development Lifecycle**
You can use WSO2 Integration Studio to execute the complete development lifecycle of your integration solutions:
1. **Create** the integration artifacts.
2. **Build** and **test** the artifacts.
3. **Debug** and **iterate** (improve the artifacts).
4. **Publish** to production.

**Graphical integration designing**
Once you have created your integration project, you can simply drag-and-drop the required artifacts to the design canvas and update the configuration parameters for your environment.

**Use Templates**
WSO2 Integration Studio contains templates for the most common integration use cases, assisted by embedded help. You can reuse these templates for your own integration scenarios to reduce the development time.

**Develop for both VMs and Containers**
WSO2 Integration Studio is shipped with an embedded Micro Integrator server, which allows you to immediately deploy and test artifacts. Also, the tool contains comprehensive container support: You can create Kubernetes and Docker projects, which automatically generates the required container artifacts for your solution.

**Continuous Integration and Continuous Deployment (CICD)**
If you are deploying in a Kubernetes environment, the Kubernetes projects generated from WSO2 Integration Studio can be directly applied to your CICD workflow. The **EI-Kubernetes Operator** will then push the deployment into your Kubernetes environment.
If you are deploying in a VM, you can generate a **CAR** file (with your integration artifacts) from WSO2 Integration Studio and push it to your CICD pipeline.

## Features

- **Graphical View**: Supports designing and development of the integration flow
- **Source View**: Represents the Synapse configuration of the integration flow
- **Properties View**: Allows configuring and customizing artifacts
- **Pre-defined Projects**: Facilitates structuring integration artifacts
- **Updater Tool**: Provides bug fixes and improvements as updates
- **Connector Support**: Supports working with WSO2 connectors at [WSO2 Store](https://store.wso2.com/store/assets/esbconnector/list)
- **Visual Data Mapping**: Maps input data formats to output data formats visually
- **Data Integration Support**: Supports data service and data source artifact generation
- **Business Process Support** : Supports BPEL workflow, human task, BPMN artifact generation
- **Docker Support**: Supports Docker image generation
- **Kubernetes Support**: Supports kubernetes deployment using [WSO2 EI Operator](https://github.com/wso2/k8s-ei-operator)
- **WSO2 Integration Cloud Support**: Supports deploying artifacts to the integration cloud
- **Synapse Testing Framework**: Allows testing the integration scenario with the Synapse Testing Framework
- **Debugger**: Allows debugging the mediation flow
- **WSO2 Server Support**: Supports adding WSO2 ESB/EI servers as remote servers and WSO2 MI as the embedded server
- **Embedded JDK**: Contains with an embedded JDK
- **Embedded WSO2 Micro Integrator**: Contains with an embedded WSO2 Micro Integrator for testing the integration flow
- **Integration Templates**: Pre-built integration templates to guide on boarding users
- **REST Client**: Allows testing the integration scenarios

## Distributions
WSO2 Integration Studio maintains distributions can be downloaded, [here](https://wso2.com/integration/integration-studio/).

All open issues pertaining to WSO2 Integration Studio are reported at the following location:
[known issues](https://github.com/wso2/devstudio-tooling-ei/issues)

## Installation and Run
1. Download the [distribution](https://wso2.com/integration/integration-studio/) for your operating system.
2. Extract the downloaded file to get the **IntegrationStudio** application. If you are a MacOS user, be sure to add it to the **Applications** directory.
3. Run the **IntegrationStudio** application to start the tool.

### Building from Source
You can download this repository and run ```mvn clean install``` from the root directory, to build the Integration Studio from the source code

## Enterprise Support

Enterprise support for WSO2 Integration Studio is provided by WSO2. Learn more [here](https://wso2.com/subscription).

## License

```
Copyright (c) 2020, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.

WSO2 Inc. 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.
```


Jazzer

Fuzz Testing for the JVM

Website
|
Blog
|
Twitter

> [!IMPORTANT]
> Hello Jazzer/Jazzer.js users!
>
> We stopped maintaining Jazzer/Jazzer.js as open source.
> But we'd be happy to try and understand what you're trying to achieve with it, and help you if we can!
>
> We already added significant new value to our CI Fuzz solution, which includes Jazzer and Jazzer.js.
> Learn more on how to turbocharge your Java Fuzz Testing with [Jazzer Pro](https://www.code-intelligence.com/introducing-jazzer-pro).
>
> Visit [code-intelligence.com](https://code-intelligence.com) for more information, or get in contact with us via [sales@code-intelligence.com](mailto:sales@code-intelligence.com).
>
> Thanks,
>
> The Code Intelligence team

Jazzer is a coverage-guided, in-process fuzzer for the JVM platform developed by [Code Intelligence](https://code-intelligence.com).
It is based on [libFuzzer](https://llvm.org/docs/LibFuzzer.html) and brings many of its instrumentation-powered mutation features to the JVM.

Jazzer currently supports the following platforms:
* Linux x86_64
* macOS 12+ x86_64 & arm64
* Windows x86_64

## Quick start

You can use Docker to try out Jazzer's Autofuzz mode, in which it automatically generates arguments to a given Java function and reports unexpected exceptions and detected security issues:

```
docker run -it cifuzz/jazzer-autofuzz \
   com.mikesamuel:json-sanitizer:1.2.0 \
   com.google.json.JsonSanitizer::sanitize \
   --autofuzz_ignore=java.lang.ArrayIndexOutOfBoundsException
```

Here, the first two arguments are the Maven coordinates of the Java library and the fully qualified name of the Java function to be fuzzed in "method reference" form.
The optional `--autofuzz_ignore` flag takes a list of uncaught exception classes to ignore.

After a few seconds, Jazzer should trigger an `AssertionError`, reproducing a bug it found in this library that has since been fixed.

## Using Jazzer via...

### JUnit 5

The following steps assume that JUnit 5.9.0 or higher is set up for your project, for example based on the official [junit5-samples](https://github.com/junit-team/junit5-samples).

1. Add a dependency on `com.code-intelligence:jazzer-junit:<latest version>`.
   All Jazzer Maven artifacts are signed with [this key](deploy/maven.pub).
2. Add a new *fuzz test* to a new or existing test class: a method annotated with [`@FuzzTest`](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-junit/com/code_intelligence/jazzer/junit/FuzzTest.html) and at least one parameter.
   Using a single parameter of type [`FuzzedDataProvider`](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html), which provides utility functions to produce commonly used Java values, or `byte[]` is recommended for optimal performance and reproducibility of findings.
3. Assuming your test class is called `com.example.MyFuzzTests`, create the *inputs directory* `src/test/resources/com/example/MyFuzzTestsInputs`.
4. Run a fuzz test with the environment variable `JAZZER_FUZZ` set to `1` to let the fuzzer rapidly try new sets of arguments.
   If the fuzzer finds arguments that make your fuzz test fail or even trigger a security issue, it will store them in the inputs directory.
   In this mode, only a single fuzz test is executed per test run (see [#599](https://github.com/CodeIntelligenceTesting/jazzer/issues/599) for details).
5. Run the fuzz test without `JAZZER_FUZZ` set to execute it only on the inputs in the inputs directory.
   This mode, which behaves just like a traditional unit test, ensures that issues previously found by the fuzzer remain fixed and can also be used to debug the fuzz test on individual inputs.

A simple property-based fuzz test could look like this (excluding imports):

```java
class ParserTests {
   @Test
   void unitTest() {
      assertEquals("foobar", SomeScheme.decode(SomeScheme.encode("foobar")));
   }

   @FuzzTest
   void fuzzTest(FuzzedDataProvider data) {
      String input = data.consumeRemainingAsString();
      assertEquals(input, SomeScheme.decode(SomeScheme.encode(input)));
   }
}
```

A complete Maven example project can be found in [`examples/junit`](examples/junit).

### GitHub releases

You can also use GitHub release archives to run a standalone Jazzer binary that starts its own JVM configured for fuzzing:

1. Download and extract the latest release from the [GitHub releases page](https://github.com/CodeIntelligenceTesting/jazzer/releases).
2. Add a new class to your project with a public static void fuzzerTestOneInput(FuzzedDataProvider data) method.
3. Compile your fuzz test with `jazzer_standalone.jar` on the classpath.
4. Run the `jazzer` binary (`jazzer.exe` on Windows), specifying the classpath and fuzz test class:

```shell
./jazzer --cp=<classpath> --target_class=<fuzz test class>
```

If you see an error saying that `libjvm.so` has not been found, make sure that `JAVA_HOME` points to a JDK.

The [`examples`](examples/src/main/java/com/example) directory includes both toy and real-world examples of fuzz tests.

### Docker

The "distroless" Docker image [cifuzz/jazzer](https://hub.docker.com/r/cifuzz/jazzer) includes a recent Jazzer release together with OpenJDK 17.
Mount a directory containing your compiled fuzz target into the container under `/fuzzing` and use it like a GitHub release binary by running:

```sh
docker run -v path/containing/the/application:/fuzzing cifuzz/jazzer --cp=<classpath> --target_class=<fuzz test class>
```

If Jazzer produces a finding, the input that triggered it will be available in the same directory.

### Bazel

Support for Jazzer is available in [rules_fuzzing](https://github.com/bazelbuild/rules_fuzzing), the official Bazel rules for fuzzing.
See [the README](https://github.com/bazelbuild/rules_fuzzing#java-fuzzing) for instructions on how to use Jazzer in a Java Bazel project.

### OSS-Fuzz

[Code Intelligence](https://code-intelligence.com) and Google have teamed up to bring support for Java, Kotlin, and other JVM-based languages to [OSS-Fuzz](https://github.com/google/oss-fuzz), Google's project for large-scale fuzzing of open-souce software.
Read [the OSS-Fuzz guide](https://google.github.io/oss-fuzz/getting-started/new-project-guide/jvm-lang/) to learn how to set up a Java project.

## Building from source

Information on building and testing Jazzer for development can be found in [CONTRIBUTING.md](CONTRIBUTING.md)

## Further documentation

* [Common options and workflows](docs/common.md)
* [Advanced techniques](docs/advanced.md)

## Findings

A list of security issues and bugs found by Jazzer is maintained [here](docs/findings.md).
If you found something interesting and the information is public, please send a PR to add it to the list.

## Credit

The following developers have contributed to Jazzer before its public release:

[Sergej Dechand](https://github.com/serj),
[Christian Hartlage](https://github.com/dende),
[Fabian Meumertzheim](https://github.com/fmeum),
[Sebastian Pöplau](https://github.com/sebastianpoeplau),
[Mohammed Qasem](https://github.com/mohqas),
[Simon Resch](https://github.com/simonresch),
[Henrik Schnor](https://github.com/henrikschnor),
[Khaled Yakdan](https://github.com/kyakdan)

The LLVM-style edge coverage instrumentation for JVM bytecode used by Jazzer relies on [JaCoCo](https://github.com/jacoco/jacoco).
Previously, Jazzer used AFL-style coverage instrumentation as pioneered by [kelinci](https://github.com/isstac/kelinci).

[`FuzzedDataProvider`]: https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html


[![Java CI with Maven](https://github.com/GraphWalker/graphwalker-project/actions/workflows/maven.yml/badge.svg?branch=master)](https://github.com/GraphWalker/graphwalker-project/actions/workflows/maven.yml)
[![CodeQL](https://github.com/GraphWalker/graphwalker-project/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/GraphWalker/graphwalker-project/actions/workflows/codeql-analysis.yml)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.graphwalker/graphwalker-project/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.graphwalker/graphwalker-project)

# GraphWalker

Documentation on http://graphwalker.org/

## Get the source code and build all modules

```bash
git clone https://github.com/GraphWalker/graphwalker-project.git
cd graphwalker-project
mvn install
```

## Build the stand command-line tool

```bash
mvn package -pl graphwalker-cli -am
```

The jar is in:
```bash
graphwalker-cli/target/graphwalker-cli-<VERSION>.jar
```

Run it like:
```bash
java -jar graphwalker-cli/target/graphwalker-cli-<VERSION>.jar
```

## Build Studio

```bash
mvn package -pl graphwalker-studio -am
```

The jar is in:
```bash
graphwalker-studio/target/
```

Run it like:
```bash
java -jar graphwalker-studio/target/graphwalker-studio-<VERSION>.jar
```


![larex](https://github.com/OCR4all/LAREX/blob/master/documentation/larex.gif)
# [LAREX](https://github.com/OCR4all/LAREX)

[![Build verification with Maven](https://github.com/OCR4all/LAREX/actions/workflows/maven_build_verification.yml/badge.svg)](https://github.com/OCR4all/LAREX/actions/workflows/maven_build_verification.yml)

LAREX is a semi-automatic open-source tool for layout analysis on early printed books.
It uses a rule based connected components approach which is very fast,
easily comprehensible for the user and allows an intuitive manual correction if necessary.
The PAGE XML format is used to support integration into existing OCR workflows.
Evaluations showed that LAREX provides an efficient and flexible way to segment pages of early printed books.

Please feel free to visit the [tool homepage](https://www.uni-wuerzburg.de/zpd/larex/). A short user manual is available [here](http://www.is.informatik.uni-wuerzburg.de/fileadmin/10030600/Mitarbeiter/Reul_Christian/Projects/Layout_Analysis/LAREX_Quick_Guide.pdf).

## Table of Contents
- [Installation](#installation)
  * [Docker](#docker)
  * [Linux](#linux)
  * [Windows](#windows)
  * [Mac OS X](#macos)
- [Usage](#usage)
- [Configuration](#configuration)
- [Related Publications](#related-publications)

_Additional information about developing for LAREX [see here](documentation/development.md)_

## Installation

### Docker
This guide uses [Docker](https://www.docker.com/) and allows a platform agnostic installation of LAREX
#### Production
* See: [LAREX Docker](https://github.com/maxnth/LAREX_Docker)

#### Development
* Configure `development/build.sh`, run `cd development` and `sh build.sh`

### Linux
This guide uses Tomcat 8, **Java 8** and Ubuntu (please adjust accordingly for your setup)

* Install required packages:
	`apt-get install tomcat8 maven openjdk-8-jdk`
* Clone Repository:
	`git clone https://github.com/OCR4all/LAREX.git`
* Compile:
	`mvn clean install -f LAREX/pom.xml`.
* Copy or link the created war file to Tomcat:
	* Copy `cp LAREX/target/Larex.war /var/lib/tomcat8/webapps/Larex.war`
	* Link: `sudo ln -s $PWD/LAREX/target/Larex.war /var/lib/tomcat8/webapps/Larex.war`
* Start Tomcat:
	`systemctl start tomcat8`
	* (Restart Tomcat via `systemctl restart tomcat8`)
	* (To start Tomcat automatically at system boot `systemctl enable tomcat8`)

### Windows
This guide uses [Eclipse](https://www.eclipse.org/) to simplify the setup on Windows

* Install _Eclipse IDE for Enterprise Java Developers_ from the [official website](https://www.eclipse.org/downloads/packages/)
* Download Tomcat 8 or up from the [official website](http://tomcat.apache.org/download-90.cgi)
* Create a Tomcat server in eclipse:
	* Open `Window` -> `Show View` -> `Other...` -> `Server` -> `Servers`
	* Click prompt to add a new server, select `Apache` -> `Tomcat <version> Server` -> `Next`-> set your Tomcat installation directory -> `Finish`.
* Clone Repository:
	* `File` -> `Import` -> `Git` -> `Projects from Git` -> `Clone URI`
	-> Set `URI: https://github.com/OCR4all/LAREX.git` -> `[✓] master` -> `Next >` -> `Next >` -> `Import as gernal project` -> `Finish`
* Set as Maven Project:
* Import Project
	* Right click on `Larex` -> `Configure` -> `Convert to Maven Project` -> `Finish`
* Update maven project (if not updated automatically)
	* Rightclick on `Larex` -> `Maven` -> `Update Project...` -> `OK`
* Start Larex
	* Right click on `Larex` -> `Run As` -> `Run on Server`.

### macOS
**Note: LAREX is mainly developed on Linux so the macOS build introductions may be outdated from time to time. If this is the case, feel free to contact us**
This guide uses homebrew (please adjust accordingly for your setup).
* Install Homebrew (see https://brew.sh/) and run `brew update`.
* Install required packages:
	* `brew cask install adoptopenjdk8`
	* `brew install tomcat git maven`
* (Verify Tomcat installation):
	* `brew services list` tomcat should be listed in the output of this command
* Clone Repository:
	* `git clone https://github.com/OCR4all/LAREX.git`
* Compile:
	* run `mvn clean install -f LAREX/pom.xml`.
* Copy or link the created war file to Tomcat
	* Copy: `cp LAREX/target/Larex.war /usr/local/Cellar/tomcat/[version]/libexec/webapps/Larex.war`
	* Link: `ln -s $PWD/LAREX/target/Larex.war /usr/local/Cellar/tomcat/[version]/libexec/webapps/Larex.war`
* Start Tomcat:
	* `brew services start tomcat`
	* (Restart Tomcat via `brew services restart tomcat`)

## Usage

### Access in browser
Go to `localhost:8080/Larex`.

### Using your own images and books
You can add your own books by copying them to `src/webapp/resources/books`

(Or an alternative direction set in the [config file](https://github.com/OCR4all/LAREX/blob/master/src/main/webapp/WEB-INF/larex.properties). See section [*Configuration*](#configuration) for more information).

Book directories must have the following structure:
```
bookDir/
├── <book_name>/
│    ├── <page_name>.png
│    └── <page_name>.xml
└── <book2_name>/
     └── …
```
### More information
Detailed information about the usage of LAREX can be found in the OCR4all [getting started](https://github.com/OCR4all/getting_started) guides.

See sections and chapters about _Segmentation_, _Ground Truth Correction_ and _Post Correction_.

## Configuration ##
LAREX contains a configuration file ([`src/webapp/WEB-INF/larex.properties`](https://github.com/OCR4all/LAREX/blob/master/src/main/webapp/WEB-INF/larex.properties)) with a few settings that can be set before running the application.

### bookpath ###
The setting *bookpath* sets the file path of the books folder.

e.g. `bookpath=/home/user/books` (Linux)

e.g. `bookpath=C:\Users\user\Documents\books` (Windows)

LAREX will load the books from this folder.

[default <Larex>/src/main/webapp/resources/books]

### localsave ###
The setting *localsave* tells the application how to handle results locally when saved.

_Please note_:
To work properly in local mode it's required that the `Page@imageFilename`-attribute matches the actual filename (apart from the extension). This label will be used for local storage.

`<mode>=[bookpath|savedir|none]`

`bookpath`: save the result in the bookpath

`savedir`: save the result in a defined savedir

`none`: do not save the result locally [default]

e.g. `localsave:bookpath`

### savedir ###
The setting *savedir* is needed if localsave mode is set to "savedir".

e.g. `savedir=/home/user/save` (Linux)

e.g. `savedir=C:\Users\user\Documents\save` (Windows)

### websave ###
The setting *websave* tells the application how to handle results on the browser side when saved.

`<value>=[true|false]`

`true`: download the result after saving [default]

`false`: no action after saving

e.g. `websave=true`

### modes ###
Set the accessible modes in the LAREX GUI `<value>=[[segment][edit][lines][text]]`
A combination of the modes "segment", "edit", "lines" and "text" can be set as
a space separated string.
e.g. `modes=segment lines`

The order of those modes in the string also determines which mode is opened
on startup, with the first in the list being opened as main mode.
The mode "segment" can be replaced with "edit" in order to hide all auto
segmentation features. ("edit" will be ignored if both are present)

[Default] `modes=segment lines text`

### directrequest ###
This setting enables or disables the direct open feature.

`<value>=[enable|disable]`

This feature allows users to load a book from everywhere on the servers drive as well as to alter the options *websave*,  *localsave* and *savedir*.

`enable`: enable direct request

`disable`: disable direct request [default]

e.g. `directrequest=enable`

This feature should be used with caution but is very useful when using LAREX in a workflow with other web applications. (e.g. in Docker)

The easiest direct request would be via a html form with the values *bookpath*, *bookname*, *websave* (optional),  *localsave* (optional) and *savedir* (optional).
```html
<form action="http://localhost:8080/Larex/direct" method="POST">
	bookpath: <input type="text" name="bookpath"/><br>
	bookname: <input type="text" name="bookname"/><br>
	websave: <input type="text" name="websave"/><br>
	localsave: <input type="text" name="localsave"/><br>
	savedir: <input type="text" name="savedir"/><br>
	modes: <input type="text" name="modes"/><br>
	<input type="submit"/>
</form>
```

### OCR4all UI mode ###
This setting enables or disables OCR4all UI mode.

`<value>=[enable|disable]`

This setting allows displaying and/or hiding certain UI elements when LAREX is used in combination with OCR4all.

`enable`: enable OCR4all UI mode

`disable`: disable OCR4all UI mode [default]

e.g. `ocr4all=enable`

## Citing LAREX

If you are using LAREX please cite:

> Reul, C., Springmann, U., Puppe, F.: *Larex: A semi-automatic open-source tool for layout analysis and region extraction on early printed books* Proceedings of the 2nd International Conference on Digital Access to Textual Cultural Heritage (2017)
```
@inproceedings{reul2017larex,
  title={Larex: A semi-automatic open-source tool for layout analysis and region extraction on early printed books},
  author={Reul, Christian and Springmann, Uwe and Puppe, Frank},
  booktitle={Proceedings of the 2nd International Conference on Digital Access to Textual Cultural Heritage},
  pages={137--142},
  year={2017}
}
```


# Discord Server

Join `Testing Is Documenting` [Discord Server](https://discord.gg/aEHbzXTX6N) to ask questions and discuss features/bugs

# Znai

Build functional, maintainable, beautiful User Guides with `Znai`.

* Markdown with custom extensions and dozens of plugins:
  * Content from external files with markers and filters support
  * Simplified extraction of a function body content (working with examples)
  * Embedding of JavaDoc/PyDoc documentation text, preserving styles
  * Beautiful API documentation capabilities
  * Two Sides Page Layout Option with convenient example languages switch
  * Rich visuals like flow diagrams, charts and cards
  * etc
* Instant pages navigation
* Local search
* Multiple integrations to work with Python, Java, OpenAPI, etc
* Presentation Mode to automatically turn your documentation into slides, using the same content
* Dark/Light runtime themes
* Leverage automated test results to enrich your documentation with annotated images, REST responses, CLI outputs, etc
* GitHub pages friendly

![generated site example](znai-docs/readme/znai-overview.png)

Embedding of [External Resources](https://testingisdocumenting.org/znai/snippets/external-code-snippets) at build time

![generated site example of external code](znai-docs/readme/znai-external-code.png)

Rich Visuals such as [Charts](https://testingisdocumenting.org/znai/visuals/charts),
[Flow Diagrams](https://testingisdocumenting.org/znai/visuals/flow-diagrams) and
[Cards](https://testingisdocumenting.org/znai/visuals/cards)

![generated site example of charts](znai-docs/readme/znai-charts.png)

Dark/Light mode switching

![generated site example of flow diagram](znai-docs/readme/znai-flow-diagram.png)

Cards support

![generated site example of cards](znai-docs/readme/znai-cards.png)

Beautiful way to document your API

![generated site example of api params](znai-docs/readme/znai-api-parameters.png)

Use [two sides](https://testingisdocumenting.org/znai/layout/two-sides-tabs) layout option to render examples and supporting information side by side
with convenient examples language switch

![generated site example of two sides layout](znai-docs/readme/znai-two-sides-tabs.png)

Blazing fast local search with results preview

![generated site example of search](znai-docs/readme/znai-search.png)

Automatic Presentation from **the same content** with zero config

![generated site example of presentation mode](znai-docs/readme/znai-presentation.png)

# Preview

`Znai` has a preview mode to automatically listen to local files changes. It automatically navigates to a page that was
changed (directly or indirectly) and highlights the changes.

# Docs Hub

`Znai` has a free, open-source enterprise support. You can host multiple documentations using single site. It provides
landing page to list all the company inner guides.

It also automatically detects documentations in the builds outputs and updates hosted documentations.

Examples (including using Google Cloud) and setup documentation are coming. Please create a GitHub issue if you want
to learn more about Enterprise setup. It will help me prioritize.

# Read More

[Znai documentation website built with Znai](https://testingisdocumenting.org/znai/)

For curios, znai word meaning: `znai` is a `to know` in Ukranian and is a prefix for words like `knoweldge` are built on.

# Developers Setup

[Local Build](https://testingisdocumenting.org/znai/znai-development/local-build)


### Teletraan Deploy Service

![](https://github.com/pinterest/teletraan/blob/master/docs/misc/images/TeletraanIntro.png)

### What is Teletraan?
Teletraan is Pinterest's deploy system. It deploys thousands of Pinterest internal services, supports tens of thousands hosts, and has been running in production for over many years. It empowers Pinterest Engineers to deliver their code to pinners fast and safe. Check out the [wiki](https://github.com/pinterest/teletraan/wiki) or blog post [Under the hood: Teletraan Deploy System](https://medium.com/@Pinterest_Engineering/under-the-hood-teletraan-deploy-system-1e5caa774a63) for more details.

The name Teletraan comes from a character in the Transformer TV series! [wikipedia](https://en.wikipedia.org/wiki/List_of_Transformers_supporting_characters#Teletran_3)

### Why use Teletraan?
Teletraan is designed to do one thing and one thing only - deploy. It supports critical features such as 0 downtime deploy, rollback, staging, continuous deploy; and many convenient developer facing features such as showing commit details, comparing different deploys, notifying deploy state changes through email or slack, displaying metrics and more. Teletraan does not support container based deploy yet. Currently you can still use Teletraan Deploy Scripts to call docker or docker-compose to run containers.

### How to use Teletraan?
Teletraan is designed to be a flexible building block. You can plug Teletraan into your existing release workflow given the following requirements met:
* Run Deploy Agent on every host
* Add Deploy Scripts to your application code
* Publish Build Artifacts to Teletraan in the end of each build

Check out [Integrate with Teletraan](https://github.com/pinterest/teletraan/wiki/Integrate-with-teletraan) for more details.

### Quick start

[Quick start guide!](https://github.com/pinterest/teletraan/wiki/Quickstart-Guide)

### Documentation

[Check out our wiki!](https://github.com/pinterest/teletraan/wiki)

### Help

If you have any questions or comments, you can reach us at teletraan-users@googlegroups.com


![uPortal logo](docs/images/uPortal-logo.jpg)

            Version

            Linux

            Windows

            Coverage

              uPortal 5

              uPortal 4.3

                Quick links

            Join the Conversation

## About

uPortal is the leading open source enterprise portal framework built by and for
the higher education community. uPortal continues to evolve through
contributions from its global community and is supported by resources, grants,
donations, and memberships fees from academic institutions, commercial
affiliates, and non-profit foundations. uPortal is built on open standards-based
technologies such as Java and XML, and enables easy, standards-based integration
with authentication and security infrastructures, single sign-on secure access,
campus applications, web-based content, and end user customization. uPortal can
easily integrate with other enterprise systems and can be customized for
specific local needs.

### Forever Free!

You may [download uPortal](https://github.com/uPortal-Project/uPortal/releases) and use it
on your site at no cost. Unlike our competitors, uPortal is 100% free open
source software managed by [Apereo](https://www.apereo.org/content/about). Our
community has access to all releases of the uPortal software with absolutely no
costs. We welcome
[contributions from our community](https://github.com/uPortal-Project/uPortal/graphs/contributors)
of all types and sizes.

### Accessible

uPortal strives to conform with
[Web Content Accessibility Guidelines Version 2.0](https://www.w3.org/TR/WCAG20/)
Level AA. The most recent accessibility audit results can be seen in
[UP-4735](https://issues.jasig.org/browse/UP-4735).

## Help and Support

The [uportal-user@apereo.org](https://wiki.jasig.org/display/JSG/uportal-user)
email address is the best place to go with questions related to configuring or
deploying uPortal.

The [uPortal manual](#manual) is a collaborative resource which has more
detailed documentation for each uPortal release.

### Manual

Additional information about uPortal is available in the Manual.

-   [uPortal 5.9 Manual][latest uportal manual]
-   [uPortal 5.8 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.8.2/docs)
-   [uPortal 5.7 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.7.1/docs)
-   [uPortal 5.6 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.6.1/docs)
-   [uPortal 5.5 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.5.1/docs)
-   [uPortal 5.4 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.4.1/docs)
-   [uPortal 5.3 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.3.2/docs)
-   [uPortal 5.2 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.2.3/docs)
-   [uPortal 5.1 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.1.2/docs)
-   [uPortal 5.0 Manual](https://github.com/uPortal-Project/uPortal/tree/v5.0.7/docs)
-   [uPortal 4.3 Manual](https://wiki.jasig.org/display/UPM43/Home)
-   [uPortal 4.2 Manual](https://wiki.jasig.org/display/UPM42/Home)
-   [uPortal 4.1 Manual](https://wiki.jasig.org/display/UPM41/Home)
-   [uPortal 4.0 Manual](https://wiki.jasig.org/display/UPM40/Home)
-   [uPortal 3.2 Manual](https://wiki.jasig.org/display/UPM32/Home)
-   [uPortal 3.1 Manual](https://wiki.jasig.org/display/UPM31/Home)
-   [uPortal 3.0 Manual](https://wiki.jasig.org/display/UPM30/Home)

## Requirements

-   JDK 1.8 - The JRE alone is NOT sufficient, a full JDK is required
-   GIT

## uPortal-start

uPortal is now meant to be deployed via [uPortal-start][], which is responsible for
servlet container (ie Tomcat), DB, and portal configurations. uPortal-start
deals with the low-level configurations and setup, while letting the adopter
focus on the business configuration side of the deployment. However, it is
possible to run uPortal without uPortal-start. The [uPortal manual][latest uportal manual] explains
how.

## Building and Deploying

uPortal uses Gradle for its project configuration and build system. uPortal
comes with a Gradle wrapper if you don't want to install the build tool
(`./gradlew` in the root directory of the repo).

### Gradle tasks

For a full list of Gradle tasks run `./gradlew tasks` from the root directory.

[latest uportal manual]: https://uportal-project.github.io/uPortal
[uportal-start]: https://github.com/uPortal-Project/uPortal-start


[![Build Status](https://github.com/SUSE/salt-netapi-client/actions/workflows/maven.yml/badge.svg)](https://github.com/SUSE/salt-netapi-client/actions/workflows/maven.yml)
[![Maven Central](https://img.shields.io/maven-central/v/com.suse.salt/salt-netapi-client)](https://mvnrepository.com/artifact/com.suse.salt/salt-netapi-client)

# salt-netapi-client

Java bindings for the [Salt API](http://docs.saltstack.com/en/latest/ref/netapi/all/salt.netapi.rest_cherrypy.html#module-salt.netapi.rest_cherrypy.app), please have a look at the Javadoc for [v0.21.0](http://suse.github.io/salt-netapi-client/docs/v0.21.0) or [master](http://suse.github.io/salt-netapi-client/docs/master).

## How to use it

Add the following dependency to the `pom.xml` file of your project:

```xml
<dependency>
    <groupId>com.suse.salt</groupId>
    <artifactId>salt-netapi-client</artifactId>
    <version>0.21.0</version>
</dependency>
```

## Code examples

There is some basic [code examples](https://github.com/SUSE/salt-netapi-client/tree/master/src/test/java/com/suse/salt/netapi/examples) available to help you getting started with the library.

## Contributing

Pull requests are always welcome, please see [issues](https://github.com/SUSE/salt-netapi-client/issues) for a list of things to possibly tackle.

### Style guide

* Indentations are represented with 4 spaces
* The maximum line length should not exceed 120
* Wrapped lines should be indented twice (8 spaces)
* Files should end with a new line


# Dapr Quickstarts and Tutorials

[![Build Status](https://github.com/dapr/quickstarts/workflows/samples/badge.svg?event=push&branch=master)](https://github.com/dapr/quickstarts/actions?workflow=samples)
[![Discord](https://img.shields.io/discord/778680217417809931)](https://discord.com/channels/778680217417809931/778680217417809934)
[![License: Apache 2.0](https://img.shields.io/badge/License-Apache-yellow.svg)](https://www.apache.org/licenses/LICENSE-2.0)

If you are new to Dapr and haven't done so already, it is recommended you go through the Dapr [Getting Started](https://docs.dapr.io/getting-started/install-dapr-cli/) instructions.

### Quickstarts

Pick a building block API (for example, PubSub, state management, etc) and rapidly try it out in your favorite language SDK (recommended), or via HTTP. Visit the [Dapr Docs Quickstarts Guide](https://docs.dapr.io/getting-started/quickstarts/) for a comprehensive walkthrough of each example.

| Dapr Quickstart | Description |
|:--------:|:--------:|
| [Publish and Subscribe](./pub_sub) | Asynchronous communication between two services using messaging |
| [Service Invocation](./service_invocation) | Synchronous communication between two services using HTTP |
| [State Management](./state_management/) | Store a service's data as key/value pairs in supported state stores |
| [Bindings](./bindings/) | Work with external systems using input bindings to respond to events and output bindings to call operations |
| [Secrets Management](./secrets_management/) | Securely fetch secrets |
| [Actors](./actors) | Create stateful, long running objects with identity |
| [Configuration](./configuration) | Get configuration items as key/value pairs or subscribe to changes whenever a configuration item changes |
| [Cryptography](./cryptography) | Perform cryptographic operations without exposing keys to your application |
| [Resiliency](./resiliency) | Define and apply fault-tolerant policies (retries/back-offs, timeouts and circuit breakers) to your Dapr API requests |
| [Workflow](./workflows) | Dapr Workflow enables you to create long running, fault-tolerant, stateful applications |

### Tutorials

Go deeper into a topic or scenario, oftentimes using building block APIs together to solve problems (for example, build a distributed calculator, build and deploy an app to Kubernetes).

| Tutorials | Description |
|------|------|
| [Hello-world](./tutorials/hello-world) | Demonstrates how to run Dapr locally. Highlights service invocation and state management. |
| [Hello-kubernetes](./tutorials/hello-kubernetes) | Demonstrates how to run Dapr in Kubernetes. Highlights service invocation and state management. |
| [Distributed-calculator](./tutorials/distributed-calculator) | Demonstrates a distributed calculator application that uses Dapr services to power a React web app. Highlights polyglot (multi-language) programming, service invocation and state management. |
| [Pub-sub](./tutorials/pub-sub) | Demonstrates how to use Dapr to enable pub-sub applications. Uses Redis as a pub-sub component. |
| [Bindings](./tutorials/bindings) | Demonstrates how to use Dapr to create input and output bindings to other components. Uses bindings to Kafka.|
| [Observability](./tutorials/observability) | Demonstrates Dapr tracing capabilities. Uses Zipkin as a tracing component. |
| [Secret Store](./tutorials/secretstore) | Demonstrates the use of Dapr Secrets API to access secret stores. |

## Code of Conduct

Please refer to our [Dapr Community Code of Conduct](https://github.com/dapr/community/blob/master/CODE-OF-CONDUCT.md)


[![Codacy Badge](https://app.codacy.com/project/badge/Grade/cfbc3de984c9407ea0eaa3b86552f848)](https://www.codacy.com/gh/jdi-testing/jdi-dark?utm_source=github.com&utm_medium=referral&utm_content=jdi-testing/jdi-dark&utm_campaign=Badge_Grade)

# JDI Dark Test Automation Framework
[![stackoverflow](https://img.shields.io/badge/stackoverflow-jdi-blue.svg?style=flat)](http://stackoverflow.com/questions/tagged/jdi)
[![SLACK](https://img.shields.io/badge/slack-community-green.svg?style=flat)](https://join.slack.com/t/jdi-family/shared_invite/zt-toag8fgg-ppPiW~lZDU9873JAiSwTJw)

## Documentation
For fast start you can go through [tutorial](https://jdi-docs.github.io/jdi-dark/#tutorial)

More links:

Documentation: <https://jdi-docs.github.io/jdi-dark> - different types of documentation from introduction and tutorial to technical methods documentation

Highlights + fast start example: <https://jdi-docs.github.io/jdi-dark/?java#highlights>

Tutorial: <https://jdi-docs.github.io/jdi-dark/#tutorial> - helps to get main ideas on practice

Project templates: <https://github.com/jdi-templates> - for fast projects start

Examples: <https://github.com/jdi-examples>

Increase test [performance examples](https://github.com/jdi-testing/jdi-dark/blob/master/jdi-dark-tests/src/test/java/com/epam/jdi/httptests/performance/PerformanceTests.java)

## Introduction

JDI Dark – is the test Framework for services testing that makes your tests fast and sustainable and provides obvious and predictable test run result

## Highlights
-Obvious Service Object Model that helps to reduce test development effort and increase its speed

-REST and SOAP web service design support

-Extended capabilities of REST Assured framework with all its features kept

-Simple interface for sending requests and response analysis

-Automated service objects generation both for REST and SOAP

-Support of the BDD approach

-Retrying of failed tests with specified number of attempts

-Detailed logging of requests and responses in JSON format which can be used in your reports

## Our plans
### Ultimate Goal

Run test execution automatically and correct tests if any changes in services happen, provide good reports for test project team and recommendations on how the project can be improved

### Nearest plans
[Features](https://github.com/jdi-testing/jdi-dark/labels/feature)

## Useful Links
Site: <http://jdi.epam.com/>

VK: <https://vk.com/jdi_framework>

Facebook: <https://www.facebook.com/groups/jdi.framework/>

You can ask your questions on StackOverflow with [![htmlelements](https://img.shields.io/badge/stackoverflow-jdiframework-orange.svg?style=flat)](http://stackoverflow.com/questions/tagged/jdiframework) tag

## Community and Support
Get Help in active users Slak chat: https://join.slack.com/t/jdi-family/shared_invite/zt-toag8fgg-ppPiW~lZDU9873JAiSwTJw

(Depricated) Get Help in active users Skype chat: https://join.skype.com/clvyVvnZvWqc

## License


# Welcome to XDAGJ

[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FXDagger%2Fxdagj.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FXDagger%2Fxdagj?ref=badge_shield) ![](https://github.com/XDagger/xdagj/actions/workflows/maven.yml/badge.svg) ![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/XDagger/xdagj) ![GitHub](https://img.shields.io/github/license/XDagger/xdagj) ![GitHub issues](https://img.shields.io/github/issues/XDagger/xdagj)

[中文版](./docs/README_zh.md)

## Directory

- [System environment](#system-environment)
  - [Installation and usage](#installation-and-usage)
  - [Develop](#develop)
    - [XDAG Mars Project](#XDAG-Mars-Project)
  - [Code](#code)
  - [Contribution](#contribution)
  - [Sponsorship](#sponsorship)
  - [Other](#other)
  - [License](#license)

## System environment

```
JDK: v17
Maven: v3.9.1
```

### JDK 17 Download
Eclipse Temurin™ 17 Latest Releases(https://adoptium.net/temurin/releases/)

### Maven 3.9.1 Download
Apache Maven 3.9.x Latest Releases(https://maven.apache.org/download.cgi)

## Installation and usage

The XDAGJ Testnet Tutorial can help you quickly access XDAGJ testnet by using wallets and mining functions. The Private Chain Building Tutorial helps you to build a private-chain for testing XDAGJ and finding bugs.

[XDAGJ_TestNet_Tutorial](./docs/XDAGJ_TestNet_Tutorial_en.md)

[XDAGJ_Devnet_Tutorial](./docs/XDAGJ_Devnet_Tutorial_en.md)

[XDAGJ TestNet Explorer](http://146.56.240.230/)

## Develop

XDAGJ has basic pool functions. Follow-up work will improve system stability and add new functions. The goal is to prepare XDAG for entry into the metaverse. It is important to adopt excellent blockchain technology.

### XDAG Mars Project

Four stages:

#### Exploration phase: XDAGJ testnet is online (online, in beta)

- [x] Deploy XDAGJ test network environment, open beta

- [x] Implement the RandomX algorithm

- [x] Implement the libp2p network protocol

- [x] Testnet blockchain browser

- [x] Test coin acquisition

#### Landing phase: XDAGJ mainnet is online

- [x] Add test cases: write test cases for existing functions

- [x] Add log functions: provide a relatively complete log service to facilitate troubleshooting

- [x] Optimize synchronization protocol: ameliorate the existing synchronization protocol and improve synchronization efficiency

- [x] Implement the snapshot function: reduce the cost of running a mining pool and boost the loading process

- [x] Implement the RPC function: access Web3j, realize the standardization of the interface

- [x] Introduce the Stratum protocol for miners

- [x] Lightweight wallet application: join the browser wallet

- [x] Standardize the format of public and private keys, follow the BIPXX specification, and add mnemonic words to generate public and private key pairs

#### Expansion phase: XDAGJ & XRC

- [x] Improve the address block structure

- [x] Increase the handling fee

- [x] Optimize wallets to improve the user experience

- [ ] Support XRC standards

- [x] Decrease the threshold of mining pool users

- [ ] Open the whitelist to achieve complete decentralization

#### Prosperity phase: XDAGJ & DeFi

- [ ] Implement cross-chain protocols, compatible with access to multiple blockchain systems, to achieve intercommunication between XDAG and other chain worlds

- [ ] Implement the oracle function

- [ ] Join a distributed exchange

## Code

- Git

  We use the gitflow branch model

  - `master` is the main branch, which is also used to deploy the production environment. Cannot modify the code directly at any time.
  - `develop` is the development branch, always keep the latest code after completion and bug fixes.
  - `feature` is a new feature branch. When developing new features, use the `develop` branch as the basis, and create the corresponding `feature/xxx` branch according to the development characteristics.
  - `release` is the pre-launch branch. During the release test phase, the release branch code will be used as the benchmark test. When a set of features is developed, it will be merged into the develop branch first, and a release branch will be created when entering the test. If there is a bug that needs to be fixed during the testing process, it will be directly fixed and submitted by the developer in the release branch. When the test is completed, merge the release branch to the master and develop branches. At this time, the master is the latest code and is used to go online.
  - `hotfix` is the branch for repairing urgent problems on the line. Using the `master` branch as the baseline, create a `hotfix/xxx` branch. After the repair is completed, it needs to be merged into the `master` branch and the `develop` branch.

- Commit Message

  The submission message must begin with a short subject line, followed by an optional, more detailed explanatory text, which should be separated from the abstract by a blank line.

- Pull Request

  The pull request must be as clear and detailed as possible, including all related issues. If the pull request is to close an issue, please use the Github keyword convention [`close`, `fix`, or `resolve`](https://help.github.com/articles/closing-issues-via-commit-messages/). If the pull request only completes part of the problem, use the `connected` keyword. This helps our tool to correctly link the issue to the pull request.

- Code Style

  Use the `formatter_eclipse.xml` or `formatter_intellij.xml` of the `xdagj` code style in the `misc/code-style` folder.

- Code Review

  We value the quality and accuracy of the code. Therefore, we will review all of the code that needs to be changed.

## FAQ

- Time Synchronization Method with NTP
  [XDAGJ_Time_Synchronization](./docs/XDAGJ_Time_Synchronization_en.md)

- XDAGJ RPC Document
  [XDAGJ_RPC](./docs/XDAGJ_RPC.md)

## Contribution

- Security Question

  XDAGJ is still in the process of large-scale development, which means that there may be problems with existing codes or protocols, or errors that may exist in practice. If you find a security problem, we hope you can report it back as soon as possible.

  If you find a problem that may affect the security of the deployed system, we hope that you can send the problem privately to xdagj@xdag.io. Please do not discuss it publicly!

  If the problem is a weakness of the agreement or does not affect the online system, it can be discussed publicly and posted to [issues](https://github.com/XDagger/xdagj.git).

- Features

  We are very happy to add more useful and interesting new features to XDAGJ. You can suggest any interesting new features that you think would be beneficial.

  If you are interested in the development of XDAGJ, we also welcome you to join the developer team and contribute your strength to XDAGJ. You can get in touch with us at xdagj@xdag.io.

## Sponsorship

Since the launch of the Apollo Project, XDAGJ has made a significant breakthrough from 0 to 1. The development of XDAGJ has been on the right track. Your support can drive the successful implementation of XDAGJ technology.
XDAG：BkcVG4i1BfxUJLdNPdctaCReBoyn4j32d

## Other

[XDAGJ New Address Structure](./docs/New_Address_Structure.md)

[XDAGJ Libp2p Introduction](./docs/XDAGJ_Networking_Specification.md)

[XDAG Wiki](https://github.com/XDagger/xdag/wiki)

[XDAG Whitepaper](https://github.com/XDagger/xdag/blob/master/WhitePaper.md)

[XDAG Protocol](https://github.com/XDagger/xdag/blob/master/Protocol.md)

## License

[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FXDagger%2Fxdagj.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FXDagger%2Fxdagj?ref=badge_large)


[![Maven](https://img.shields.io/maven-central/v/org.primefaces/primefaces.svg)](https://repo.maven.apache.org/maven2/org/primefaces/primefaces/)
[![Actions Status CI](https://github.com/primefaces/primefaces/workflows/CI/badge.svg)](https://github.com/primefaces/primefaces/actions/workflows/build.yml)
[![Actions Status Integration Tests](https://github.com/primefaces/primefaces/workflows/IT/badge.svg)](https://github.com/primefaces/primefaces/actions/workflows/nightly.yml)
[![Sonar](https://sonarcloud.io/api/project_badges/measure?project=org.primefaces%3Aprimefaces&metric=alert_status)](https://sonarcloud.io/dashboard?id=org.primefaces%3Aprimefaces)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Discord Chat](https://img.shields.io/discord/557940238991753223.svg?color=7289da&label=chat&logo=discord)](https://discord.gg/gzKFYnpmCY)
[![Stackoverflow](https://img.shields.io/badge/StackOverflow-primefaces-chocolate.svg)](https://stackoverflow.com/questions/tagged/primefaces+jsf)
[![Prime Discussions](https://img.shields.io/github/discussions-search?query=org%3Aprimefaces&logo=github&label=Prime%20Discussions&link=https%3A%2F%2Fgithub.com%2Forgs%2Fprimefaces%2Fdiscussions)](https://github.com/orgs/primefaces/discussions)

[![PrimeFaces Hero](https://www.primefaces.org/wp-content/uploads/2021/10/PrimeFaces-GitHub-2021Q4.jpg "PrimeFaces Hero")](https://www.primefaces.org/showcase)

# PrimeFaces

This is an overview page, please visit [PrimeFaces.org](https://www.primefaces.org) for more information.

[![PrimeFaces Logo](https://www.primefaces.org/wp-content/uploads/2016/10/prime_logo_new.png)](https://www.primefaces.org/showcase)

### Overview
***

[PrimeFaces](https://www.primefaces.org/) is one of the most popular UI libraries in Java EE Ecosystem and widely used by software companies, world renowned brands, banks, financial institutions, insurance companies, universities and more. Here are [some of the users](https://www.primefaces.org/whouses) who notified us or subscribed to a [PrimeFaces Support Service](https://www.primefaces.org/support).

### Community <> Elite <> Pro
***

This is the open source code and issue tracker of the PrimeFaces master (a.k.a. community version).
Please check the following link for informations about Elite and Pro: [PrimeFaces Support](https://www.primefaces.org/support/)

What does that mean?
- PrimeFaces is developed by PrimeTek and the open source community.
- The most contributers here on GitHub are working on PrimeFaces in their spare time.
- PrimeTek pushes fixes and new features from their closed source Elite and Pro repositories to the community edition.
- We, the community on GitHub, only provide support for issues, which are reproducable with the current SNAPSHOT (scroll down for more information on how to use it).
- We are NOT able to port bugfixes to elite releases. This is up to PrimeTek and can e.g. be triggered with PrimeFaces PRO.

### Versions
***

Version | Binary | Source | JSF version | Java version | Documentation
------------ | -------------  | ------------- | ------------- | ------------- | ------------- |
![14.0.x](https://img.shields.io/maven-central/v/org.primefaces/primefaces.svg?versionPrefix=14&color=cyan)| [JAR](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/14.0.1/primefaces-14.0.1.jar)  | [Sources](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/14.0.1/primefaces-14.0.1-sources.jar)| 2.3 - 4.0 | 11 - ? | [14.0.1 Documentation](https://primefaces.github.io/primefaces/14_0_0/#/)
![13.0.x](https://img.shields.io/maven-central/v/org.primefaces/primefaces.svg?versionPrefix=13&color=cyan)| [JAR](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/13.0.10/primefaces-13.0.10.jar)  | [Sources](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/13.0.10/primefaces-13.0.10-sources.jar) | 2.0 - 4.0 | 8 - ? | [13.0.10 Documentation](https://primefaces.github.io/primefaces/13_0_0/#/)
![12.0.x](https://img.shields.io/maven-central/v/org.primefaces/primefaces.svg?versionPrefix=12&color=cyan)| [JAR](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/12.0.0/primefaces-12.0.0.jar)  | [Sources](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/12.0.0/primefaces-12.0.0-sources.jar) | 2.0 - 4.0 | 8 - ? | [12.0.0 Documentation](https://primefaces.github.io/primefaces/12_0_0/#/)

<details>
  <summary>Archive</summary>

Version | Binary | Source | JSF version | Java version | Documentation
------------ | -------------  | ------------- | ------------- | ------------- | ------------- |
11.0.0| [primefaces-11.0.0.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/11.0.0/primefaces-11.0.0.jar)  | [primefaces-11.0.0-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/11.0.0/primefaces-11.0.0-sources.jar) | 2.0 - 4.0 | 8 - ? | [11.0.0 Documentation](https://primefaces.github.io/primefaces/11_0_0/#/)
10.0.0| [primefaces-10.0.0.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/10.0.0/primefaces-10.0.0.jar)  | [primefaces-10.0.0-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/10.0.0/primefaces-10.0.0-sources.jar) | 2.0 - 3.0 | 8 - ? | [10.0.0 Documentation](https://primefaces.github.io/primefaces/10_0_0/#/)
8.0| [primefaces-8.0.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/8.0/primefaces-8.0.jar)  | [primefaces-8.0-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/8.0/primefaces-8.0-sources.jar) | 2.0 - 2.3 | 8 - ? | [8.0 Documentation](https://primefaces.github.io/primefaces/8_0/#/)
7.0| [primefaces-7.0.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/7.0/primefaces-7.0.jar)  | [primefaces-7.0-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/7.0/primefaces-7.0-sources.jar) | 2.0 - 2.3 | 7 - ? | [7.0 Documentation](https://primefaces.github.io/primefaces/7_0/#/)
6.2| [primefaces-6.2.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/6.2/primefaces-6.2.jar)  | [primefaces-6.2-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/6.2/primefaces-6.2-sources.jar) | 2.0 - 2.3 | 6 - ? | [6.2 Documentation](https://www.primefaces.org/docs/guide/primefaces_user_guide_6_2.pdf)
6.1| [primefaces-6.1.jar](http://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/6.1/primefaces-6.1.jar)  | [primefaces-6.1-sources.jar](http://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/6.1/primefaces-6.1-sources.jar) | 2.0 - 2.3 | 5 - ? | [6.1 Documentation](https://www.primefaces.org/docs/guide/primefaces_user_guide_6_1.pdf)
6.0| [primefaces-6.0.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/6.0/primefaces-6.0.jar)  | [primefaces-6.0-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/6.0/primefaces-6.0-sources.jar) | 2.0 - 2.2 | 5 - ? | [6.0 Documentation](https://www.primefaces.org/docs/guide/primefaces_user_guide_6_0.pdf)
5.3| [primefaces-5.3.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/5.3/primefaces-5.3.jar)  | [primefaces-5.3-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/5.3/primefaces-5.3-sources.jar) | 2.0 - 2.2 | 5 - ? | [5.3 Documentation](https://www.primefaces.org/docs/guide/primefaces_user_guide_5_3.pdf)
5.2| [primefaces-5.2.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/5.2/primefaces-5.2.jar)  | [primefaces-5.2-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/5.2/primefaces-5.2-sources.jar) | 2.0 - 2.2 | 5 - ? | [5.2 Documentation](https://www.primefaces.org/docs/guide/primefaces_user_guide_5_2.pdf)
5.1| [primefaces-5.1.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/5.1/primefaces-5.1.jar)  | [primefaces-5.1-sources.jar](https://search.maven.org/remotecontent?filepath=org/primefaces/primefaces/5.1/primefaces-5.1-sources.jar) | 2.0 - 2.2 | 5 - ? | [5.1 Documentation](https://www.primefaces.org/docs/guide/primefaces_user_guide_5_1.pdf)
</details>

For a full list of the available downloads, please visit the [download page](https://www.primefaces.org/downloads).

### Maven
***

##### Release

  ```xml
  <!-- Java EE / javax.* / JSF 2.3 -->
  <dependency>
      <groupId>org.primefaces</groupId>
      <artifactId>primefaces</artifactId>
      <version>14.0.1</version>
  </dependency>

  <!-- Jakarta EE / jakarta.* / Faces 4.0+  -->
  <dependency>
      <groupId>org.primefaces</groupId>
      <artifactId>primefaces</artifactId>
      <version>14.0.1</version>
      <classifier>jakarta</classifier>
  </dependency>
  ```

##### SNAPSHOT

  ```xml
  <!-- Java EE / javax.* / JSF 2.3 -->
  <dependency>
      <groupId>org.primefaces</groupId>
      <artifactId>primefaces</artifactId>
      <version>15.0.0-SNAPSHOT</version>
  </dependency>

  <!-- Jakarta EE / jakarta.* / Faces 4.0+  -->
  <dependency>
      <groupId>org.primefaces</groupId>
      <artifactId>primefaces</artifactId>
      <version>15.0.0-SNAPSHOT</version>
      <classifier>jakarta</classifier>
  </dependency>

  <repositories>
    <repository>
      <id>sonatype-snapshots</id>
      <name>Sonatype Snapshot Repository</name>
      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
      <releases>
          <enabled>false</enabled>
      </releases>
      <snapshots>
          <enabled>true</enabled>
      </snapshots>
    </repository>
  </repositories>
  ```

### Tag Library
***

The VDL documentation for the PrimeFaces tag libary can be found here: https://primefaces.github.io/primefaces/vdldoc/

### Usage
***

```xml
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:h="jakarta.faces.html"
	xmlns:f="jakarta.faces.core"
	xmlns:pt="jakarta.faces.passthrough"
	xmlns:jsf="jakarta.faces"
	xmlns:ui="jakarta.faces.facelets"
	xmlns:p="primefaces">

	<h:head>

	</h:head>

	<h:body>

		<p:spinner />

	</h:body>
</html>

```

### Demo
***
Please refer to the [showcase](https://www.primefaces.org/showcase) in order to see the full usage of the components. Sources of PrimeFaces showcase are available within module [primefaces-showcase](https://github.com/primefaces/primefaces/tree/master/primefaces-showcase).

### Contribution
***
Visit the [contribution](./CONTRIBUTING.md) page for detailed information.

### Release Instructions
***
- Run `mvn versions:set -DgenerateBackupPoms=false -DnewVersion=14.0.1` to update all modules versions
- Commit and push the changes to GitHub
- In GitHub create a new Release titled `14.0.1` to tag this release
- Run `mvn clean deploy -Prelease` to push to Maven Central
- Rename Milestone in GitHub Issues and close it
- Create a new Milestone

### License
***
Licensed under the MIT License.


# PowerSystemDataModel
[![Build Status](https://simona.ie3.e-technik.tu-dortmund.de/ci/buildStatus/icon?job=ie3-institute%2FPowerSystemDataModel%2Fdev)](https://simona.ie3.e-technik.tu-dortmund.de/ci/job/ie3-institute/job/PowerSystemDataModel/job/dev/)
[![Quality Gate Status](https://simona.ie3.e-technik.tu-dortmund.de/sonar/api/project_badges/measure?project=edu.ie3%3APowerSystemDataModel&metric=alert_status)](https://simona.ie3.e-technik.tu-dortmund.de/sonar/dashboard?id=edu.ie3%3APowerSystemDataModel)
[![codecov](https://codecov.io/gh/ie3-institute/PowerSystemDataModel/branch/master/graph/badge.svg)](https://codecov.io/gh/ie3-institute/PowerSystemDataModel)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/d1d73fb87e084904993f968178274835)](https://www.codacy.com/gh/ie3-institute/PowerSystemDataModel?utm_source=github.com&utm_medium=referral&utm_content=ie3-institute/PowerSystemDatamodel&utm_campaign=Badge_Grade)
[![License](https://img.shields.io/github/license/ie3-institute/powersystemdatamodel)](https://github.com/ie3-institute/powersystemdatamodel/blob/master/LICENSE)
[![Maven Central](https://img.shields.io/maven-central/v/com.github.ie3-institute/PowerSystemDataModel.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22com.github.ie3-institute%22%20AND%20a:%22PowerSystemDataModel%22)

Provides an extensive data model capable of modelling energy systems with high granularity e.g. for bottom-up simulations. Additionally, useful functions to process, augment and furnish model i/o information is provided. Effective handling of geographic information related to power grids is also possible. Currently, i/o processing capabilities are provided for *.csv* files.

**Supported physical models:**

	- Power Grids containing nodes, lines, switches and transformers
	- Conventional and renewable generating components such as fixed feed, biomass plants, wind turbines and photovoltaics
	- Power to heat units e.g. combined heat and power plants and heat pumps
	- Electrical storages, electric vehicles and charging stations
	- Thermal units consisting of thermal building and cylindrical storage models

**Supported simulation data:**

	Load profiles, weather data etc.

For more information visit [ReadTheDocs](https://powersystemdatamodel.readthedocs.io/en/latest/) or the [API docs](https://ie3-institute.github.io/PowerSystemDataModel/).


# Google Mobile Ads for Flutter

[![google_mobile_ads](https://github.com/googleads/googleads-mobile-flutter/actions/workflows/google_mobile_ads.yaml/badge.svg)](https://github.com/googleads/googleads-mobile-flutter/actions/workflows/google_mobile_ads.yaml)

This repository contains the source code for the Google Mobile Ads Flutter
plugin, which enables publishers to monetize [Flutter](https://flutter.dev/)
apps using the Google Mobile Ads SDK.

## Documentation

For instructions on how to use the plugin, please refer to the developer guides
for [AdMob](https://developers.google.com/admob/flutter/quick-start) and
[Ad Manager](https://developers.google.com/ad-manager/mobile-ads-sdk/flutter/quick-start).

## Downloads

See [pub.dev](https://pub.dev/packages/google_mobile_ads/versions) for the
latest releases of the plugin.

## Suggesting improvements

To file bugs, make feature requests, or to suggest other improvements, please
use [github's issue tracker](https://github.com/googleads/googleads-mobile-flutter/issues).

## Other resources

* [AdMob help center](https://support.google.com/admob/?hl=en#topic=7383088)
* [Ad Manager help center](https://support.google.com/admanager/?hl=en#topic=7505988)

## License

[Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)


tinylog 2
=========
[![Build](https://github.com/tinylog-org/tinylog/actions/workflows/build.yaml/badge.svg?branch=v2.8&event=push)](https://github.com/tinylog-org/tinylog/actions/workflows/build.yaml)
[![Code Coverage](https://codecov.io/gh/tinylog-org/tinylog/branch/v2.8/graph/badge.svg)](https://codecov.io/gh/tinylog-org/tinylog/branch/v2.8)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.tinylog/tinylog-impl/badge.svg)](https://search.maven.org/search?q=g:org.tinylog)
[![Percentage of issues still open](https://isitmaintained.com/badge/open/tinylog-org/tinylog.svg)](https://github.com/tinylog-org/tinylog/issues "Percentage of issues still open")

Example
-------

```java
import org.tinylog.Logger;

public class Application {

    public static void main(String[] args) {
        Logger.info("Hello {}!", "world");
    }

}
```

Outputting log entries to the console and rolling log files via *tinylog.properties*

```properties
level            = INFO

writer1          = console
writer1.format   = {date: HH:mm:ss.SSS} {class}.{method}() {level}: {message}

writer2          = rolling file
writer2.file     = logs/{date: yyyy-MM-dd}/log_{count}.txt
writer2.policies = startup, daily: 03:00
writer2.format   = {date: HH:mm:ss} [{thread}] {level}: {message}
```

More information about tinylog including a detailed user manual and the Javadoc documentation can be found on https://tinylog.org/v2/.

Contributing
------------

On GitHub, issues and pull requests are always welcome :)

For building tinylog or contributing to this project, please take a look at [contributing.md](./contributing.md).

License
-------

Copyright 2016-2024 Martin Winandy

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.


# Mine Little Pony

[![Current Version](https://img.shields.io/github/v/release/MineLittlePony/MineLittlePony)](https://github.com/MineLittlePony/MineLittlePony/releases/latest)
[![Build Status](https://github.com/MineLittlePony/MineLittlePony/actions/workflows/gradle-build.yml/badge.svg)](https://github.com/MineLittlePony/MineLittlePony/actions/workflows/gradle-build.yml)
![Downloads](https://img.shields.io/github/downloads/MineLittlePony/MineLittlePony/total.svg?color=yellowgreen)
[![Modrinth](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.modrinth.com%2Fv2%2Fproject%2Fmine-little-pony%2Fversion&query=%24%5B0%5D.version_number&label=modrinth)](https://modrinth.com/mod/mine-little-pony)
[![Discord Server](https://img.shields.io/discord/182490536119107584.svg?color=blueviolet)](https://discord.gg/HbJSFyu)
![License](https://img.shields.io/github/license/MineLittlePony/MineLittlePony)
[![Crowdin](https://badges.crowdin.net/mine-little-pony/localized.svg)](https://crowdin.com/project/mine-little-pony)
![](https://img.shields.io/badge/api-fabric-orange.svg)

Turns players and mobs into ponies.

https://minelittlepony-mod.com

## Building

1. JDK 17 is required. Install it using https://adoptium.net/?variant=openjdk17&jvmVariant=hotspot

2. Open a terminal window in the same directory as the sources (git clone or extracted from zip). Run the following command (windows).

```
gradlew build
```

3. After some time, the built mod will be in `/build/libs`.

## Installation

Fabric (And FabricAPI) are required. Please refer to their installation instructions here and come back once you have Fabric functioning.

Once you have fabric installed, simply download the MineLittlePony-version.jar for your particular version from [the releases page](https://github.com/MineLittlePony/MineLittlePony/releases) and place it into your mods folder next to the fabric-api jar and (optionally) the hdskins jar.

**Remember to use the fabric launcher profile when starting the game!**

## Maven

Stable Releases Channel: `https://repo.minelittlepony-mod.com/maven/release`

Unstable Snapshot Channel: `https://repo.minelittlepony-mod.com/maven/snapshot`

Dependency: `com.minelittlepony:minelittlepony:<version>`


[中文](README.zh-CN.md)

Your star is my motivation to keep going. If you like LiteFlow, please help me with a star in the upper right corner.

## Overview
LiteFlow is a lightweight and powerful rules engine framework, which can be used in the field of complex componenzed business orchestration. DSL rules drive the whole complex business, and can achieve smooth refresh hot deployment, supporting the embedding of multiple scripting language rules. Help the system become more silky and flexible.

LiteFlow was officially open-sourced in 2020 and has since become an indispensable presence in the field of open-source rule engines in China. What's more, the most crucial aspect is that LiteFlow is an open-source project that continues to iterate at a high speed.

LiteFlow is a community-driven project. We take community building very seriously. We have a community of more than 4000 users who can respond to any problems or suggestions they encounter.

You can find out how to join the community on the official website!

## Website url: [Click here to access the official website](https://liteflow.cc)
## Documents url: [Click here to enter the documentation to learn](https://liteflow.cc/pages/5816c5/)
## Demo projects: [DEMO1](https://github.com/bryan31/message-demo) | [DEMO2](https://gitee.com/bryan31/liteflow-example)

## Feature
* **Component definition unified:** All logic is a component, for all logic to provide a unified component implementation, small size, large energy.
* **Rules lightweight:** based on the rules file to arrange the process, learning the rules entry only takes 5 minutes, a read both understand.
* **Rule diversification:** rules support XML, JSON, YML three rule file writing methods, which you like to use.
* **Arbitrary arrangement:** Synchronous asynchronous mixing, no matter how complex the logic process, using LiteFlow rules, are easy to do, see the rules file to see how the logic works.
* **Rules can be loaded from anywhere:** The framework provides implementations of local file configuration sources and ZK configuration sources, as well as an extension interface that allows you to store rules anywhere.
* **Elegant hot refresh mechanism:** Rule changes, instant change of application rules without restarting your application. High concurrency does not cause any errors in executing rules due to refreshing rules.
* **Wide support:** LiteFlow works regardless of whether your project is built on Springboot, Spring, or any other Java framework.
* **JDK support:** From JDK8 to JDK17. Don't worry about JDK versions.
* **Full Springboot support:** Supports Springboot 2.X through the latest Springboot 3.X.
* **Scripting language support:** You can define script language nodes that support Groovy, Javascript, QLExpress, Python, Lua, Kotlin and Aviator. More script languages will be supported in the future.
* **Rule nesting support:** You can use simple expressions to create multiple nested complex logic layouts if you want.
* **Component retry support:** Components can support retry, and each component can customize the retry configuration and specify exceptions.
* **Context isolation mechanism:** Reliable context isolation mechanism, you do not have to worry about high concurrency data flow.
* **Declarative component support:** You can make any of your classes become components in seconds.
* **Detailed step information:** How your link performs, how much time each component takes, what errors are reported at a glance.
* **Stable and reliable:** has been iterating for more than 2 years, running stably on the core systems of major companies.
* **Excellent performance:** the framework itself consumes little extra performance, depending on the efficiency of your component execution.
* **Built-in simple monitoring:** Built-in a command line monitoring framework, you can know the running time ranking of each component.

## What scenarios apply

LiteFlow is a choreographed rules engine that is best at decoupling your systems. If you have a complex system with bloated code, the LiteFlow framework is a great solution.

LiteFlow uses regular expressions to drive the engine that you define. Have you ever thought about how to write multithreaded process choreography like the following?

These processes can be easily solved with LiteFlow! The framework has a very low threshold to learn the expression language, but it can accomplish extremely high complexity of the choreography.

LiteFlow has an extremely detailed and easy-to-understand documentation， it can help you solve more than 95% of your problems when using the framework.

LiteFlow has 1500 test cases and more. Complete documentation and comprehensive test case coverage guarantee the stability of LiteFlow framework!

Looking forward to your use！

**DISCORD LINK**

Discord Link: [https://discord.gg/MpdBSBnFTu](https://discord.gg/MpdBSBnFTu)

## 👑LF CLUB Community

LF CLUB is a premium paid community founded by the author of LiteFlow.

LF CLUB can help all users of the LiteFlow framework, as well as potential developers who want to use LiteFlow.

LF CLUB provides the following services:

**1.Weekly releases of a condensed analysis series for LF. As long as users study along with the Planet series articles, they will definitely be able to fully grasp LF.**

**2.Provide a Q&A service where members can ask unlimited questions and receive detailed replies and guidance on the same day.**

**3.Each enrolled user is entitled to two remote one-on-one tutoring sessions per year as part of the remote assistance service.**

**4.Every 1 to 2 days, there will be updates on LF's current progress and the focus of the next version.**

The LF CLUB can solve all the problems you encounter when using the LiteFlow framework. It offers a series of courses to help you gain a deep understanding of the LiteFlow framework. Unlike the WeChat community, the LF CLUB prioritizes the importance of questions and provides detailed answers.

Exclusive content helps you gain a profound understanding without the need to search for answers on other platforms. The author personally teaches, providing expert guidance at your fingertips, eliminating the need to seek help from others.

To join the LF CLUB, please scan the QR code below or click on the image to go directly to the website.

## 🦾Sponsor

**MISBoot低代码开发平台**

**云程企业级低代码平台**

**驰骋工作流引擎**

**FastBee物联网平台**

**JNPF低代码开发平台**

**WECHAT OFFICIAL ACCOUNT**

Since the community group is over 200 people, you need to be invited to join the group. Follow the WECHAT OFFICIAL ACCOUNT and click `Personal WeChat` to add me, I can invite you into the group

![official-wx](static/img/offical-wx.jpg)

Open source is not easy, please sponsor LiteFlow if you support it


[![actions]](https://github.com/aya-prover/aya-dev/actions/workflows/gradle-check.yaml)
[![maven]][maven-repo]
[![codecov]](https://codecov.io/gh/aya-prover/aya-dev)

[**Website**](https://www.aya-prover.org) contains:

+ Development blogs which are written for general audience
+ [Installation](https://www.aya-prover.org/guide/install.html)
  instructions (basically telling you what to download in [GitHub Releases])
+ [Tutorial for functional programming features](https://www.aya-prover.org/guide/haskeller-tutorial.html)
+ [Tutorial for theorem proving features](https://www.aya-prover.org/guide/prover-tutorial.html)

> [!WARNING]
>
> Aya is under active development, so don't be surprised about bugs, usability or performance issues
> (please file issues or create threads in discussions!), but we have the goal to make it as
> user-friendly as we can feasibly do.

## What to expect?

+ Dependent types, including Π-types, Σ-types, indexed families, etc.
  You could write a [sized-vector type][gadt].
+ Set-level cubical type theory (XTT).
  + Demonstration of [quotient-inductive-inductive types][hiir],
    no forward declaration or mutual block needed!
    We infer the type checking order by how definitions use each other.
  + Proof of `funExt` in [paths.aya][funExt].
+ Pattern matching with first-match semantics.
  Checkout the [red-black tree][rbtree] (without deletion yet).
+ A JIT-compiler that translates Aya code to higher-order abstract syntax in Java.
  This makes the interpreter to run tree-sort 10x faster! See [benchmark code][tbtree-bench].
+ Overlapping and order-independent patterns. Very [useful][oop] in theorem proving.
+ A literate programming mode with inline code fragment support, inspired from Agda and [1lab].
  You may preview the features (in Chinese)
  [here](https://blog.imkiva.org/posts/intro-literate-aya.html).
+ Binary operators, with precedence specified by a partial ordering
  (instead of a number like in Haskell or Agda).
+ A fairly good termination checker.
  We adapted some code from Agda's implementation to accept more definitions such as the
  `testSwapAdd` example in [this file][foetus] (which are rejected by, e.g. Arend).

See also [use as a library](#use-as-a-library).

[GitHub Releases]: https://github.com/aya-prover/aya-dev/releases/tag/nightly-build
[Java 21]: https://jdk.java.net/21
[1lab]: https://1lab.dev

## Contributing to Aya

> [!IMPORTANT]
>
> Since you need [Java 21] to set this project up, in case your choice
> of IDE is IntelliJ IDEA, version 2023.3 or higher is required.

+ Questions or concerns are welcomed in the discussion area.
  We will try our best to answer your questions, but please be nice.
+ We welcome nitpicks on error reporting! Please let us know anything not perfect.
  We have already implemented several user-suggested error messages.
+ Before contributing in any form, please read
  [the contribution guideline](CONTRIBUTING.md) thoroughly
  and make sure you understand your responsibilities.
+ Please follow [the Code of Conduct](CODE_OF_CONDUCT.md) to
  ensure an inclusive and welcoming community atmosphere.
+ Ask [@ice1000] or simply create a ticket in the discussion to become an organization member.
  + If you want to contribute, ask before doing anything.
    We are reluctant to accept PRs that contradict our design goals.
    We value your time and enthusiasm, so we don't want to close your PRs :)

[@ice1000]: https://github.com/ice1000
[actions]: https://github.com/aya-prover/aya-dev/actions/workflows/gradle-check.yaml/badge.svg
[codecov]: https://img.shields.io/codecov/c/github/aya-prover/aya-dev?logo=codecov&logoColor=white
[maven]: https://img.shields.io/maven-central/v/org.aya-prover/base?logo=gradle
[oop]: ../cli-impl/src/test/resources/shared/src/arith/nat/base.aya
[gadt]: ../cli-impl/src/test/resources/shared/src/data/vec/base.aya
[regularity]: ../cli-impl/src/test/resources/shared/src/paths.aya
[funExt]: ../cli-impl/src/test/resources/shared/src/paths.aya
[rbtree]: ../jit-compiler/src/test/resources/TreeSort.aya
[tbtree-bench]: ../jit-compiler/src/test/java/RedBlackTreeTest.java
[hiir]: https://www.aya-prover.org/blog/tt-in-tt-qiit.html
[foetus]: ../cli-impl/src/test/java/org/aya/test/fixtures/TerckError.java
[maven-repo]: https://repo1.maven.org/maven2/org/aya-prover

## Use as a library

It's indexed in [mvnrepository](https://mvnrepository.com/artifact/org.aya-prover),
and here are some example build configurations:

```xml
<!-- Maven -->
<dependency>
    <groupId>org.aya-prover</groupId>
    <artifactId>[project name]</artifactId>
    <version>[latest version]</version>
</dependency>
```

```groovy
// Gradle
implementation group: 'org.aya-prover', name: '[project name]', version: '[latest version]'
```

+ `[project name]` specifies the subproject of Aya you want to use,
  and the options are `pretty`, `base`, `cli-impl`, `parser`, etc.
  + The syntax definitions live in `syntax`.
  + The parser lives in `parser` (the generated parsing code) and `producer`
    (transformer from parse tree to concrete syntax tree).
  + The type checker lives in `base`.
  + The JIT compiler lives in `jit-compiler`.
  + The generalized pretty printing framework is in `pretty`.
  + The library system, literate mode, single-file type checker, and basic REPL are in `cli-impl`.
  + The generalized tree builder, generalized termination checker,
    and a bunch of other utilities (files, etc.) are in `tools`.
  + The generalized binary operator parser, generalized mutable graph are
    in `tools-kala` because they depend on a larger subset of the kala library.
  + The command and argument parsing framework is in `tools-repl`.
    It offers an implementation of jline3 parser based on Grammar-Kit and relevant facilities.
  + The literate-markdown related infrastructure is in `tools-md`.
    It offers commonmark extensions for literate mode of any language with a highlighter.
+ `[latest version]` is what you see on this badge ![maven].