# Objectify

Objectify is a Java data access API specifically designed for the Google Cloud Datastore (aka the Google App Engine Datastore aka Firestore in Cloud Datastore mode).  It occupies a "middle ground"; easier to use and more transparent than JDO or JPA, but significantly more convenient than the low-level API libraries that Google provides.  Objectify is designed to make novices immediately productive yet also expose the full power of the Datastore.

**Important note about versions**: Objectify v5 and prior use the _Google App Engine API for Java_ and therefore can only be used within Google App Engine Standard. Objectify v6+ uses the _Cloud Datastore API_ and can be used from anywhere - GAE Standard, GAE Flex, GCE, or outside Google Cloud entirely. See the [FAQ](https://github.com/objectify/objectify/wiki/FrequentlyAskedQuestions) for more information.

## Features

  * Objectify lets you persist, retrieve, delete, and query your own **typed objects**.
  ```
  @Entity
  class Car {
      @Id String vin; // Can be Long, long, or String
      String color;
  }

  ofy().save().entity(new Car("123123", "red")).now();
  Car c = ofy().load().type(Car.class).id("123123").now();
  ofy().delete().entity(c);
  ```
  * Objectify surfaces **all native datastore features**, including batch operations, queries, transactions, asynchronous operations, and partial indexes.
  * Objectify provides **type-safe key and query classes** using Java generics.
  * Objectify provides a **human-friendly query interface**.
  * Objectify can automatically **cache your data in memcache** for improved read performance.
  * Objectify can store polymorphic entities and perform **true polymorphic queries**.
  * Objectify provides a simple, **easy-to-understand transaction model**.
  * Objectify provides built-in facilities to **help migrate schema changes** forward.
  * Objectify provides **thorough documentation** of concepts as well as use cases.
  * Objectify has an **extensive test suite** to prevent regressions.

## Documentation

Full documentation is available in the [Objectify Wiki](https://github.com/objectify/objectify/wiki).

## Downloads

Objectify is released to the [Maven Central Repository](https://github.com/objectify/objectify/wiki/MavenRepository)
and can be downloaded directly from there.

## Help

Help is provided in the
[Objectify App Engine User Group](https://groups.google.com/forum/?fromgroups#!forum/objectify-appengine)


HTTP/1.1, HTTP/2 and WebSockets stub server for stubbing distributed web services in Docker and non-containerized environments for contract testing

[![CircleCI build master branch][circleci-badge]][circleci-link]
[![DockerHub][docker-hub-badge]][docker-hub-link]
[![GitHubStars][stars-badge]][stars-link]
[![GitHubForks][forks-badge]][forks-link]
[![codecov][codecov-badge]][codecov-link]
[![Maven Central][maven-badge]][maven-link]
[![Stackoverflow stubby4j][stackoverflow-badge]][stackoverflow-link]

[![stubb4j][logo-badge]][logo-link]

It is a highly flexible and configurable tool for testing interactions of service-oriented (SoA) or/and micro-services architectures (REST, SOAP, WSDL, etc.) over `HTTP/1.1`, `HTTP/2` and `WebSockets` protocols.

## Full documentation

[![pages-build-deployment][gh-pages-badge]][gh-pages-link] [![say thanks!](https://img.shields.io/badge/say%20thanks-!-1EAEDB.svg)](https://saythanks.io/to/azagniotov)

Full documentation hosted at [https://stubby4j.com](https://stubby4j.com), which includes a comprehensive user guide, various HOWTOs and usage examples.

## Key features

There are a number of use cases where you'd want to use `WebSockets`, `HTTP/1.1`, `HTTP/2` stub server in your development/QA environment. If you are a `Software Engineer`/`Test Engneer`/`QA`, then it should hit close to home with you. As an example, some of these use cases are outlined below (this is by no means an exhaustive list). Use `stubby4j` when you want to:

* Dockerzied. Stub out external services in a Docker based micro-service architecture (ARM64 Docker images are also available!)
* Support for `TLS` protocol versions `1.0`, `1.1`, `1.2` and `1.3`
* Support for `HTTP/2` over TCP (`h2c`) and `HTTP/2` over TLS (`h2`) on TLS v1.2 or newer using ALPN extension
* Verify that your code makes `HTTP/1.1` or `HTTP/2` (over TLS) requests with all the required parameters and/or headers
* Support for `WebSocket` protocol over `HTTP/1.1` (with `TLS` and without) for request verification, response stubbing, server push, and more
* Fault injection, where after X good responses on the same URI you get a bad one
* Dynamic flows. Multiple stubbed responses on the same stubbed URI to test multiple application flows
* Request proxying. Ability to configure a proxy/intercept where requests are proxied to another service
* Record & Replay. The HTTP response recorded on the first call, having the subsequent calls play back the recorded HTTP response, without actually connecting to the external server
* Regex support for dynamic matching on URI, query params, headers, POST payload (ie:. `mod_rewrite` in Apache)
* Dynamic token replacement in stubbed response, by leveraging regex capturing groups as token values during HTTP request verification
* Serve binary files as stubbed response content (images, PDFs. etc.)
* Support for delayed responses for performance and stability testing
* Support for HTTP `30x` redirects verification
* Support for different types of HTTP Authorizations: `Basic`, `Bearer Token` & others
* Embed stubby4j to create a web service SANDBOX for your integration test suite
* Verify that your code correctly handles HTTP response error codes

Full documentation hosted at [https://stubby4j.com](https://stubby4j.com), which includes a comprehensive user guide, various HOWTOs and usage examples.

## Minimal system requirements

### Running stubby4j as a standalone JAR

See [https://stubby4j.com/#minimal-system-requirements](https://stubby4j.com/#minimal-system-requirements) for more information.

### Running stubby4j as a pre-built Docker container

See [https://stubby4j.com/#running-in-docker](https://stubby4j.com/#running-in-docker) for more information.

### Docker Compose

See [https://stubby4j.com/#docker-compose](https://stubby4j.com/#docker-compose) for more information.

Full documentation hosted at [https://stubby4j.com](https://stubby4j.com), which includes a comprehensive user guide, various HOWTOs and usage examples.

<!-- references -->

[circleci-badge]: https://circleci.com/gh/azagniotov/stubby4j.svg?style=shield
[circleci-link]: https://circleci.com/gh/azagniotov/stubby4j

[codecov-badge]: https://codecov.io/gh/azagniotov/stubby4j/branch/master/graph/badge.svg?token=Lp9ajUmLrh
[codecov-link]: https://codecov.io/gh/azagniotov/stubby4j

[maven-badge]: https://img.shields.io/maven-central/v/io.github.azagniotov/stubby4j.svg?style=flat&label=maven-central
[maven-link]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.github.azagniotov%22%20AND%20a%3A%22stubby4j%22

[stubby4j-7-x-maven-link]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.github.azagniotov%22%20AND%20a%3A%22stubby4j%20AND%20v%3A%227.*
[stubby4j-6-x-maven-link]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.github.azagniotov%22%20AND%20a%3A%22stubby4j%20AND%20v%3A%226.*
[stubby4j-5-x-maven-link]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.github.azagniotov%22%20AND%20a%3A%22stubby4j%20AND%20v%3A%225.*
[stubby4j-4-x-maven-link]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.github.azagniotov%22%20AND%20a%3A%22stubby4j%20AND%20v%3A%224.*

[stackoverflow-badge]: https://img.shields.io/badge/stackoverflow-stubby4j-brightgreen.svg?style=flat
[stackoverflow-link]: http://stackoverflow.com/questions/tagged/stubby4j

[chat-badge]: https://badges.gitter.im/Join%20Chat.svg
[chat-link]: https://gitter.im/stubby4j/Lobby

[license-badge]: https://img.shields.io/badge/license-MIT-blue.svg?style=flat
[license-link]: http://badges.mit-license.org

[docker-hub-badge]: https://img.shields.io/docker/pulls/azagniotov/stubby4j.svg?style=flat
[docker-hub-link]: https://hub.docker.com/r/azagniotov/stubby4j

[stars-badge]: https://img.shields.io/github/stars/azagniotov/stubby4j.svg?color=success
[stars-link]: https://github.com/azagniotov/stubby4j

[logo-badge]: https://cdn.rawgit.com/azagniotov/stubby4j/master/assets/stubby-logo-duke-hiding.svg
[logo-link]: https://github.com/azagniotov/stubby4j

[forks-badge]: https://img.shields.io/github/forks/azagniotov/stubby4j.svg
[forks-link]: https://github.com/azagniotov/stubby4j

[gh-pages-badge]: https://github.com/azagniotov/stubby4j/actions/workflows/pages/pages-build-deployment/badge.svg?branch=gh-pages
[gh-pages-link]: https://github.com/azagniotov/stubby4j/actions/workflows/pages/pages-build-deployment


# Airlift
[![Maven Central](https://img.shields.io/maven-central/v/io.airlift/airlift.svg?label=Maven%20Central)](https://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.airlift%22)
[![Build Status](https://github.com/airlift/airlift/workflows/CI/badge.svg)](https://github.com/airlift/airlift/actions?query=workflow%3ACI+event%3Apush+branch%3Amaster)

Airlift is a framework for building REST services in Java.

This project is used as the foundation for distributed systems like [Trino (formerly PrestoSQL)](https://trino.io).

Airlift pulls together stable, mature libraries from the Java ecosystem into a simple, light-weight package that lets you focus on getting things done and includes built-in support for configuration, metrics, logging, dependency injection, and much more, enabling you and your team to ship a production-quality web service in the shortest time possible.

Airlift takes the best-of-breed libraries from the Java ecosystem and glues them together based on years of experience in building high performance Java services without getting in your way and without forcing you into a large, proprietary framework.

## Getting Started

- [Overview](docs/overview.md)
- [Getting Started](docs/getting_started.md)
  - Then see [Next Steps](docs/next_steps.md)

## Reference

- [Configuration](docs/ref_configuration.md)
- [Lifecycle/Bootstrapping](docs/ref_lifecycle.md)
- TBD - Concurrency
- TBD - Database Pooling
- TBD - Discovery
- TBD - Events
- TBD - HTTP server
- [HTTP client](http-client/README.md)
- TBD - Packaging
- TBD - Logging
- TBD - Tracing
- TBD - Maven BOM
- TBD - Jackson/JSON

## Recipes

- How do I ... [do conditional binding based on config](docs/recipes.md#how-do-i-do-conditional-binding-based-on-a-config-value)
- How do I ... [serve static HTML files](docs/recipes.md#how-do-i-serve-static-html-files)
- How do I ... [package my service](docs/recipes.md#how-do-i-package-my-service)
- TBD - How do I do ... ?


![Screenshot](https://raw.githubusercontent.com/opacapp/opacclient/master/img/github_banner.png)

Web Opac App
============

Android client for public libraries. See [opacapp.net](http://opacapp.net) for details.

Deprecated
----------

**This project will be end-of-life on 2024-06-30. Before that, we will still issue releases with significant bugfixes that affect our customers. After this, no more changes to this repository are planned and the app will be removed from the Play Store.**

More info on https://opac.app/en/

Features
--------
* Search the catalogue
* Make reservations
* Bookmarks
* Account view
* Extending lending periods
* Notification for return dates
* Search by ISBN using barcodes
* Much more cool stuff

Not all of the features are available for every library.

Support
-------
Supports web catalogues of different library system vendors, see our [website](http://de.opacapp.net/kompatibilitaet/) or [wiki](https://github.com/raphaelm/opacclient/wiki/Supported-library-types) for details.

Java Library (`libopac`)
------------------------
The underlying code that the app uses to connect to the different supported OPAC software systems and parse
data from them is available as a separate library called `libopac`. It can also be used in ordinary Java
projects because it does not depend on Android APIs. More information about the library can be found in
[its own README file](https://github.com/opacapp/opacclient/blob/master/opacclient/libopac/README.md).

Library configuration files
---------------------------
The JSON configuration files for each library previously located in the `opacclient/opacapp/src/main/assets/bibs` directory were recently removed from the repository and can be downloaded from our server. For more information about this, see [here](https://github.com/opacapp/opacclient/blob/master/opacclient/opacapp/LIBRARY_DATA.md).

Contributing
------------
We'd like to invite you to contribute to our project, e.g. by improving the user interface or adding support
for new libraries. Additionally, you could help to extend our test suite to increase this number: [![Coverage Status](https://coveralls.io/repos/github/opacapp/opacclient/badge.svg?branch=master)](https://coveralls.io/github/opacapp/opacclient?branch=master) :wink:.

Checking out the project with Android Studio should be fairly straightforward, but we
also have a little bit of information in the [project wiki](https://github.com/opacapp/opacclient/wiki).
Contributions are best submitted via GitHub pull requests.

If you get stuck anywhere in the process, please do not hesitate to create a draft pull request and ask us there!

Please note that we have a [Code of Conduct](https://github.com/opacapp/opacclient/blob/master/CODE_OF_CONDUCT.md)
in place that applies to all project-related communication.

License
-------
This code is released under the terms of the [MIT License](http://opensource.org/licenses/mit-license.php)

It contains several libraries:

* jsoup, (c) Jonathan Hedley and contributors, MIT License
* ACRA, (c) Kevin Gaudin and contributors, Apache License
* cwac-endless and cwac-adapter, (c) CommonsWare, LLC and Google, Inc., Apache License
* Android Support library, (c) Google Inc., Apache License
* NineOldAndroids, (c) Jake Wharton, Apache License
* android-flowlayout, (c) Artem Votincev, Apache License
* rv-joiner, (c) Evgeny Egorov, Apache License

Authors
-------
* [Raphael Michel](https://github.com/raphaelm) <mail@raphaelmichel.de>
* [Johan von Forstner](https://github.com/johan12345)

Many thanks go to our contributors, including:

* [Rüdiger Wurth](https://github.com/ruediger-w)
* [Simon Legner](https://github.com/simon04)
* [YKassim](https://github.com/YKassim)
* [AdamLazarus](https://github.com/AdamLazarus)
* [Sulekha Alse](https://github.com/YSulekha)
* [Caroline Ho](https://github.com/carolineh101)
* [Ceasar Jimenez](https://github.com/ceasarj)
* [Nico Puhlmann](https://github.com/NPuhlmann)
* [JustyAnOther](https://github.com/JustyAnOther)


# killbill-client-java
![Maven Central](https://img.shields.io/maven-central/v/org.kill-bill.billing/killbill-client-java?color=blue&label=Maven%20Central)

Java client library for Kill Bill.

## Kill Bill compatibility

| Client version | Kill Bill version |
| -------------: | ----------------: |
| 0.23.y         | 0.16.z            |
| 0.40.y         | 0.18.z            |
| 0.41.y         | 0.19.z            |
| 1.0.y          | 0.20.z            |
| 1.1.y          | 0.22.z            |
| 1.2.y          | 0.22.z            |
| 1.3.y          | 0.24.z            |

We've upgraded numerous dependencies in 1.2.x (required for Java 11 support).

## Usage

Add the library to your application:

```xml
<dependency>
    <groupId>org.kill-bill.billing</groupId>
    <artifactId>killbill-client-java</artifactId>
    <version>... release version ...</version>
</dependency>
```

The easiest way to get started is to look at our [Java client tutorial](https://docs.killbill.io/latest/java_client.html). We also provide a sample [Java client application](https://github.com/killbill/killbill-client-java-example). You can clone this project in order to get started.

When sending a body, if you are unsure which parameters to pass, take a look at the [Java api documentation](https://killbill.github.io/slate/?java#).

## Build

To build the library:

```
mvn clean install -DskipTests=true
```

This will produce several jars, including:

* killbill-client-java-x.y.z-SNAPSHOT.jar which contains the library only
* killbill-client-java-x.y.z-SNAPSHOT-jar-with-dependencies.jar which is a self-contained jar (library and dependencies)

## About

Kill Bill is the leading Open-Source Subscription Billing & Payments Platform. For more information about the project, go to https://killbill.io/.


# Apache Dubbo Project

[![Build and Test For PR](https://github.com/apache/dubbo/actions/workflows/build-and-test-pr.yml/badge.svg)](https://github.com/apache/dubbo/actions/workflows/build-and-test-pr.yml)
[![Codecov](https://codecov.io/gh/apache/dubbo/branch/3.2/graph/badge.svg)](https://codecov.io/gh/apache/dubbo)
![Maven](https://img.shields.io/maven-central/v/org.apache.dubbo/dubbo.svg)
![License](https://img.shields.io/github/license/alibaba/dubbo.svg)
[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/apache/dubbo.svg)](http://isitmaintained.com/project/apache/dubbo "Average time to resolve an issue")
[![Percentage of issues still open](http://isitmaintained.com/badge/open/apache/dubbo.svg)](http://isitmaintained.com/project/apache/dubbo "Percentage of issues still open")

Apache Dubbo is a high-performance, Java-based open-source RPC framework. Please visit the [official site](http://dubbo.apache.org) for the quick start guide and documentation, as well as the [wiki](https://github.com/apache/dubbo/wiki) for news, FAQ, and release notes.

We are now collecting Dubbo user info to help us to improve Dubbo further. Kindly support us by providing your usage information on [Wanted: who's using dubbo](https://github.com/apache/dubbo/discussions/13842), thanks :)

## Architecture

![Architecture](https://dubbo.apache.org/imgs/architecture.png)

## Features

* Transparent interface based RPC
* Intelligent load balancing
* Automatic service registration and discovery
* High extensibility
* Runtime traffic routing
* Visualized service governance

## Getting started

The following code snippet comes from [Dubbo Samples](https://github.com/apache/dubbo-samples.git). You may clone the sample project and step into the `dubbo-samples-api` subdirectory before proceeding.

```bash
git clone https://github.com/apache/dubbo-samples.git
cd dubbo-samples/1-basic/dubbo-samples-api
```

There's a [README](https://github.com/apache/dubbo-samples/blob/389cd612f1ea57ee6e575005b32f195c442c35a2/1-basic/dubbo-samples-api/README.md) file under `dubbo-samples-api` directory. We recommend referencing the samples in that directory by following the below-mentioned instructions:

### Maven dependency

```xml
<properties>
    <dubbo.version>3.2.13-SNAPSHOT</dubbo.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
        <version>${dubbo.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-dependencies-zookeeper</artifactId>
        <version>${dubbo.version}</version>
        <type>pom</type>
    </dependency>
</dependencies>
```

### Define service interfaces

```java
package org.apache.dubbo.samples.api;

public interface GreetingsService {
    String sayHi(String name);
}
```

*See [api/GreetingsService.java](https://github.com/apache/dubbo-samples/blob/389cd612f1ea57ee6e575005b32f195c442c35a2/1-basic/dubbo-samples-api/src/main/java/org/apache/dubbo/samples/api/GreetingsService.java) on GitHub.*

### Implement service interface for the provider

```java
package org.apache.dubbo.samples.provider;

import org.apache.dubbo.samples.api.GreetingsService;

public class GreetingsServiceImpl implements GreetingsService {
    @Override
    public String sayHi(String name) {
        return "hi, " + name;
    }
}
```

*See [provider/GreetingsServiceImpl.java](https://github.com/apache/dubbo-samples/blob/389cd612f1ea57ee6e575005b32f195c442c35a2/1-basic/dubbo-samples-api/src/main/java/org/apache/dubbo/samples/provider/GreetingsServiceImpl.java) on GitHub.*

### Start service provider

```java
package org.apache.dubbo.samples.provider;

import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.ServiceConfig;
import org.apache.dubbo.samples.api.GreetingsService;

import java.util.concurrent.CountDownLatch;

public class Application {
    private static String zookeeperHost = System.getProperty("zookeeper.address", "127.0.0.1");

    public static void main(String[] args) throws Exception {
        ServiceConfig<GreetingsService> service = new ServiceConfig<>();
        service.setApplication(new ApplicationConfig("first-dubbo-provider"));
        service.setRegistry(new RegistryConfig("zookeeper://" + zookeeperHost + ":2181"));
        service.setInterface(GreetingsService.class);
        service.setRef(new GreetingsServiceImpl());
        service.export();

        System.out.println("dubbo service started");
        new CountDownLatch(1).await();
    }
}
```

*See [provider/Application.java](https://github.com/apache/dubbo-samples/blob/389cd612f1ea57ee6e575005b32f195c442c35a2/1-basic/dubbo-samples-spring-xml/src/main/java/org/apache/dubbo/samples/provider/Application.java) on GitHub.*

### Build and run the provider

```bash
mvn clean package
mvn -Djava.net.preferIPv4Stack=true -Dexec.mainClass=org.apache.dubbo.samples.provider.Application exec:java
```

### Call remote service in the consumer

```java
package org.apache.dubbo.samples.client;

import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.ReferenceConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.samples.api.GreetingsService;

public class Application {
    private static String zookeeperHost = System.getProperty("zookeeper.address", "127.0.0.1");

    public static void main(String[] args) {
        ReferenceConfig<GreetingsService> reference = new ReferenceConfig<>();
        reference.setApplication(new ApplicationConfig("first-dubbo-consumer"));
        reference.setRegistry(new RegistryConfig("zookeeper://" + zookeeperHost + ":2181"));
        reference.setInterface(GreetingsService.class);
        GreetingsService service = reference.get();
        String message = service.sayHi("dubbo");
        System.out.println(message);
    }
}
```
*See [client/Application.java](https://github.com/apache/dubbo-samples/blob/389cd612f1ea57ee6e575005b32f195c442c35a2/1-basic/dubbo-samples-api/src/main/java/org/apache/dubbo/samples/client/Application.java) on GitHub.*

### Build and run the consumer

```bash
mvn clean package
mvn -Djava.net.preferIPv4Stack=true -Dexec.mainClass=org.apache.dubbo.samples.client.Application exec:java
```

The consumer will print out `hi, dubbo` on the screen.

### Next steps

* [Your first Dubbo application](https://dubbo.apache.org/en/blog/2018/08/07/dubbo-101/) - A 101 tutorial to reveal more details, with the same code above.
* [Dubbo user manual](https://dubbo.apache.org/en/overview/what/) - How to use Dubbo and all its features.
* [Dubbo developer guide](https://dubbo.apache.org/en/docs3-v2/java-sdk/) - How to involve in Dubbo development.
* [Dubbo admin manual](https://dubbo.apache.org/en/docs/v2.7/admin/ops/) - How to admin and manage Dubbo services.

## Building

If you want to try out the cutting-edge features, you can build with the following commands. (Java 1.8 is needed to build the master branch)

```
  mvn clean install
```

## Recommended Test Environment
To avoid intermittent test failures (i.e., flaky tests), it is recommended to have a machine or virtual machine with the following specifications:

* Minimum of 2CPUs.
* Minimum of 2Gb of RAM.

### How does the Dubbo Community collaborate?

The Dubbo Community primarily communicates on GitHub through issues, discussions, and pull requests.

- Issues: We use issues to track bugs and tasks. Any **work-related** item is associated with an issue.
- Discussions: We use discussions for questions, early proposals, and announcements. Any **idea-related** item is associated with a discussion.
- Pull Requests: We use pull requests to merge a set of changes from contributors into Dubbo.

We have also implemented [a project board](https://github.com/orgs/apache/projects/337) to monitor all the items.

Any essential changes should be discussed on the mailing list before they happen.

### Seeking for help

If you have questions such as:

- What is Dubbo?
- How do I use Dubbo?
- Why did an unexpected result occur?

Please start a discussion at https://github.com/apache/dubbo/discussions.

However, if you encounter the following situations:

- You're certain there's a bug that Dubbo needs to fix,
- You believe a feature could be enhanced,
- You have a detailed proposal for improving Dubbo,

Please open an issue at https://github.com/apache/dubbo/issues.

To ask effective questions, we recommend reading **[How To Ask Questions The Smart Way](https://github.com/selfteaching/How-To-Ask-Questions-The-Smart-Way/blob/master/How-To-Ask-Questions-The-Smart-Way.md)** first.

### Contribution

- Browse the "help wanted" tasks in the [Dubbo project board](https://github.com/orgs/apache/projects/337).
- Participate in discussions on the mailing list. See the subscription [guide](https://github.com/apache/dubbo/wiki/Mailing-list-subscription-guide).
- Respond to queries in the [discussions](https://github.com/apache/dubbo/issues).
- Resolve bugs reported in [issues](https://github.com/apache/dubbo/issues) and send us a pull request.
- Review existing [pull requests](https://github.com/apache/dubbo/pulls).
- Enhance the [website](https://github.com/apache/dubbo-website). We typically need:
    - Blog posts
    - Translations for documentation
    - Use cases showcasing Dubbo integration in enterprise systems.
- Improve the [dubbo-admin](https://github.com/apache/dubbo-admin).
- Contribute to the projects listed in the [ecosystem](https://github.com/apache/?q=dubbo&type=all&language=&sort=).
- Any other forms of contribution not listed above are also welcome.
- If you're interested in contributing, please send an email to [dev@dubbo.apache.org](mailto:dev@dubbo.apache.org) to let us know!

For further details, please refer our [guide](https://github.com/apache/dubbo/blob/master/CONTRIBUTING.md) about how to contribute Dubbo.

## Reporting bugs

Please follow the [template](https://github.com/apache/dubbo/issues/new?template=dubbo-issue-report-template.md) for reporting any issues.

## Reporting a security vulnerability

Please report security vulnerabilities to [us](mailto:security@dubbo.apache.org) privately.

## Contact

* Mailing list:
    * dev list: for dev/user discussion. [subscribe](mailto:dev-subscribe@dubbo.apache.org), [unsubscribe](mailto:dev-unsubscribe@dubbo.apache.org), [archive](https://lists.apache.org/list.html?dev@dubbo.apache.org),  [guide](https://github.com/apache/dubbo/wiki/Mailing-list-subscription-guide)

* Bugs: [Issues](https://github.com/apache/dubbo/issues/new?template=dubbo-issue-report-template.md)
* Gitter: [Gitter channel](https://gitter.im/alibaba/dubbo)
* Twitter: [@ApacheDubbo](https://twitter.com/ApacheDubbo)

## Dubbo ecosystem

* [Dubbo Ecosystem Entry](https://github.com/apache?utf8=%E2%9C%93&q=dubbo&type=&language=) - A GitHub group `dubbo` to gather all Dubbo relevant projects not appropriate in [apache](https://github.com/apache) group yet
* [Dubbo Website](https://github.com/apache/dubbo-website) - Apache Dubbo official website
* [Dubbo Samples](https://github.com/apache/dubbo-samples) - samples for Apache Dubbo
* [Dubbo Admin](https://github.com/apache/dubbo-admin) - The reference implementation for Dubbo admin
* [Dubbo Awesome](https://github.com/apache/dubbo-awesome) - Dubbo's slides and video links in Meetup

#### Language

* [Go](https://github.com/apache/dubbo-go) (recommended)
* [Rust](https://github.com/apache/dubbo-rust)
* [Node.js](https://github.com/apache/dubbo-js)
* [Python](https://github.com/dubbo/py-client-for-apache-dubbo)
* [PHP](https://github.com/apache/dubbo-php-framework)
* [Erlang](https://github.com/apache/dubbo-erlang)

## License

Apache Dubbo software is licensed under the Apache License Version 2.0. See the [LICENSE](https://github.com/apache/dubbo/blob/master/LICENSE) file for details.


* Please post questions in [Discussions](https://github.com/naver/ngrinder/discussions) not Issues.
* nGrinder 3.5.9-p1 has been released. See https://github.com/naver/ngrinder/releases
* Currently, we are working on the internal project not ngrinder. We will resume ngrinder dev from July, 2022.

nGrinder
========

[![Join the chat at https://gitter.im/naver/ngrinder](https://badges.gitter.im/naver/ngrinder.svg)](https://gitter.im/naver/ngrinder?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

nGrinder is a platform for stress tests that enables you to execute script creation, test execution, monitoring, and result report generator simultaneously. The open-source nGrinder offers easy ways to conduct stress tests by eliminating inconveniences and providing integrated environments.

Want to know what's changed from the original grinder platform?
 * Checkout https://github.com/naver/ngrinder/wiki/Architecture !

To get to know what's different from previous ngrinder 2.0?
 * Checkout http://www.slideshare.net/junhoyoon3994/ngrinder-30-load-test-even-kids-can-do !

To get started,
 * Checkout https://github.com/naver/ngrinder/wiki/User-Guide !

You can find out what nGrinder looks like with screen-shot.
 * https://github.com/naver/ngrinder/wiki/Screen-Shot

nGrinder consists of two major components.

nGrinder controller
 * a web application that enables the performance tester to create a test script and configure a test run

nGrinder agent
* a virtual user generator that creates loads.

Features
--------

* Use Jython script to create test scenario and generate stress in JVM using multiple agents.
* Extend tests with custom libraries(jar, py). It's unlimited practically.
* Provide web-based interface for project management, monitoring, result management and report management.
* Run multiple tests concurrently. Assign the pre-installed multiple agents to maximize each agent's utilization.
* Deploy agents on multiple network regions. Execute tests on various network locations
* Embed Subversion to manage scripts.
* Allow to monitor the state of agents generating stress and target machines receiving stress
* Proven solution which is used to test huge systems having more than 100 million users in NHN.

Download
--------

You can download the latest nGrinder in the following link.
* https://github.com/naver/ngrinder/releases

Quick Start
-------------
You can start nGrinder by executing following command.

```
java -Djava.io.tmpdir=${NGRINDER_HOME}/lib -jar ngrinder-controller-{version}.war
```

And then access it by using a browser. http://localhost:8080

> `NGRINDER_HOME` is usually `${HOME}/.ngrinder`.

Documentation
-------------
You can find the installation guide at the following link.
* https://github.com/naver/ngrinder/wiki/Installation-Guide

You can find the user guide at the following location link.
* https://github.com/naver/ngrinder/wiki/User-Guide

Contribution?
-------------
nGrinder welcomes any contributions from users. Please make all pull requests against master branches.
* Clone the REPO : 'git clone git://github.com/naver/ngrinder.git'

You can find general developer documents at the following link.
 * https://github.com/naver/ngrinder/wiki/Dev-Document

Versioning
----------

For transparency and insight into our release cycle, and to strive to maintain backward compatibility, Bootstrap will be maintained under the Semantic Versioning guidelines to the greatest extent possible.

Releases will be numbered in the following format:

      `<major>.<minor>.<patch>`

Release will be constructed based on the following guidelines:

* Breaking backward compatibility bumps the major (and resets the minor and patch)
* New additions without breaking backward compatibility bump the minor (and reset the patch)
* Bug fixes and small enhancement. changes bump the patch

Q/A and Bug tracker
-------------------
Found the apparent bug? Got a brilliant idea for an enhancement? Please create an issue here on GitHub so you can notify us!
* https://github.com/naver/ngrinder/issues

You can join our forum as well
* Dev : http://ngrinder.373.s1.nabble.com/ngrinder-dev-f1.html
* User Forum : http://ngrinder.373.s1.nabble.com/ngrinder-user-f50.html
* 中文论坛 (Chinese) : http://ngrinder.373.s1.nabble.com/ngrinder-user-cn-f114.html
* 한국어 유저 포럼 (Korean): http://ngrinder.373.s1.nabble.com/ngrinder-user-kr-f113.html

License
-------

     Copyright 2012-present NAVER Corp.

     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.

nGrinder includes the following software and libraries as follows. See the NOTICE folder for the license and copyright details for each.
* https://github.com/naver/ngrinder/tree/master/NOTICE


# DROID (Digital Record Object Identification)

[![CI](https://github.com/digital-preservation/droid/workflows/CI/badge.svg)](https://github.com/digital-preservation/droid/actions?query=workflow%3ACI)
[![Build status](https://ci.appveyor.com/api/projects/status/hrr6c3ckbghjvd7h/branch/master?svg=true)](https://ci.appveyor.com/project/dpreservation/droid/branch/master)
[![Coverage Status](https://coveralls.io/repos/github/digital-preservation/droid/badge.svg?branch=master)](https://coveralls.io/github/digital-preservation/droid?branch=master)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/uk.gov.nationalarchives/droid/badge.svg)](https://search.maven.org/search?q=g:uk.gov.nationalarchives)

## General Information

DROID is a software tool developed by [The National Archives](http://www.nationalarchives.gov.uk/ "The National Archives Website") to perform automated batch identification of file formats. Developed by its Digital Preservation Department as part of its broader digital preservation activities, DROID is designed to meet the fundamental requirement of any digital repository to be able to identify the precise format of all stored digital objects, and to link that identification to a central registry of technical information about that format and its dependencies.

DROID uses internal signatures to identify and report the specific file format versions of digital files. These signatures are stored in an XML signature file, generated from information recorded in the [PRONOM technical registry](http://www.nationalarchives.gov.uk/PRONOM/Default.aspx "PRONOM Technical Registry"). New and updated signatures are regularly added to PRONOM, and DROID can be configured to automatically download updated signature files.

DROID is a platform-independent Java application. It can be invoked from two interfaces:

* Java Swing GUI
* Command line interface

DROID allows files and folders to be selected from a file system for identification. This file list can be saved at any point. After the identification process had been run, the results can be output in various report formats, including CSV.

DROID is made available under the [New BSD License](https://raw.github.com/digital-preservation/droid/master/license.md).

More information can be found on the [DROID github pages](https://digital-preservation.github.io/droid/).

## Installing DROID

The latest binary file can be downloaded from [The National Archives website](https://www.nationalarchives.gov.uk/information-management/manage-information/preserving-digital-records/droid/ "The National Archives website").

## Running DROID

DROID can be run either as a graphical desktop application (GUI) or as a command line tool (CLI). GUI usage is explained in the [DROID User Guide](https://cdn.nationalarchives.gov.uk/documents/information-management/droid-user-guide.pdf).

### Basic command line examples

Assuming the `droid` executable (the `droid.sh` or `droid.bat` file) is in your PATH, run one of the following two commands to identify the file `file.jpg` or the directory `directory` (recursively, thanks to the `-R`, or `--recurse` switch), respectively:

~~~console
$ droid file.jpg
"ID","PARENT_ID","URI","FILE_PATH","NAME","METHOD","STATUS","SIZE","TYPE","EXT","LAST_MODIFIED","EXTENSION_MISMATCH","HASH","FORMAT_COUNT","PUID","MIME_TYPE","FORMAT_NAME","FORMAT_VERSION"
"1","","file:/home/user/file.jpg","/home/user/file.jpg","file.jpg","Signature","Done","1689552","File","jpg","2017-11-21T06:52:50","false","","1","fmt/1507","image/jpeg","Exchangeable Image File Format (Compressed)","2.3.x"

$ droid -R directory
...
~~~

If you don't need every bit of information that DROID outputs by default you can make it print only a limited set of columns using the `-co`, or `--columns` option (note the `-a`, it's required in this case!):

~~~console
$ droid -co NAME PUID -a file.jpg
"NAME","PUID"
"file.jpg","fmt/1507"
~~~

To remove even more noise from the output you can use the `-qc`, or `--quote-commas` switch which tells DROID to use quotes only where necessary:

~~~console
$ droid -qc -co NAME PUID -a file.jpg
NAME,PUID
file.jpg,fmt/1507
~~~

Beyond these basic invocations there are many additional options for advanced tweaking of DROID's operation. To learn about them run:

~~~console
$ droid --help
~~~

### Managing signature files in the command line interface

It's possible to update and switch signature files on the command line. Use `-c`, or `--check-signature-update` to check for updates; use `-d`, or `--download-signature-update` to download (and use) the latest signature files:

~~~console
$ droid -c
Container signature update Version 20231127 is available
Binary signature update Version 116 is available

$ droid -d
Signature update version 20.231.127 has been downloaded
Signature update version 116 has been downloaded
~~~

Use `-x`, or `--display-signature-file` to see the signature files that DROID currently uses for identification; use `-X`, or `--list-signature-files` to see all locally available signature files (i.e., all files that you have installed on your machine including those that are currently not in use):

~~~console
$ droid -x
Type: Container Version:  20231127  File name: container-signature-20231127.xml
Type: Binary Version:  116  File name: DROID_SignatureFile_V116.xml

$ droid -X
Type: Binary Version:  114  File name: DROID_SignatureFile_V114.xml
Type: Binary Version:  116  File name: DROID_SignatureFile_V116.xml
Type: Container Version:  20230822  File name: container-signature-20230822.xml
Type: Container Version:  20231127  File name: container-signature-20231127.xml
~~~

If for some reason you want to use another, possibly older signature file for identification you can change the default with the `-s`, or `--set-signature-file` option (remember to switch back to the latest version when you are done!):

~~~console
$ droid -s 114
Default signature file updated. Version: 114  File name: DROID_SignatureFile_V114.xml

$ droid -s 20230822
Default signature file updated. Version: 20230822  File name: container-signature-20230822.xml
~~~

## Building DROID

DROID can be built from source using Maven. The source code can be obtained from the Github repository at [https://github.com/digital-preservation/droid](https://github.com/digital-preservation/droid)

Once the code is cloned into a folder (e.g. `droid`), executing `mvn clean install` inside it will build the code. After a successful build, two archives are provided inside the `droid-binary/target` folder.

### Linux / OSX users

You will need JAVA 8 to 11 installed to run DROID.

Unpack the archive `droid-binary-${VERSION}-bin-unix.zip`, then use the `droid.sh` script to run the application.

### Windows users
Archive  `droid-binary-${VERSION}-bin-win64-with-jre.zip`

You will need JAVA 8 to 11 installed to run DROID. For Windows users who might not be able to install JAVA, the provided bundle includes JAVA 11.

Unpack the archive `droid-binary-${VERSION}-bin-win32-with-jre.zip`, then use the `droid.bat` script to run the application.

## Signatures

Since version 6.5, DROID adds some new capabilities to support developing and testing signatures.

[Signature syntax](Signature%20syntax.md) provides details on the types of signatures and regular expression syntax supported by DROID.

### sigtool

To aid work on signatures, we provide `sigtool`, packaged with DROID. `sigtool` is a simple command line application which can:

 * test binary or container signatures directly against files.
 * generate signature XML from binary or container signatures.
 * convert signatures between the original (binary) and the newer (container) syntax.
 * produce summaries of signature XML files, converting the XML back into signatures.
 * convert standard XML signature files into a simpler format, which uses the signatures directly.

More details are provided in [Sigtool's user guide](droid-binary/bin/Using%20sigtool.txt) .

### Simpler signature XML

Since version 6.5, DROID can compile signatures itself, without needing a full XML specification. Inside current signature files, the actual sequences to match are specified in various sub-elements and attributes of `<ByteSequence>` elements.

For example, the signature `{10-1024} 01 02 03 04 05 [00:30] * 01 02 03` is represented in signature XML by:

```xml
<ByteSequence Reference="BOFoffset">
    <SubSequence SubSeqMinOffset="10" SubSeqMaxOffset="1024">
        <Sequence>01 02 03 04 05</Sequence>
        <RightFragment MaxOffset="0" MinOffset="0" Position="1">[00:30]</RightFragment>
    </SubSequence>
    <SubSequence>
        <Sequence>01 02 03</Sequence>
    </SubSequence>
</ByteSequence>
```

DROID can now put a signature directly inside a `Sequence` attribute on the `<ByteSequence>` element, with no further XML required.  For example, the signature above can be simply written as:

```xml
<ByteSequence Reference="BOFoffset" Sequence="{10-1024} 01 02 03 04 05 [00:30] * 01 02 03" />
```

The full syntax can be used in either binary or container signature files.

## Developer related guidance

For any detais about contributing, testing, releasing, please check the [wiki](https://github.com/digital-preservation/droid/wiki)


# Welcome to MIT App Inventor

## Introduction

Learn more about [MIT App Inventor](http://appinventor.mit.edu).

This code is designed to be run in Google's App Engine. MIT runs a
public instance that all are welcome to use to build App Inventor
Applications. You do not need to compile or use this code if you wish
to build MIT App Inventor applications.

We provide this code for reference and for experienced people who wish
to operate their own App Inventor instance and/or contribute to the project.

This code is tested and known to work with Java 8.

## Contributors

The best way to go about integrating changes in App Inventor is to start a conversation in the [Open Source forum](https://community.appinventor.mit.edu/c/open-source-development/10) about whatever you intend to change or add.

We use ***very brief and informal*** design documents with descriptions of the proposed changes and screenshots of how the functionality would look like and behave, in order to gather as much feedback from the community, as early as possible. We generally use shared Google docs for this (with permissions to add comments), but any format that is accessible from a web browser (and allows comments) would do.

If you have skipped this step and have gone ahead and made your changes already, feel free to open a pull request, but don't be too surprised if we ask you to go back and document it in a design document. Remember that the main goal of doing this is ***to gather as much feedback, as early as possible***. We will also possibly ask you to put an instance with your changes on [appspot](http://appspot.com), and provide a modified Companion app (if that applies) so that reviewers can play with the changes before looking at the source.

Check out our open source [site](http://appinventor.mit.edu/appinventor-sources/) to find a lot more information about the project and how to contribute to it.

## Setup Instructions (Vagrant)

The easiest way to get a development environment up and running is to use the provided Vagrantfile. Install [Vagrant](https://vagrantup.com) and open a terminal in the root directory of this repository. Run the following commands

```bash
vagrant plugin install vagrant-vbguest  # optionally for virtualbox users, and only once
vagrant up                              # initializes the VM
```

It may take a few minutes for Vagrant to initialize as it will pull down a virtual machine image from the Internet and configure it with all of the App Inventor dependencies. Subsequent start-ups will be faster. Next, enter the virtual machine by running:

```bash
vagrant ssh
```

This should open up a terminal within the virtual machine in the directory `/vagrant/appinventor`. This directory is the same as the `appinventor` directory in this repository, shared between your host machine and the virtual machine. Any changes made on one side will be visible in the other. This allows you to edit files on your host machine with your preferred editor, while keeping the build environment relegated to the virtual machine.

Before you can build App Inventor, you will need to also obtain the dependencies as described [below](#checkout-dependencies) using `git submodule` command:

```bash
git submodule update --init
```

Now, you are ready to build App Inventor, you may now run:

```bash
ant
```

and to run App Inventor:

```bash
start_appinventor
```

Press Ctrl+C to quit the server. Enter exit at the prompt to leave the virtual machine. To reclaim resources when you are not actively developing, you can run `vagrant halt` to stop the virtual machine. To completely remove the virtual machine, run `vagrant destroy`. If you destroy the VM, you will need to start these instructions from the top.

Note 1: For macOS users, if you are using VirtualBox and get any error while initializing the VM it may be due to security restrictions in System Preferences, consider reading [this](https://medium.com/@Aenon/mac-virtualbox-kernel-driver-error-df39e7e10cd8) article.

Note 2: If it seems like none of the dependencies are installed in the VM, run ```vagrant provision```.

For better performance, consider using the manual instructions.

## Setup Instructions (iOS Support)

Building MIT App Inventor Companion for iOS requires an Apple
Macintosh computer running macOS 12 or later with Xcode 14 or later
installed. While earlier versions may work we provide no support for
building on versions below the ones stated. To install on a device,
you **must** have a valid Apple Developer account license and have
added the relevant mobile provisioning profiles from the Developer
portal to your Xcode organizer (see Apple's website on instructions on
how to do this).

To build the MIT App Inventor companion, you will need to create a
file called AICompanionApp.xcconfig in the components-ios directory
that sets your development team. The easiest way to do this is to copy
the AICompanionApp.xcconfig.sample file and edit it. Alternatively,
create a file with the following line:

```conf
DEVELOPMENT_TEAM = ID
```

where ID is the development team ID shown in the Apple Developer
Portal. This ID is unique to your developer account (individual or
organization).

## Setup Instructions (Manual)

This is a quick guide to get started with the sources. More detailed instructions can be found [here](https://docs.google.com/document/pub?id=1Xc9yt02x3BRoq5m1PJHBr81OOv69rEBy8LVG_84j9jc), a slide show can be seen [here](http://josmas.github.io/contributingToAppInventor2/#/), and all the [documentation](http://appinventor.mit.edu/appinventor-sources/#documentation) for the project is available in our [site](http://appinventor.mit.edu/appinventor-sources/).

### Dependencies

You will need a full Java JDK (version 8, OpenJDK preferred; JRE is not enough) and Python to compile and run the servers.

You will also need a copy of the [Google Cloud SDK](https://cloud.google.com/appengine/docs/standard/java/download) for Java and [ant](http://ant.apache.org/).

If you want to make changes to the source, you are going to need to run an automated test suite, and for that you will also need [phantomjs](http://phantomjs.org/). Have a look at the testing section for more information.

Note 1: If you are working on a 64-bit linux system, you need to install 32-bit version of: glibc(to get a 32-bit version of ld-linux.so), zlib and libstdc++.

If you are on a Debian-based distribution(Ubuntu), use:

    $ sudo apt-get install libc6:i386 zlib1g:i386 libstdc++6:i386

If you are on an RPM-based distribution(Fedora), use:

    $ sudo dnf install glibc.i686 zlib.i686 libstdc++.i686

Note 2: Certain Java 8 features, such as lambda expressions, are not supported on Android, so please don't use them in your changes to the source code.

### Forking or cloning

Consider ***forking*** the project if you want to make changes to the sources. If you simply want to run it locally, you can simply ***clone*** it.

#### Forking

If you decide to fork, follow the [instructions](https://help.github.com/articles/fork-a-repo) given by github. After that you can clone your own copy of the sources with:

    $ git clone https://github.com/YOUR_USER_NAME/appinventor-sources.git

Make sure you change *YOUR_USER_NAME* to your user name.

Configuring a remote pointing to this repository is also a good idea if you are forking:

    $ cd appinventor-sources
    $ git remote add upstream https://github.com/mit-cml/appinventor-sources.git

Finally, you will also have to make sure that you are ignoring files that need ignoring:

    $ cp sample-.gitignore .gitignore

### Checkout dependencies

App Inventor uses Blockly, the web-based visual programming editor from Google, as a core part of its editor. Blockly core is made available to App Inventor as a git submodule. The first time after forking or cloning the repository, you will need to perform the following commands:

    $ git submodule update --init

For developers who will be working on Blockly within the context of App Inventor, the preferred checkout procedure is to perform a `git submodule init`, edit the `.git/config` file to use the read/write SSH URL for [MIT CML's Blockly fork](https://github.com/mit-cml/blockly) instead of the public read-only HTTPS URL assumed by default (to support pushing changes). After changing `.git/config`, a `git submodule update` will pull the repository.

If you need to switch back to a branch that does contains the Blockly and Closure Library sources in the tree, you will need to run the command:

    $ git submodule deinit --all

to clear out the submodules ___before switching branches___. When switching back, you will need to repeat the initialization and update procedure above.

### Troubleshooting common installation issues

Run this command to run a self-diagnosis of your environment. This command tries to figure out common installation issues and offers you a solution to fix them yourself. Make sure this passes all the checks before you proceed further.

#### Linux and macOS

```bash
./buildtools doctor
```

#### Windows

```bash
buildtools doctor
```

## Compiling

Before compiling the code, an [auth key](https://docs.google.com/document/pub?id=1Xc9yt02x3BRoq5m1PJHBr81OOv69rEBy8LVG_84j9jc#h.yikyg2e1rfut) is needed. You can create one by running the following commands:

    $ cd appinventor
    $ ant MakeAuthKey

Once the key is in place, type the following to compile (from the appinventor folder):

    $ ant

You will see a lot of stuff in the terminal and after a few minutes (it can take from 2 to 10 minutes, depending on your machine specs) you should see a message saying something like *Build Successful*.

### Notes on compiling for iOS

If you are compiling on a Mac and **are not** interested in building
the companion for iOS, you must set the property `skip.ios` to `true`,
for example:

```bash
ant -Dskip.ios=true
```

iOS builds will automatically be skipped on other operating systems.

We generally use Xcode for iOS development. Open the
AppInventor.xcworkspace file to view the Xcode workspace. This
workspace includes three projects:

* SchemeKit: A Scheme implementation for iOS built on Picrin with
  additions to support foreign function calls to Objective-C and
  Swift. This also implements some basic types from App Inventor
  including YailList and YailDictionary.
* AIComponentKit: App Inventor component implementations, mostly
  written in Swift.
* AICompanionApp: The App Inventor companion written in Swift.

In Xcode you can run the AICompanionApp on your device by selecting
the AICompanionApp target's Debug scheme and pressing the Run button.

For more information about iOS support, please see
[README.ios.md](README.ios.md).

## Running the Server(s)

There are two servers in App Inventor, the main server that deals with project information, and the build server that creates apk files. More detailed information can be found in the [App Inventor Developer Overview](https://docs.google.com/document/d/1hIvAtbNx-eiIJcTA2LLPQOawctiGIpnnt0AvfgnKBok/pub) document.

### Running the main server

    $ your-google-cloud-SDK-folder/bin/java_dev_appserver.sh --port=8888 --address=0.0.0.0 appengine/build/war/

Make sure you change *your-google-cloud-SDK-folder* to wherever in your hard drive you have placed the Google Cloud SDK.

### Running the build server

The build server can be run from the terminal by typing:

    $ cd appinventor/buildserver
    $ ant RunLocalBuildServer

Note that you will only need to run the build server if you are going to build an app as an apk. You can do all the layout and programming without having the build server running, but you will need it to download the apk.

### Accessing your local server

You should now be up and running; you can test this by pointing your browser to:

    http://localhost:8888

Before entering or scanning the QR code in the Companion, check the box labeled "Use Legacy Connection".

### Running tests

The automated tests depend on [Phantomjs](http://phantomjs.org/). Make sure you install it and add it to your path. After that, you can run all tests by typing the following in a terminal window:

    $ ant tests

### Building Release Code

Release builds with optimizations turned on for the web components of the system can be done by passing `-Drelease=true` to `ant`, e.g.:

```
ant -Drelease=true noplay
```

The release configuration sets the following additional options:

- Blockly Editor is compiled with SIMPLE optimizations (instead of RAW)
- App Engine YaClient module is compiled without `<collapse-all-properties/>` to create per-language/browser builds
- App Engine YaClient module is compiled with optimization tuned to 9 and with 8 threads

### Hot-reloading GWT code with 'Super Dev Mode'

1. Run `ant devmode`
2. [Run the main server](#running-the-main-server).
3. Open http://localhost:9876 (*GWT CodeServer*) and drag the two bookmarklets (*Dev Mode On & Off*) to the bookmarks bar.
4. Open http://localhost:8888 (*App Engine server*)
5. To see changes "live":
   1. Save your changes in file.
   2. Click on the *"Dev Mode On"* bookmarklet.
   3. A popup will be shown with a button to compile `ode` module.
   4. Press that button to compile. (That button is actually a bookmarklet. So you can drag this button to the bookmarks bar as well. This will come handy for subsequent compilations)
   5. After that, *GWT CodeServer* will compile the module incrementally.
   6. Refresh the page and that's it! The changes are live.

Logs can be found at http://localhost:9876/log/ode and SourceMaps at http://localhost:9876/sourcemaps/ode

## Need Help?

Join [our community](https://community.appinventor.mit.edu/).


Eureka
======
[![build](https://github.com/Netflix/eureka/actions/workflows/nebula-snapshot.yml/badge.svg)](https://github.com/Netflix/eureka/actions/workflows/nebula-snapshot.yml)

Eureka is a RESTful (Representational State Transfer) service that is primarily used in the AWS cloud for the purpose of
discovery, load balancing and failover of middle-tier servers. It plays a critical role in Netflix mid-tier infra.

Building
--------
The build requires `java8` because of some required libraries that are `java8` (`servo`), but the source and target
compatibility are still set to `1.7`. Note that tags should be checked out to perform a build.

Contributing
------------
For any non-trivial change (or a large LoC-wise change), please open an issue first to make sure there's alignment on
the scope, the approach, and the viability.

Support
----------
Community-driven mostly, feel free to open an issue with your question, the maintainers are looking over these
periodically. Issues with the most minimal repro possible have the highest chance of being answered.

Documentation
--------------
Please see [wiki](https://github.com/Netflix/eureka/wiki) for detailed documentation.


# Native-platform: Java bindings for native APIs

A collection of cross-platform Java APIs for various native APIs. Currently supports OS X, Linux, Windows and FreeBSD
on Intel architectures.

These APIs support Java 5 and later. Some of these APIs overlap with APIs available in later Java versions.

## Available bindings

### Terminal and console

These bindings work for the UNIX terminal, the Windows console and Mintty from Cygwin and MSys on Windows.

* Determine whether stdin/stdout/stderr are attached to a terminal.
* Query the terminal size. Not supported for Mintty
* Change foreground color on the terminal.
* Switch between bold and normal text mode on the terminal.
* Switch between dim, bright and normal text intensity on the terminal.
* Move terminal cursor up, down, left, right, start of line.
* Clear to end of line.
* Show and hide the cursor.
* Read raw input from the terminal. Not support for Mintty.
* Read arrow keys and other function keys from the terminal. Not support for Mintty.

See [Terminals](native-platform/src/main/java/net/rubygrapefruit/platform/terminal/Terminals.java)

* Utility class to display various kinds of prompts to the user on the terminal.

See [Prompter](native-platform/src/main/java/net/rubygrapefruit/platform/prompts/Prompter.java)

### System information

* Query kernel name and version.
* Query machine architecture.
* Query hostname.
* Query total and available memory (OS X and Windows only).
* Query system commit total and limit (Windows only).

See [SystemInfo](native-platform/src/main/java/net/rubygrapefruit/platform/SystemInfo.java)

### Processes

* Query the PID of the current process.
* Query and set the process working directory.
* Query and set the process environment variables.
* Detach process from its controlling console

See [Process](native-platform/src/main/java/net/rubygrapefruit/platform/Process.java)

### File systems

* Query and set UNIX file mode.
* Create and read symbolic links on UNIX and Windows.
* Query UNIX file uid and gid.
* Query file type, size and timestamps.
* Query directory contents.

See [Files](native-platform/src/main/java/net/rubygrapefruit/platform/file/Files.java)

* List the available file systems on the machine and details of each file system.
* Query file system mount point.
* Query file system type.
* Query file system device name.
* Query whether a file system is local or remote.
* Query whether a file system is case-sensitive and case preserving.

See [FileSystems](native-platform/src/main/java/net/rubygrapefruit/platform/file/FileSystems.java)

### Windows registry

* Query registry value.
* Query the subkeys and values of a registry key.

See [WindowsRegistry](native-platform/src/main/java/net/rubygrapefruit/platform/WindowsRegistry.java)

## Supported platforms

Currently ported to OS X, Linux, FreeBSD and Windows. Support for Solaris is a work in progress. Supported on:

* OS X, version 10.13 and later (x86_64)
* Fedora 23 and later (amd64).
* Ubuntu 8.04 and later (amd64).
* Ubuntu 18.04 and later (aarch64).
* FreeBSD 10 and later (amd64).
* Windows XP and later (amd64, i386). Console integration works with cmd.exe, powershell, ConEmu, Mintty from Cygwin, Mintty from Msys (includes Git for Windows).

## Using

Include `native-platform.jar` and `native-platform-${os}-${arch}.jar` in your classpath. From Gradle, you can do
this:

    repositories {
        jcenter()
    }

    dependencies {
        compile "net.rubygrapefruit:native-platform:0.21"
    }

You can also download the Jars from [bintray](https://bintray.com/adammurdoch/maven/net.rubygrapefruit%3Anative-platform)

A test application is also available from [bintray](https://bintray.com/adammurdoch/maven/net.rubygrapefruit%3Anative-platform-test)

Some sample code to use the terminal:

    import net.rubygrapefruit.platform.Native;
    import net.rubygrapefruit.platform.terminal.Terminals;
    import net.rubygrapefruit.platform.terminal.TerminalOutput;
    import static net.rubygrapefruit.platform.terminal.Terminals.Output.*;

    Terminals terminals = Native.get(Terminals.class);

    // check if terminal
    terminals.isTerminal(Stdout);

    // use terminal
    TerminalOutput stdout = terminals.getTerminal(Stdout);
    stdout.bold();
    System.out.println("bold text");

## Changes

### 0.22 (unreleased)

* Remove support for 32bit Linux & FreeBSD, as well as support for FreeBSD < 10.
* Implement `Memory` and add `WindowsMemory` for Windows.

### 0.21

* Some preparation for a new API to watch the file system for changes.

### 0.20

* Removed `FileEvents` API for watching the file system for changes.

### 0.19

* Added `SystemInfo.getHostname()`. Thanks to [Tom Dunstan](https://github.com/tomdcc)
* Fixed terminal integration on Arch linux.
* Fixed terminal integration on Amazon linux 2 aarch64.

### 0.18

* Support for symlinks on Windows. Thanks to [Renaud Paquay](https://github.com/rpaquay).
* Fixed handling of long paths on Windows. Thanks to [Renaud Paquay](https://github.com/rpaquay).
* Support for Linux on aarch64. Thanks to [Amey](https://github.com/ameyp).

### 0.17

* Fixed handling of supplementary characters in environment variable values. Thanks to [Gary Hale](https://github.com/ghale).
* Added `TerminalInput.supportsRawMode()` to determine whether terminal supports raw mode.
* Improve `Prompter` to show an alternate UI when the terminal input does not support raw mode.

### 0.16

* Change `Terminals` to support running under Mintty from Cygwin and MSYS on Windows. Supported for Windows 2008 and later. `TerminalOutput` is supported, however `TerminalInput` is not.

### 0.15

* Fixed `Files.stat()` when the path points to a descendent of a file. Thanks to [Gary Hale](https://github.com/ghale).
* Renamed `Terminal` to `TerminalOutput`.
* Moved some types to subpackages.
* Added `TerminalInput` to read text from the terminal. Supports raw mode and arrow keys.
* Added method to `Terminals` to determine whether stdin is attached to a terminal.
* Added method to `Terminals` to force the use of ANSI escape sequences to write the terminal output.
* Added methods to `TerminalOutput` to show and hide the cursor.
* Added methods to `TerminalOutput` to set foreground text color to its default value.
* Added methods to `TerminalOutput` to set bright and dim foreground text intensity.
* Added methods to `TerminalOutput` to write text to the terminal. Anything written to `System.out` or `System.err` is no longer automatically flushed before cursor or text attributes are changed.
* Added `Prompter` utility class to display prompts on the terminal to ask the user various questions.
* Moved releases to JCenter.

### 0.14

* Added `Memory`, for OS X only. Thanks to [Paul Merlin](https://github.com/eskatos)
* `NativeIntegrationLinkageException` is thrown by `Native.get()` when a particular native library cannot be loaded due to a linkage error.

### 0.13

* Added overloads of `Files.stat()` and `Files.listDir()` that follow links.
* Improvements to error handling for `Files.stat()` and `listDir()`.
* Fixes for build time detection of ncurses 6. Thanks to [Marcin Zajączkowski](https://github.com/szpak)

### 0.12

* Added `Files.listDir()`.
* Fixes for terminal integration for Linux distributions that use ncurses 6, such as Fedora 24 and later.
* Fixes for running on FreeBSD 10 and later without requiring GCC to be installed on the machine.

### 0.11

* Added support to detach the current process from its controlling console. Thanks to [Gary Hale](https://github.com/ghale).
* Fixes for handling Windows shares from Linux. Thanks to [Thierry Guérin](https://github.com/SchwingSK).
* Added initial implementation of `FileEvents`, which allows an application to listen for changes to a file system directory.
* Added more properties to `PosixFile`.
* Added `Files` and `WindowsFiles`.
* Added `FileSystem.isCaseSensitive()` and `FileSystem.isCasePreserving()`.
* Fixes running under GCJ.

### 0.10

* Fixes for broken 0.9 release.

### 0.9

* Fixes for non-ascii file names on OS X when running under the Apple JVM.

You should avoid using this release, and use 0.10 or later instead.

### 0.8

* Ported to FreeBSD. Thanks to [Zsolt Kúti](https://github.com/tinca).

### 0.7

* Some fixes for a broken 0.6 release.

### 0.6

* Some fixes for Windows 7 and OS X 10.6.

You should avoid using this release, and use 0.7 or later instead.

### 0.5

* Query the available values of a Windows registry key. Thanks to [Michael Putters](https://github.com/mputters).

### 0.4

* Get file type.
* Query Windows registry value and subkeys.
* Fixes to work on 64-bit Windows XP.

### 0.3

* Get and set process working directory.
* Get and set process environment variables.
* Launch processes.
* Fixed character set issue on Linux and Mac OS X.
* Fixes to work with 64-bit OpenJDK 7 on Mac OS X. Thanks to [Rene Groeschke](https://github.com/breskeby).

### 0.2

* Fixes to make native library extraction multi-process safe.
* Fixes to windows terminal detection and reset.

### 0.1

* Initial release.

# Development

## Building

This project uses (Gradle)[https://www.gradle.org] to build. Just run `gradlew` in the root of the source repo.
You will need Java 8 or later to run the tests.

### Ubuntu

The g++ compiler is required to build the native library. You will need to install the `g++` package for this.
Alternatively, you can use the Clang C++ compiler.

You need to install the `libncurses5-dev` package to pick up the ncurses header files. Also worth installing the `ncurses-doc` package too.

#### 64-bit machines with multi-arch support

Where multi-arch support is available (e.g. recent Ubuntu releases), you can build the i386 and amd64 versions of the library on the
same machine.

You need to install the `gcc-multilib` and `g++-multilib` packages to pick up i386 support.

You need to install the `lib32ncurses5-dev` package to pick up the ncurses i386 version.

### Windows

You need to install Visual studio 2012 or later, plus the Windows SDK to allow you to build both x86 and x64 binaries.

### OS X

The clang compiler is required to build the native library. You will need to install the XCode command-line tools for this.

### Solaris

For Solaris 11, you need to install the `development/gcc-45` and `system/header` packages.

## Running

Run `gradlew installDist` to install the test application into `test-app/build/install/native-platform-test`. Or
`gradle distZip` to create an application distribution in `test-app/build/distributions/native-platform-test-$version.zip`.

You can run `$INSTALL_DIR/bin/native-platform-test` to run the test application.

## Testing integration with another project

When developing a new feature in native platform, you often want to test the features in a real-world project which uses native platform.
There are various ways how to test the changes of native platform in the consuming project.

### Use composite build on a developer machine

#### From the command line

From the checkout directory of the consuming project you can run:

```sh
./gradlew --include-build ../native-platform ...
```

This assumes that `native-platform` is checked out in `../native-platform` relative to the consuming project.

#### From IDEA

In IDEA, open the consuming project.
Then [link the `native-platform` project](https://www.jetbrains.com/help/idea/gradle.html#link_gradle_project).
Finally, add the linked `native-platform` project [as a participant to the Gradle build](https://www.jetbrains.com/help/idea/work-with-gradle-projects.html#gradle_composite_build) and sync the consuming project.

> **WARNING**: You need to use IDEA 2020.1 for the composite build to work.
> See https://youtrack.jetbrains.com/issue/IDEA-228368 and https://youtrack.jetbrains.com/issue/IDEA-206799.

### Use a published snapshot on a developer machine/CI

- Publish a snapshot from the branch you want to test by using [this Teamcity build](https://builds.gradle.org/buildConfiguration/GradleNative_NativePlatform_Publishing_PublishJavaApiSnapshot?mode=builds).
- Change the version of native platform in the consuming project to match the version you just published, e.g. `0.22-snapshot-20200128143135+0000`,
  and push the changes to a branch.
- Run some tests on CI on the branch of the consuming project you just pushed.
- Test what you want to test on the consuming project.

### Use `mavenLocal()` on a developer machine

- Install a dev version of native platform to your local Maven repository by running
    ```sh
    ./gradlew publishToMavenLocal -PonlyLocalVariants
    ```
- Add `mavenLocal()` as a repository in the consuming project.
- Change the version of native platform in the consuming project to match the version you just built, e.g. `0.22-dev`.
- Test what you want to test on the consuming project.

# Releasing

See [this issue](https://github.com/gradle/native-platform/issues/271) first.

In the meantime, this [TC job](https://builds.gradle.org/buildConfiguration/GradleNative_NativePlatform_Publishing_PublishJavaApiAlpha?branch=&buildTypeTab=overview&mode=builds) should be used to publish a milestone.
[Add a tag](https://github.com/gradle/native-platform/tags) afterward.

To publish manually:

1. Check the version number in `build.gradle`.
2. Create a tag
3. Build each variant.
    1. Checkout tag.
    2. `./gradlew clean :native-platform:test :native-platform:uploadJni -Prelease -PpublishUserName=<> -PpublishApiKey=<>`.
4. Build Java library:
    1. Checkout tag.
    2. `./gradlew clean :native-platform:test :native-platform:uploadMain -Prelease -PpublishUserName=<> -PpublishApiKey=<>`
5. Build the test app:
    1. Checkout tag.
    2. `./gradlew clean :test-app:uploadMain -Prelease -PpublishUserName=<> -PpublishApiKey=<>`
6. Publish on bintray
7. Checkout master
8. Increment version number in `gradle.properties` and this readme.
9. Push changes.

Use `-Pmilestone` instead of `-Prelease` to publish a milestone version.

## Testing

* Test on IBM JVM.
* Test on Java 5, 6, 7.
* Test on Windows 7, Windows XP

## TODO

### Fixes

* OS X: Watch for changes to files in directory.
* FreeBSD: Watch for changes to files in directory.
* Linux: Fix spurious change event on close.
* All: Handle deletion and recreation of watched file/directory.
* All: Watch for creation and changes to missing file/directory.
* Windows: Watch for changes to a file (directory works, file does not).
* All: `FileWatch` tests: file truncated, last modified changed, content changed, recreated as file/dir, file renamed
* All: Thread safety for `FileWatch`.
* All: Bulk read of multiple file change events, coalesce events, use background thread to drain queue.
* Linux: Fix detection of multiarch support
* FreeBSD: Fix detection of multiarch support
* All: `Process.getPid()` should return a long
* All: fail subsequent calls to `Native.get()` when `Native.initialize()` fails.
* Posix: allow terminal to be detected when ncurses cannot be loaded
* Windows: fix detection of shared drive under VMWare fusion and Windows XP
* Windows: restore std handles after launching child process
* Linux: detect remote filesystems.
* All: cache reflective lookup in native functions.
* Solaris: fix unicode file name handling.
* Solaris: fail for unsupported architecture.
* Solaris: build 32 bit and 64 bit libraries.

### Improvements

* All: fall back to WrapperProcessLauncher + DefaultProcessLauncher for all platforms, regardless of whether a
  native integration is available or not.
* All: change the terminal API to handle the fact that stdout/stderr/stdin can all be attached to the same or to
  different terminals.
* All: have `Terminal` extend `Appendable` and `Flushable`
* All: add a method to `Terminal` that returns a `PrintStream` that can be used to write to the terminal, regardless of what
  `System.out` or `System.err` point to.
* Windows: use `wchar_to_java()` for system and file system info.
* All: test network file systems
* Windows: test mount points
* All: cache class, method and field lookups
* Unix: change `readLink()` implementation so that it does not need to NULL terminate the encoded content
* All: don't use `NewStringUTF()` anywhere
* Mac: change `java_to_char()` to convert java string directly to utf-8 char string.
* Mac: change `char_to_java()` to assume utf-8 encoding and convert directly to java string.
* Linux: change `char_to_java()` to use `iconv()` to convert from C char string to UTF-16 then to java string.
* Windows: support for cygwin terminal input
* Solaris: use `TERM=xtermc` instead of `TERM=xterm`.
* All: add diagnostics for terminal.
* All: version each native interface separately.
* Windows: string names for errno values.
* All: split into multiple projects.
* Mac: use fully decomposed form for unicode file names on hfs+ filesystems.
* All: extend FileSystem to deal with removable media.
* Unix: add a Terminal implementation that uses ANSI control codes. Use this when TERM != 'dumb' and
  libncurses cannot be loaded.
* All: add a method to Terminal that indicates whether the cursor wraps to the next line when a character is written
  to the rightmost character position.
* All: check for null parameters.

### Ideas

* Normalise a unicode file name for a given file system (eg hfs+ uses fully decomposed form).
* Expose meta-data about an NTFS volume:
    * Does the volume support 8.3 file names: Query [FILE_FS_PERSISTENT_VOLUME_INFORMATION](https://msdn.microsoft.com/en-us/library/windows/hardware/ff540280.aspx)
      using [DeviceIoControl()](https://msdn.microsoft.com/en-us/library/aa363216.aspx)
* Expose native desktop notification services:
    * OS X message center
    * Growl
    * Snarl
    * dnotify
* Locate various system directories (eg program files on windows).
* Expose platform-specific HTTP proxy configuration. Query registry on windows to determine IE settings.
* Expose native named semaphores, mutexes and condition variables (CreateMutex, CreateSemaphore, CreateEvent, semget, sem_open, etc).
* Expose information about network interfaces.
    * Windows networking: https://msdn.microsoft.com/en-us/library/windows/desktop/ee663286(v=vs.85).aspx
    * Windows ip functions: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366071(v=vs.85).aspx
    * Windows notification on change: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366329(v=vs.85).aspx
* Expose information about memory size and usage:
    * http://nadeausoftware.com/articles/2012/09/c_c_tip_how_get_physical_memory_size_system
* Expose system monotonic clock, for timing:
    * clock_gettime(CLOCK_MONOTONIC) on Linux
    * mach_absolute_time() and mach_timebase_info() on OS X.
* Fire events when filesystems or network interfaces change in some way.
* Fire events when terminal size changes.
* Expose system keystores and authentication services.
* Expose a mechanism for generating a temporary directory.