Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/aregtech/areg-sdk
AREG is an asynchronous Object RPC framework to simplify multitasking programming by blurring borders between processes and treating remote objects as if they coexist in the same thread.
https://github.com/aregtech/areg-sdk
async client-server concurrency cross-platform distributed embedded event-driven framework functional-programming iot ipc library logging multiprocessing multithreading parallel-computing pubsub realtime rpc sdk
Last synced: 1 day ago
JSON representation
AREG is an asynchronous Object RPC framework to simplify multitasking programming by blurring borders between processes and treating remote objects as if they coexist in the same thread.
- Host: GitHub
- URL: https://github.com/aregtech/areg-sdk
- Owner: aregtech
- License: apache-2.0
- Created: 2021-08-03T14:42:35.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2024-10-29T11:16:44.000Z (6 days ago)
- Last Synced: 2024-10-29T12:13:16.271Z (6 days ago)
- Topics: async, client-server, concurrency, cross-platform, distributed, embedded, event-driven, framework, functional-programming, iot, ipc, library, logging, multiprocessing, multithreading, parallel-computing, pubsub, realtime, rpc, sdk
- Language: C++
- Homepage: https://www.aregtech.com
- Size: 22.7 MB
- Stars: 276
- Watchers: 7
- Forks: 117
- Open Issues: 27
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE.txt
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
- fucking-awesome-readme - aregtech/areg-sdk - Logo. Multiple info and statistics badges. List of contributors and stargazers with pictures. TOC and "Back to top" links for easy navigation. Headlines with graphics. Topic hide/show menu. Project description and philosophy. Clone and integration instructions. Quick build with multiple tools. Tools configuration instructions. Reference to examples and Demo projects. Reference to use cases. References to guidance and Wiki pages. Links with badges to contact. Links with badges to share the project on social networks. (Examples)
- awesome-readme - aregtech/areg-sdk - Logo. Multiple info and statistics badges. List of contributors and stargazers with pictures. TOC and "Back to top" links for easy navigation. Headlines with graphics. Topic hide/show menu. Project description and philosophy. Clone and integration instructions. Quick build with multiple tools. Tools configuration instructions. Reference to examples and Demo projects. Reference to use cases. References to guidance and Wiki pages. Links with badges to contact. Links with badges to share the project on social networks. (Examples)
- awesome-readme - aregtech/areg-sdk - Description of the project and use cases with explanation graphics. Build with multiple tools and integration instructions, reference to the guidance to create the first project. Examples. Project logo. Multiple badges. Headlines with graphics. TOC for easy navigation. (Examples)
- awesome-iot - AREG SDK ★ 15 ⧗ 0 - AREG SDK is a developer-friendly, an interface-centric real-time asynchronous communication engine to enable distributed- and [mist-computing](https://csrc.nist.gov/publications/detail/sp/500-325/final), where connected Things interact and provide services, as if they act like thin distributed servers. (Framework)
README
AREG SDK
*Discover AREG - an advanced framework for real-time communication in mist- and fog- network environments.*
[](https://github.com/aregtech/areg-sdk/releases/tag/v1.5.0)
[](https://GitHub.com/aregtech/areg-sdk/commit/)
[](https://github.com/aregtech/areg-sdk/stargazers)
[](https://github.com/aregtech/areg-sdk/network/members)
[](https://github.com/aregtech/areg-sdk/watchers)
[](https://github.com/aregtech/areg-sdk/wiki/)
---
## Project Status[](#project-status)
---
## Introduction[](#introduction)
**AREG** (*Automated Real-time Event Grid*) is an advanced communication framework designed for seamless data transmission in IoT **[fog- and mist-network environments](https://csrc.nist.gov/publications/detail/sp/500-325/final)**. Lightweight and platform-agnostic, AREG enables efficient, automated communication by combining **Client-Server** and **Publish-Subscribe** models. By adopting an interface-centric approach, AREG facilitates the creation of service grids, where multiple devices and software nodes function collaboratively as **distributed micro-servers and clients**, ensuring reliable real-time data exchange across a network of connected nodes.
---
## Table of contents[](#table-of-contents)
- [Motivation](#motivation)
- [Interface-centricity](#interface-centricity)
- [More than embedded](#more-than-embedded)
- [Composition of AREG SDK](#composition-of-areg-sdk)
- [Getting Started: Clone and Build the AREG SDK](#getting-started-clone-and-build-the-areg-sdk)
- [Cloning Sources](#cloning-sources)
- [Build Instructions](#build-instructions)
- [Build with CMake](#build-with-cmake)
- [Build with Microsoft Visual Studio](#build-with-microsoft-visual-studio)
- [Additional Build Options](#additional-build-options)
- [Integration and Development](#integration-and-development)
- [AREG SDK Integration Methods](#areg-sdk-integration-methods)
- [1. Integrate by Fetching sources](#1-integrate-by-fetching-sources)
- [2. Integrate as a project submodule](#2-integrate-as-a-project-submodule)
- [3. Integrate the `areg` Package (vcpkg)](#3-integrate-the-areg-package-vcpkg)
- [Service Creation and Development](#service-creation-and-development)
- [Example: Application Model Setup](#example-application-model-setup)
- [Multicast Router and Log Collector](#multicast-router-and-log-collector)
- [Examples](#examples)
- [Pipeline and Roadmap](#pipeline-and-roadmap)
- [Use Cases and Benefits](#use-cases-and-benefits)
- [License](#license)
- [Call to action](#call-to-action)
- [Thank you all!](#thank-you-all)
> [!IMPORTANT]
> For full technical guidance of building and using AREG SDK, see the [following documents](./docs/wiki/).
---
## Motivation[](#motivation)
Traditionally, devices act as connected clients to stream data to the cloud or fog servers for further processing.
As data is generated and collected at the edge of the network (**mist network**), there is a growing need to redefine the role of connected Things and enable network-accessible _Public Services_ on the edge device, thereby extending the _Cloud_ capabilities to the extreme edge. This approach provides a robust foundation for solutions like:
* **Enhancing data privacy**, which is crucial for sensitive information.
* **Decrease data streaming**, which is a fundamental condition to optimize network communication.
* **Autonomous, intelligent and self-aware devices** with services directly in the environment of data origin.
---
## Interface-centricity[](#interface-centricity)
At the core of AREG is **ORPC** (_Object Remote Procedure Call_), which targets interfaces on objects. This allows AREG to establish a **service mesh** or **service grid** where applications expose reusable services. Clients, without knowledge of the server’s network location, can request services seamlessly via method invocation.
This **interface-driven Object RPC** model mirrors object-oriented programming principles and is flexible in managing multiple object instances. It imposes no protocol limitations and supports bi-directional communication to ensure seamless messaging between connected software nodes. In this model:
* **Service Providers** (*micro-server objects*) offer reusable, accessible services.
* **Service Consumers** (*client objects*) invoke services without needing to know the network details.
AREG’s design integrates **Client-Server (Request-Reply)** and **Publish-Subscribe (PubSub)** models, enabling it to support both action- and data-centric communication.
---
## More than Embedded[](#more-than-embedded)
The architecture of AREG is ideal for embedded applications, but its capabilities extend far beyond. AREG offers distributed and scalable solutions for **multithreading**, **multiprocessing**, and **internet** communications, making it a versatile choice for a wide range of applications. Services in AREG are categorized into three types: **Local**, **Public**, and **Internet**, enabling flexible and efficient remote communication across diverse environments.
> [!NOTE]
> AREG currently supports **Local** (multithreading) and **Public** (multiprocessing) services.
The fault-tolerant design of AREG offers key advantages, such as:
* **Resilience:** Failure in one application does not affect the overall system.
* **Automatic Discovery:** Services are automatically discovered by clients without manual configuration.
* **Thread-Safe Execution:** All service methods are executed within their respective thread contexts, ensuring thread safety and independence.
---
## Composition of AREG SDK[](#composition-of-areg-sdk)
The **AREG SDK** consists of several modules to streamline distributed, real-time applications development:
- **[AREG communication engine (*areg*)](./framework/areg/):** Core framework enabling communication between software components.
- **[Multicast router (_mcrouter_)](./framework/mcrouter/):** Facilitates message routing between services.
- **[Log collector (*logger*)](./framework/logger/):** Collects logs from various applications and forwards them to log observers.
- **[Log observer (*areglogger*)](./framework/areglogger/):** Library for receiving logs from the log collector service.
- **[AREG Extended Library (*aregextend*)](./framework/aregextend/):** Offers additional objects with extended features.
- **[Code generator](./master/tools/):** Generates Service **Provider** and **Consumer** objects from Service Interface documents.
- **[Examples](./examples/):** Illustrates the features of AREG Framework and use of the AREG SDK components.
- **[*Lusan* UI Tool](https://github.com/aregtech/areg-sdk-tools):** Simplifies and visualizes service design, log views.
> [!NOTE]
> The UI tool **[Lusan](https://github.com/aregtech/areg-sdk-tools)** is currently under the development. It is supposed to provide multiple features like Service Interface design, log viewing, and runtime testing. We call to join this open source project to develop the tool.
---
## Getting Started: Clone and Build the AREG SDK[](#getting-started-clone-and-build-the-areg-sdk)
### Cloning Sources
To obtain the AREG SDK source codes, use the following command:
```bash
git clone https://github.com/aregtech/areg-sdk.git
```
### Build Instructions
The **AREG SDK** is written in **C++17** and supports multiple platforms and compilers:
- **Supported platforms:** Linux, Windows, Cygwin and macOS.
- **Supported compilers:** GNU, Clang, MSVC and Cygwin GNU.
- **Supported CPU:** x86, x86_64, arm, and aarch64.
The following build tools are supported:
| Tool | Solution | Platforms | API | Quick actions to compile |
|-------------|------------------|------------------------|--------------|------------------------------------|
| **CMake** | `CMakeLists.txt` | Linux, Windows, Cygwin | POSIX, Win32 | Build with CMake, VSCode, or MSVS. |
| **MSBuild** | `areg-sdk.sln` | Windows | Win32 | Build with MSBuild or MSVS. |
For detailed build instructions, check the **[Software Build](./docs/wiki/BUILD.md)** page.
> [!NOTE]
> Other POSIX-compliant operating systems and compilers have not been tested yet.
#### Build with CMake
To compile the **AREG SDK** using **CMake**, follow these steps:
```bash
cmake -B ./build
cmake --build ./build -j 20
```
For custom builds, pass the options via the command line or configure the options listed in **[user.cmake](./docs/wiki/USER-CMAKE.md)** in CMake script.
#### Build with Microsoft Visual Studio
Open `areg-sdk.sln` file in Microsoft Visual Studio and build the solution, or navigate to the root directory of the project and run build with **MSBuild**:
```bash
MSBuild ./areg-sdk.sln
```
For further details on customizing builds, visit the **[Build with MSBuild](./docs/wiki/MSVS-BUILD.md)** document.
#### Additional Build Options
- **IDE Support:** Includes instructions for **[Microsoft Visual Studio](./docs/wiki/MSVS-BUILD.md)** and **[Visual Studio Code](./docs/wiki/VSCODE.md)**.
- **WSL Support:** Detailed steps for building under **[Windows Subsystem for Linux (WSL)](./docs/wiki/WSL.md)** are provided.
> [!NOTE]
> This chapter focuses on building AREG and examples using **Microsoft Visual Studio** and **Visual Studio Code**. The other IDEs are currently not in the focus.
---
## Integration and Development[](#integration-and-development)
For a practical example of building real-time, distributed systems using **AREG SDK**, check out the **[AREG SDK Demo](https://github.com/aregtech/areg-sdk-demo)** project, which includes implementations of multitasking applications for **embedded, IoT mist- and fog-systems**.
### AREG SDK Integration Methods
There are three ways to integrate the AREG SDK into your project:
#### 1. Integrate by Fetching sources
Add the following script to your `CMakeLists.txt` to integrate AREG SDK:
```cmake
find_package(areg CONFIG)
if (NOT areg_FOUND)
include(FetchContent)
FetchContent_Declare(
areg-sdk
GIT_REPOSITORY https://github.com/aregtech/areg-sdk.git
GIT_TAG "master"
)
FetchContent_MakeAvailable(areg-sdk)
set(AREG_SDK_ROOT "${areg-sdk_SOURCE_DIR}")
include_directories("${AREG_SDK_ROOT}/framework")
endif()
include("${AREG_CMAKE_CONFIG_DIR}/conf/cmake/areg.cmake")
```
This either finds or fetches the AREG SDK components from `master` branch. See the **[CMake Integration Guide](./docs/wiki/cmake-integrate.md)** for more details.
#### 2. Integrate as a project submodule
1. Add `areg-sdk` as a **Git submodule** in your project.
2. Include the `*.vcxproj` files from `/framework` in your solution.
3. Link your project with the `areg` library and set project dependencies.
For full details, see the **[Visual Studio Integration Guide](./docs/wiki/MSVS-INTEGRATE.md)**.
#### 3. Integrate the `areg` Package (vcpkg)
> [!IMPORTANT]
> Starting with AREG SDK 2.0, you can integrate it using the `vcpkg` package manager.
Before starting, visit the **[official vcpkg](https://github.com/microsoft/vcpkg)** repository to clone and install the `vcpkg` package manager tool in your PC.
1. **Install and integrate the `areg` package:** Example of the AREG SDK components, headers and its dependencies installation under Linux:
```bash
./vcpkg install areg:linux-64
./vcpkg integrate install
```
2. **Integrate with CMake:** Add the following script to your `CMakeLists.txt` (replace `` with real target):
```cmake
find_package(areg CONFIG REQUIRED)
target_link_libraries( PRIVATE areg::areg)
```
Use `vcpkg` toolchain file (`` is the root path of `vcpkg`) to configure and build the project:
```bash
cmake -B ./build -DCMAKE_TOOLCHAIN_FILE=/scripts/buildsystems/vcpkg.cmake
cmake --build ./build -j 20
```
3. **Integrate with Microsoft Visual Studio:** In Microsoft Visual Studio, there is no need to add AREG SDK projects in the solution file. Develop projects and make sure to link `areg` library with binaries either in *Project Properties* or by adding this line of code:
```cpp
#pragma comment(lib, "areg")
```
For details of installing and using `areg` package, see the appropriate **[integrate `areg` package](./docs/wiki/AREG-PACKAGE.md)** document.
### Service Creation and Development
Follow the **[“Hello Service!”](./docs/HelloService.md)** tutorial for step-by-step instructions. Generated service interface files integrate with CMake or Visual Studio projects. Service Providers extend **xxxStub**, and Service Consumers extend **xxxClientBase**.
### Example: Application Model Setup
When developing **Service Provider** and **Service Consumer** components, developers can easily determine whether to run components in the same process (multithreading) or in separate processes (multiprocessing) for optimal performance in real-time applications by defining the **Application Model**. Below is an example of setting up a *model* where the *Service Provider* and *Service Consumer* components run in the same process, but on different threads.
```cpp
BEGIN_MODEL("ApplicationModel")
// Provider Thread
BEGIN_REGISTER_THREAD("ProviderThread", NECommon::WATCHDOG_IGNORE)
BEGIN_REGISTER_COMPONENT("ServiceProvider", ServiceComponent)
REGISTER_IMPLEMENT_SERVICE(NEHelloService::ServiceName, NEHelloService::InterfaceVersion)
END_REGISTER_COMPONENT("ServiceProvider")
END_REGISTER_THREAD("ProviderThread")
// Consumer Thread
BEGIN_REGISTER_THREAD("ConsumerThread", NECommon::WATCHDOG_IGNORE)
BEGIN_REGISTER_COMPONENT("ServiceConsumer", ClientComponent)
REGISTER_DEPENDENCY("ServiceProvider")
END_REGISTER_COMPONENT("ServiceConsumer")
END_REGISTER_THREAD("ConsumerThread")
END_MODEL("ApplicationModel")
int main(void)
{
Application::initApplication();
Application::loadModel("ApplicationModel");
Application::waitAppQuit();
Application::unloadModel("ApplicationModel");
Application::releaseApplication();
return 0;
}
```
In this example:
- **ServiceProvider** runs on `ProviderThread`, and **ServiceConsumer** runs on `ConsumerThread`.
- `REGISTER_DEPENDENCY("ServiceProvider")` means `ServiceConsumer` component consumes the services provided by `ServiceProvider`.
You can also set up multiprocess applications using same components and changing *model*. As a practical example, follow projects in the **[00_helloservice](./examples/00_helloservice/)** directory.
> [!TIP]
> *Learn how AREG SDK simplifies the creation of Service Providers and Consumers, supporting both multithreading and multiprocessing for real-time, distributed applications.* Visit **[examples](./examples/README.md)** to see the list of demonstrated applications and features of the AREG communication engine.
### Multicast Router and Log Collector
Both **mcrouter** and **logger** are essential components for communication and log collection. Configuration templates for the multicast router and log collector services are provided in the `areg.init` file. Both processes are designed to run as console applications or as **Operating System managed** services.
For in-depth details of building and using these applications, review the descriptions in **[Multicast Router Service](./docs/wiki/MCROUTER.md)** and **[Log Collector Service](./docs/wiki/LOGGER.md)** pages. *Discover how the AREG SDK’s Multicast Router and Log Collector streamline communication and logging in edge computing and real-time data transfer systems.*
---
This version is strong, but a few minor adjustments can improve flow, consistency, and readability. Here’s a refined version:
---
## Examples[](#examples)
The AREG SDK offers hands-on examples demonstrating **Multithreading** and **Multiprocessing** applications, **Client-Server** and **Publish-Subscribe** models, **Object Remote Procedure Call (Object RPC)** and **Inter-Process Communication (IPC)**, featured **Finite-State Machines (FSM)** creation, and more. Each project highlights key features that facilitate efficient development of distributed services.
**Some Featured Examples:**
1. **[00_helloservice](./examples/00_helloservice/)**: Master service creation across single-threaded, multi-threaded, and multi-process environments, showcasing AREG’s intuitive, interface-driven approach.
2. **[04_trace](./examples/04_trace/)**: Configure and manage logging to track application behavior, aiding debugging, performance analysis, and log management.
3. **[16_pubfsm](./examples/16_pubfsm/)**: Build and control a *Finite-State Machine (FSM)* with AREG’s *Timers* and *Events* for smooth state transitions.
4. **[19_pubwatchdog](./examples/19_pubwatchdog/)**: Implement a watchdog to monitor thread activity, restart unresponsive threads, and notify components as needed.
5. **[24_pubsubmulti](./examples/24_pubsubmulti/)**: Explore the PubSub model, which reduces data traffic by delivering only relevant updates.
For the full list of examples and additional documentation, visit **[AREG SDK Examples](./examples/README.md)**.
> *Accelerate your multithreading, multiprocessing, embedded, IoT edge, and event-driven development with these examples. For technical inquiries, please contact us.*
---
## Pipeline and Roadmap[](#pipeline-and-roadmap)
The AREG SDK is continuously evolving to help developers create complex applications more efficiently on **Desktop**, **Embedded**, and **IoT edge** devices. It aims to reduce development time by **30-50%** while ensuring automation, reliability and flexibility.
**Upcoming Features:**
- **Multi-channel & multi-protocol communication**: Enhanced support for various communication methods, improving interoperability.
- **Internet category services**: Expansion into web-based services, enabling more modern, internet-driven applications.
**Tools in Development:**
- **Service Interface Designer**: A visual tool to simplify service interface creation.
- **Interactive Log Viewer**: A tool for easy log visualization and performance analysis.
- **Service Testing & Simulation Tool**: Helps simulate services and data, streamlining testing and development.
The tools are actively being developed in the **[AREG SDK Tools repository](https://github.com/aregtech/areg-sdk-tools)**.
---
## Use Cases and Benefits[](#use-cases-and-benefits)
The **AREG SDK** enables efficient multithreading and multiprocessing communication, offering full support for *edge computing* and *fog computing* use cases that demand efficient communication between devices and services in real-time. It is ideal for developing:
- **Distributed solutions** for embedded systems.
- **Real-time applications** for IoT devices.
- **Simulation and test environments**.
Explore **[real-world use cases and examples](./docs/USECASES.md)** to learn more about its applications.
---
## License[](#license)
The AREG SDK is available under the **[Apache License Version 2.0](./LICENSE.txt)**, a permissive free open-source license. For developers or businesses that need commercial licensing, this option is available and includes:
- Commercial support.
- Full rights to create and distribute software without open-source license obligations.
For more information on commercial licensing, commercial support, trainings, or partnership inquiries, visit the **[Aregtech](https://www.aregtech.com/)** website or contact us at **info[at]aregtech[dot]com**.
---
## Call to action[](#call-to-action)
We encourage the developer community to get involved and contribute to the growth of the AREG SDK. Join AREG SDK community and collaborate with AREG developers. Here’s how you can help:
- Check out our list of [open issues](https://github.com/aregtech/areg-sdk/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) where assistance is needed.
- If you have suggestions or need new features, open a [new issue](https://github.com/aregtech/areg-sdk/issues) or start a [discussion](https://github.com/aregtech/areg-sdk/discussions).
- For pull requests, ensure that the code adheres to our coding style and allow time for review and testing.
Lastly, help us grow the AREG SDK community by **giving a star** on GitHub! Whether you’re working on **embedded applications**, **multiprocessing and multithreading applications**, **real-time data transfer**, **IoT applications**, or **microservices architecture**, your support helps us continue to improve this cutting-edge communication framework.
---
## Thank you all!](#thank-you)
Special thanks to all contributors and supporters that starred this repository.
**Our amazing contributors**:
[](https://github.com/aregtech/areg-sdk/graphs/contributors)
**Our supportive stargazers**:
[](https://github.com/aregtech/areg-sdk/stargazers)
Do you like this project? Join us or [give](https://github.com/aregtech/areg-sdk/stargazers) a ⭐.
Do you have an idea or found a bug? Please open an [issue](https://github.com/aregtech/areg-sdk/issues) or start a [discussion](https://github.com/aregtech/areg-sdk/discussions).
---
**Follow us** at
[](https://www.linkedin.com/company/aregtech)
[](https://gitter.im/areg-sdk/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
---
**Share** the project link with your network on social media.
