Open-Source Platform for Quantified Self & IoT

# Heedy

[![Docs](https://img.shields.io/badge/documentation-heedy.org-purple?style=flat-square)](https://heedy.org)[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/heedy/heedy?style=flat-square)](https://github.com/heedy/heedy/releases)[![PyPI](https://img.shields.io/pypi/v/heedy?style=flat-square)](https://pypi.org/project/heedy/)![GitHub Workflow Status](https://img.shields.io/github/workflow/status/heedy/heedy/Test?label=tests&style=flat-square)

A repository for your personal data, and an extensible analysis engine.

There already exist many apps and fitness trackers that gather and attempt to make sense of your data. Most of these services are isolated - your phone's fitness tracking software knows nothing about your browser's time-tracking extension. Furthermore, each app and service has its own method for downloading data (if they offer raw data at all!), which makes an all-encompassing analysis of life extremely tedious. Heedy offers a self-hosted open-source way to put all of this data together into a single system.

Several existing aggregators already perform many of heedy's functions ([see the list here](https://github.com/woop/awesome-quantified-self#aggregators--dashboards)). However, they are all missing one of two critical components:

1. **Open-source and self-hosted**: Most existing tools are cloud-based, which means that all of your data is on "someone else's computer". While these companies may claim that they will not [sell your data](https://arstechnica.com/tech-policy/2019/03/ftc-investigates-whether-isps-sell-your-browsing-history-and-location-data/), or won't [turn it over to governments](<https://en.wikipedia.org/wiki/PRISM_(surveillance_program)>), they can change their minds (and terms of service) at any time. The only way to guarantee that your data will never be used against you is for it to be on your computer, operated by software you can audit yourself.
2. **Extensible**: Even a system with fantastic visualizations and powerful analysis has limited utility. This is because it can only show what the original authors assumed would be useful. Heedy offers a powerful plugin system - plugin writers can add new integrations, plots, or even modify core functionality with a few lines of python or javascript.

## Running

Heedy currently supports Mac and Linux (including the Raspberry Pi). The server is started from the command-line.

1. [Download Heedy](https://github.com/heedy/heedy/releases/latest), it is a single executable file that has everything built-in!
2. Run it:

```bash
chmod +x ./heedy # Allow execution of file
./heedy          # Run heedy
```

3. Open your browser to http://localhost:1324 to set up your database!

_Before setting up Heedy, it is recommended that you have Python >=3.7 with venv support installed, because most heedy plugins use Python! On Ubuntu/PiOS, you just need to install `python3-venv`._

### Docker

Heedy is also available for use with docker. You will want to create a folder (`myheedy`) to hold your heedy database, and bind it to the `/data` folder in the container:

```bash
mkdir myheedy
docker run --rm -d -p 1324:1324 -v $PWD/myheedy:/data --user $UID --name heedy dkumor/heedy
```

This runs heedy in the background on port `1324`. To run interactively, use `-it` instead of `-d`.

## Plugins

Heedy itself is very limited in scope. Most of its power comes from plugins that extend its functionality, and integrate with other services. Some plugins worth checking out:

- [fitbit](https://github.com/heedy/heedy-fitbit-plugin) - sync heedy with Fitbit, allowing you to access and analyze your wearables' data.
- [notebook](https://github.com/heedy/heedy-notebook-plugin) - analyze your data directly within Heedy with Jupyter notebooks.

Installing a plugin is as simple as [uploading its zip file to heedy](https://heedy.org/server/configuration.html#installing-plugins).

## Screenshots

The first screenshot is of sleep data uploaded by the [fitbit plugin](https://github.com/heedy/heedy-fitbit-plugin). The second is a jupyter notebook enabled by the [notebook plugin](https://github.com/heedy/heedy-notebook-plugin). The final screenshot shows Heedy's built-in analysis capabilities.

[![Fitbit Plugin Example](docs/_static/img/screenshots/1.png)](https://github.com/heedy/heedy-fitbit-plugin)
[![Fitbit Notebook Example](docs/_static/img/screenshots/2.png)](https://github.com/heedy/heedy-notebook-plugin)
![Data Analysis Example](docs/_static/img/screenshots/3.png)

## Building

Building heedy requires at least go 1.18 and a recent version of node with at least npm 7.

### Release

```
git clone https://github.com/heedy/heedy
cd heedy
make
```

### Debug

```
git clone https://github.com/heedy/heedy
cd heedy
make debug
```

The debug version uses the assets from the `./assets` folder instead of embedding in the executable.

#### Watch frontend

To edit the frontend, you will want to run the following:

```
make watch
```

This will watch all frontend files and rebuild them as they change, allowing you to edit them and see changes immediately by refreshing your browser.

### Verbose Mode

You can see everything heedy does, including all SQL statements and raw http requests by running it in verbose mode:

```
./heedy --verbose
```


connectordb

Lightweight data stream processing engine for IoT edge

# LF Edge eKuiper - An edge lightweight IoT data analytics software

[![GitHub Release](https://img.shields.io/github/release/lf-edge/ekuiper?color=brightgreen)](https://github.com/lf-edge/ekuiper/releases)
[![Docker Pulls](https://img.shields.io/docker/pulls/lfedge/ekuiper)](https://hub.docker.com/r/lfedge/ekuiper)
[![codecov](https://codecov.io/gh/lf-edge/ekuiper/branch/master/graph/badge.svg?token=24E9Q3C0M0)](https://codecov.io/gh/lf-edge/ekuiper)
[![Go Report Card](https://goreportcard.com/badge/github.com/lf-edge/ekuiper)](https://goreportcard.com/report/github.com/lf-edge/ekuiper)
[![Slack](https://img.shields.io/badge/Slack-LF%20Edge-39AE85?logo=slack)](https://slack.lfedge.org/)
[![Twitter](https://img.shields.io/badge/Follow-EMQ-1DA1F2?logo=twitter)](https://twitter.com/EMQTech)
[![Community](https://img.shields.io/badge/Community-Kuiper-yellow?logo=github)](https://github.com/lf-edge/ekuiper/discussions)
[![YouTube](https://img.shields.io/badge/Subscribe-EMQ-FF0000?logo=youtube)](https://www.youtube.com/channel/UC5FjR77ErAxvZENEWzQaO5Q)

[English](README.md) | [简体中文](README-CN.md) | [日本語](README-JP.md)

## Overview

LF Edge eKuiper is a lightweight IoT data analytics and stream processing engine running on resource-constraint edge devices. The major goal for eKuiper is to provide a streaming software framework (similar to [Apache Flink](https://flink.apache.org)) in edge side.  eKuiper's  **rule engine** allows user to provide either SQL based or graph based (similar to Node-RED) rules to create IoT edge analytics applications within few minutes.

![arch](./docs/en_US/resources/arch.png)

**User scenarios**

It can be run at various IoT edge user scenarios, such as,
- Real-time processing of production line data in the IIoT 
- Gateway of connected vehicle analyze the data from CAN in IoV
- Real-time analysis of wind turbines and smart bulk energy storage data in smart energy

eKuiper processing at the edge can greatly reduce system response latency, save network bandwidth and storage costs and improve system security.

## Features

- Lightweight

  - Core server package is only about 4.5M, memory footprint is about 10MB

- Cross-platform

  - CPU Arch：X86 AMD * 32/64; ARM * 32/64; PPC
  - Popular Linux distributions, OpenWrt Linux, MacOS and Docker
  - Industrial PC, Raspberry Pi, industrial gateway, home gateway, MEC edge cloud server

- Data analysis support

  - Support data ETL
  - Data order, group, aggregation and join with different data sources (the data from databases and files)
  - 60+ functions, includes mathematical, string, aggregate and hash etc
  - 4 time windows & count window

- Highly extensible 

  It supports to extend at `Source`, `Functions` and `Sink` with Golang or Python.

  - Source: allows users to add more data source for analytics. 
  - Sink: allows users to send analysis result to different customized systems.
  - UDF functions: allow users to add customized functions for data analysis (for example, AI/ML function invocation) 

- Management

  - [A free dockerised web based management dashboard](https://hub.docker.com/r/emqx/ekuiper-manager) for visualized management
  - [An open-source free web based management dashboard](https://github.com/ankur-paan/ekuiper-manager) for visualized management based on latest ekuiper release
  - Swagger API playground available at https://ankur-paan.github.io/ekuiper-manager/
  - Plugins, streams and rules management through CLI, REST API and config maps(Kubernetes)
  - Easily be integrated with Kubernetes
    frameworks [KubeEdge](https://github.com/kubeedge/kubeedge), [OpenYurt](https://openyurt.io/), [K3s](https://github.com/rancher/k3s) [Baetyl](https://github.com/baetyl/baetyl)

- Integration with EMQX products

  Seamless integration with [EMQX](https://www.emqx.io/), [Neuron](https://neugates.io/) & [NanoMQ](https://nanomq.io/), and provided an end-to-end solution from IIoT, IoV 

## Quick start

- [5 minutes quick start](docs/en_US/getting_started/quick_start_docker.md)
- [Getting started](docs/en_US/getting_started/getting_started.md)
- [EdgeX rule engine tutorial](docs/en_US/edgex/edgex_rule_engine_tutorial.md)

## Community

Join our [Slack](https://slack.lfedge.org/), and then join [ekuiper](https://lfedge.slack.com/archives/C024F4P7KCK) or [ekuiper-user](https://lfedge.slack.com/archives/C024F4SMEMR) channel.

### Meeting

Subscribe to community events [calendar](https://lists.lfedge.org/g/ekuiper-tsc/calendar?calstart=2021-08-06).

Weekly community meeting at Friday 10:30AM GMT+8:
- [Zoom meeting link](https://zoom.us/j/95097577087?pwd=azZaOXpXWmFoOXpqK293RFp0N1pydz09 )
- [Meeting minutes](https://wiki.lfedge.org/display/EKUIPER/Weekly+Development+Meeting)

### Contributing
Thank you for your contribution! Please refer to the [CONTRIBUTING.md](./docs/en_US/CONTRIBUTING.md) for more information.

## Performance test result

### MQTT throughput test

- Using JMeter MQTT plugin to send IoT data to [EMQX Broker](https://www.emqx.io/), such as: `{"temperature": 10, "humidity" : 90}`, the value of temperature and humidity are random integer between 0 - 100.
- eKuiper subscribe from EMQX Broker, and analyze data with SQL: `SELECT * FROM demo WHERE temperature > 50 `
- The analysis result are wrote to local file by using [file sink plugin](docs/en_US/guide/sinks/plugin/file.md).

| Devices                                        | Message # per second | CPU usage     | Memory usage |
|------------------------------------------------|----------------------|---------------|--------------|
| Raspberry Pi 3B+                               | 12k                  | sys+user: 70% | 20M          |
| AWS t2.micro( 1 Core * 1 GB) <br />Ubuntu18.04 | 10k                  | sys+user: 25% | 20M          |

### EdgeX throughput test

- A [Go application](test/edgex/benchmark/pub.go) is written to send data to ZeroMQ message bus, the data is as
  following.

  ```
  {
    "Device": "demo", "Created": 000, …
    "readings": 
    [
       {"Name": "Temperature", value: "30", "Created":123 …},
       {"Name": "Humidity", value: "20", "Created":456 …}
    ]
  }
  ```

- eKuiper subscribe from EdgeX ZeroMQ message bus, and analyze data with
  SQL: ``SELECT * FROM demo WHERE temperature > 50``. 90% of data will be filtered by the rule.

- The analysis result are sent to [nop sink](docs/en_US/guide/sinks/builtin/nop.md), so all the result data will be
  ignored.

|                                                | Message # per second | CPU usage     | Memory usage |
|------------------------------------------------|----------------------|---------------|--------------|
| AWS t2.micro( 1 Core * 1 GB) <br />Ubuntu18.04 | 11.4 k               | sys+user: 75% | 32M          |

### Max number of rules support

- 8000 rules with 800 message/second in total
- Configurations
  - 2 core * 4GB memory in AWS
  - Ubuntu
- Resource usage
  - Memory: 89% ~ 72%
  - CPU: 25%
  - 400KB - 500KB / rule
- Rule
  - Source: MQTT
  - SQL: `SELECT temperature FROM source WHERE temperature > 20` (90% data are filtered) 
  - Sink: Log

### Multiple rules with shared source instance

- 300 rules with a shared MQTT stream instance.
  - 500 messages/second in the MQTT source
  - 150,000 message processing per second in total
- Configurations:
  - 2 Core * 2GB memory in AWS
  - Ubuntu
- Resource usage
  - Memory: 95MB
  - CPU: 50%
- Rule
  - Source: MQTT
  - SQL: `SELECT temperature FROM source WHERE temperature > 20`, (90% data are filtered)
  - Sink: 90% nop and 10% MQTT

To run the benchmark by yourself, please check [the instruction](./test/benchmark/multiple_rules/readme.md).

## Documents

Check out the [latest document](https://ekuiper.org/docs/en/latest/) in official website.


## Build from source

#### Preparation

- Go version >= 1.25

#### Compile

+ Binary: 

  - Binary: `$ make`

  - Binary files that support EdgeX: `$ make build_with_edgex`

  - Minimal binary file with core runtime only: `$ make build_core`

+ Packages: `$ make pkg`

  - Packages: `$ make pkg`

  - Package files that support EdgeX: `$ make pkg_with_edgex`

+ Docker images: `$ make docker`

  > Docker images support EdgeX by default

Prebuilt binaries are provided in the release assets. If using os or arch which does not have prebuilt binaries, please
use cross-compilation, refer to [this doc](docs/en_US/operation/compile/cross-compile.md).

During compilation, features can be selected through go build tags so that users can build a customized product with
only the desired feature set to reduce binary size. This is critical when the target deployment environment has resource
constraint. Please refer to [features](docs/en_US/operation/compile/features.md) for more detail.

## Open source license

[Apache 2.0](LICENSE)


ekuiper

Project Flogo is an Open Source Framework for IoT Edge Apps & Integration

<p align="center">
  <img src ="images/projectflogo.png" />
</p>

<p align="center" >
  <b>Project Flogo is an Open Source ecosystem for event-driven apps</b>
</p>

<p align="center">
  <img src="https://travis-ci.org/TIBCOSoftware/flogo.svg"/>
  <img src="https://img.shields.io/badge/dependencies-up%20to%20date-green.svg"/>
  <img src="https://img.shields.io/badge/license-BSD%20style-blue.svg"/>
  <a href="https://gitter.im/project-flogo/Lobby?utm_source=share-link&utm_medium=link&utm_campaign=share-link"><img src="https://badges.gitter.im/Join%20Chat.svg"/></a>
</p>

<p align="center">
  <a href="#project-flogo-ecosystem">Ecosystem</a> | <a href="#flogo-repos">Repos</a> | <a href="#flogo-core">Core</a> | <a href="#flogo-flows">Flows</a> | <a href="#flogo-streams">Streams</a> | <a href="#flogo-rules">Flogo Rules</a> | <a href="#golang-api">Go Developers</a> | <a href="#when-to-use-flogo">When to use Flogo</a> | <a href="#contributing">Contributing</a> | <a href="#license">License</a>
</p>

<br/>

Project Flogo is an ultra-light, Go-based open source ecosystem for building event-driven apps. Event-driven, you say? Yup, the notion of *triggers* and *actions* are leveraged to process incoming events. An action, a common interface, exposes key capabilities such as application integration, stream processing, etc.
<br/>

<p align="center">
  <img src ="images/eventhandlers.png" />
</p>
<br/>

- **App = Trigger(s) + Actions[&Activities]**
- **Triggers**
  - receive data from external sources.
  - are managed by a configurable threading model
  - have a common interface enabling anyone to build a Flogo trigger.
- **Handlers**
  - dispatch events to actions
- **Actions**
  - process events in a manner suitable with the implementation
  - have a common interface enabling opinionated event processing capabilities

# Project Flogo Ecosystem

All capabilities within the Flogo Ecosystem have a few things in common, they all process events (in a manner suitable for the specific purpose) and they all implement the *action* interface exposed by Flogo Core.

Some of the key highlights include:

🎈 **Ultra-light** 20x-50x lighter than Java or Node.js <br/>
⚡️ **Event-driven** Powerful event-driven programming model based on *triggers* and *actions*<br/>
⚙️ **Common core** a single, common core enables reuse and flexibility across all eventing constructs<br/>
✏️ **Golang based** Written entirely in Golang for efficiency<br/>
💪 **Deployment flexibility** Deploy as ultra-lightweight serverless functions, containers or static binaries on IoT edge devices<br/>
🧠 **Native machine learning** Purpose built activity for TensorFlow SavedModel inferencing<br/>
😍 **100% Open Source** for your dev & hacking pleasure<br/>

<p align="center">
  <img src ="images/flogostack.png" />
</p>

* **Integration Flows** Application Integration process engine with conditional branching and a visual development environment<br/>
* **Stream Processing** a simple pipeline-based stream processing action with event joining capabilities across multiple triggers & aggregation over time windows<br/>
* **Contextual Decisioning**  Declarative Rules for Real-time Contextual Decisions<br/>
* **Microgateway** Microgateway pattern for conditional, content-based routing, JWT validation, rate limiting, circuit breaking and other common patterns<br/>

The concept is simple, an event is just that, an event, how it’s processed is what differs. Flogo Core eases the burden by enabling a common set of functionality, such as:

- threading
- logging
- data type coercion
- data mapping
- tracing & monitoring hooks

While also exposing a common set of contributions via activities and triggers. For example, all available triggers can be leveraged to dispatch events to any action implementation, that is, flows for application integration, streams for stream processing, rules for contextual rule processing, etc.

# Flogo Repos

Project Flogo consists of the following sub-projects available as separate repos under a seperated GitHub Org:

* [project-flogo/flogo-cli](https://github.com/project-flogo/cli):  Command line tools for building Flogo apps & extensions
* [project-flogo/flogo-core](https://github.com/project-flogo/core): The core Flogo library 
* [project-flogo/flogo-contrib](https://github.com/project-flogo/contrib): Flogo contributions/extensions
* [project-flogo/stream](https://github.com/project-flogo/stream): Flogo Streams Action
* [project-flogo/rules](https://github.com/project-flogo/rules): Contextual, deterministic rules action
* [project-flogo/microgateway](https://github.com/project-flogo/microgateway): Flogo Microgateway Action
* [project-flogo/flogo-web](https://github.com/project-flogo/flogo-web): Flogo Web UI

# Flogo Core

Flogo Core is an event-driven app framework used to develop apps for the cloud & IoT edge. It can also be thought of as a lightweight *app kernel* used by open source & commercial solutions.

Flogo Core provides the following key benefits:

⛓ **Action chaining** enables communication between one or more capabilities in a single, sub 10MB binary!<br/>
🏗 **Common contribution model** build activities and triggers that can be leveraged by all capabilities<br/>
🔨 **Extensible** easily extend the capabilities available by building your own action using the common interfaces<br/>

## Flogo Core Contribution Model

Flogo Core exposes three principal contribution interfaces that enable developers to build common capabilities and functionality. These contribution interfaces include:

* **Trigger Interface** a common interface for building event-consumers that dispatch events to one or more actions. The Kafka subscriber is an example of a trigger.
* **Activity Interface** a common interface for exposing common application logic in a reusable manner. Think of this as a function, such as write to database, publish to Kafka, etc that can be used by all Flogo apps.
* **Action Interface** a common interface for processing events. Actions contain the specific capability logic, such as integration, stream processing, rule processing, etc. Actions have a great deal of flexibility in how they’re developed and how developers leverage actions within their overall applications. For example, flows and streams expose JSON-based DSLs & Go APIs for maximum developer flexibility.

# Flogo Flows

Flogo Flows provides application integration capabilities and includes the following key highlights.

🌈 **Painless development** Visual modeler with step-back debugging capabilities & elegant DSL<br/>
⚙️ **Ultra-light process engine** for conditional flow control

## Getting Started

We've made getting started with Flogo Flows as easy as possible. The current set of tooling is designed for:

- Serverless function developers
- Cloud-native microservices developers
- IoT Solutions developers
- <a href="#golang-api">Go Developers</a>

### Zero-code Developers

If your background is in or you prefer to develop your apps using zero-coding environments, then read on, because we’ve got something special for you.

Flows Web UI is available via [Docker Hub](https://hub.docker.com/r/flogo/flogo-docker) or [Flogo.io](http://flogo.io). The Docker image contains the Flows Web UI along with all required components to begin developing, testing and building deployable artifacts right from your web browser.

To report any issues with the Issue tracker on this project.

![Flogo Web In Action](images/flogo-web2.gif)

# Flogo Streams

Edge devices have the potential for producing millions or even billions of events at rapid intervals, often times the events on their own are meaningless, hence the need to provide basic streaming operations against the slew of events.

A native streaming action as part of the Project Flogo Ecosystem accomplishes the following primary objectives:

- Enables apps to implement basic streaming constructs in a simple pipeline fashion
- Provides non-persistent state for streaming operations
  - Streams are persisted in memory until the end of the pipeline
- Serves as a pre-process pipeline for raw data to perform basic mathematical and logical operations. Ideal for feeding ML models

Some of the key highlights include:

😀 **Simple pipeline** construct enables a clean, easy way of dealing with streams of data<br/>
⏳ **Stream aggregation** across streams using time or event tumbling & sliding windows<br/>
🙌 **Join streams** from multiple event sources<br/>
🌪 **Filter** out the noise with stream filtering capabilities<br/>

## Getting Started

We’ve made building powerful streaming pipelines as easy as possible. Develop your pipelines using:

- A simple, clean JSON-based DSL
- Golang API

See the sample below of an aggregation pipeline (for brevity, the triggers and metadata of the resource has been omitted). Also don’t forget to check out the examples in the [project-flogo/stream](https://github.com/project-flogo/stream/tree/master/examples) repo.

```json
  "stages": [
    {
      "ref": "github.com/project-flogo/stream/activity/aggregate",
      "settings": {
        "function": "sum",
        "windowType": "timeTumbling",
        "windowSize": "5000"
      },
      "input": {
        "value": "=$.input"
      }
    },
    {
      "ref": "github.com/project-flogo/contrib/activity/log",
      "input": {
        "message": "=$.result"
      }
    }
  ]
```

# Flogo Rules

Processing Events in real-time to determine next best action is an important function of Event driven applications. With the vast amount of events that are generated from different sources, making sense of the information in a given context can be immensely valuable. 

Flogo Rules simplifies the complexity involved with real-time contextual decisions.

Flogo Rules supports

- Declarative Rules to define conditional logic and trigger result rules
- Joins/Correlations across multiple Event sources
- Ability to define Rule Priorities
- Timer Events; Configurable TTL (time to live) -1 - no expiry, 0 - event expiry set to end of run to completion cycle. 
- Forward chaining for Inferencing

# The CLI

The CLI is used to build all applications that leverage the JSON-based DSL. If you’re using the Go API to build your apps, feel free to just `go build` your stuff without the flogo CLI.

Getting started with the CLI couldn't be any easier (refer to [Flogo CLI](https://github.com/project-flogo/cli) repo for detail instructions and dependencies):

* Install the CLI
```bash
go install github.com/project-flogo/cli/...@latest
```

* Create & build your app
<img src="images/flogo-cli.gif" width="70%"/>

* **flogo** the core CLI for creating and building your applications
* **flogogen** a scaffolding tool to begin building your Flogo contributions (activities, triggers & actions)

If you're interested in building your own contribution(s), refer to the [Flogo Documentation](https://tibcosoftware.github.io/flogo/) or join us on the [project-flogo/Lobby Gitter Channel](https://gitter.im/project-flogo/Lobby?utm_source=share-link&utm_medium=link&utm_campaign=share-link).

# Golang API

Are you the kind of person who would rather code, but would love to leverage the capabilities of the Flogo Ecosystem? Makes total sense, we just ❤️ to code also! We’ve exposed a number of Go APIs for leveraging the various action types, activities and triggers. Getting started is pretty easy, just follow the steps below.

* Create your new project dir and init your module
```base
mkdir test
cd test
go mod init example.com/m
```

* Go get the latest [flogo core](https://github.com/project-flogo/core)
```bash
go get github.com/project-flogo/core
```

* Optionally, if you're using any of the Flogo contributions, don't forget to get that repo, as well
```bash
go get github.com/project-flogo/contrib
```

* Open up your favorite IDE or txt editor and start coding!

```go
package main

import (
	"context"
	"fmt"

	"github.com/project-flogo/contrib/activity/log"
	"github.com/project-flogo/contrib/trigger/rest"
	"github.com/project-flogo/core/activity"
	"github.com/project-flogo/core/api"
	"github.com/project-flogo/core/data/coerce"
	"github.com/project-flogo/core/engine"
)

func main() {

	app := myApp()

	e, err := api.NewEngine(app)

	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	engine.RunEngine(e)
}

func myApp() *api.App {
	app := api.NewApp()

	trg := app.NewTrigger(&rest.Trigger{}, &rest.Settings{Port: 8080})
	h, _ := trg.NewHandler(&rest.HandlerSettings{Method: "GET", Path: "/blah/:num"})
	h.NewAction(RunActivities)

	//store in map to avoid activity instance recreation
	logAct, _ := api.NewActivity(&log.Activity{})
	activities = map[string]activity.Activity{"log": logAct}

	return app
}

var activities map[string]activity.Activity

func RunActivities(ctx context.Context, inputs map[string]interface{}) (map[string]interface{}, error) {

	trgOut := &rest.Output{}
	trgOut.FromMap(inputs)

	msg, _ := coerce.ToString(trgOut.PathParams)
	_, err := api.EvalActivity(activities["log"], &log.Input{Message: msg})
	if err != nil {
		return nil, err
	}

	response := make(map[string]interface{})

	response["id"] = "123"
	response["amount"] = "1"
	response["balance"] = "500"
	response["currency"] = "USD"

	reply := &rest.Reply{Code: 200, Data: response}
	return reply.ToMap(), nil
}
```

* Don't forget to tidy your dependencies
```bash
go mod tidy
```

* Before we can build the app, let's generate the metadata for the triggers
```bash
go generate
```

* Build the app
```bash
go build
```

# When to use Flogo

You’ll look to leverage Flogo if you’re a dev & sick of building all the messy stuff that comes along with coding production apps. Such as connectivity to event-driven messaging platforms, datastores, SaaS apps, etc & want to deploy to a wide range of targets, such as

- serverless compute
- IoT edge devices
- containers

The broader Flogo ecosystem exposes an opinionated perspective on building event-driven apps. If you’re looking to process events in any of the following ways, then read on because the Project Flogo Ecosystem is for you!

- long running processes with flow-control support geared toward application integration
- consuming and manipulating large streams of events via a pipeline to act as a pre-processor for time-series data to serve things like machine learning models or to derive simple conclustions via data aggregation
- contextual, declarative rules for real-time decisioning

In short...

| Flogo is...  | Flogo is not... |
| :--- | :--- |
| an ecosystem of opinionated, event-driven capabilities | a front-end web app or analytics framework |
| a Go lib to increase dev productivity  | an IoT platform  |

# Contributing
Want to contribute to Project Flogo? We've made it easy, all you need to do is fork the repository you intend to contribute to, make your changes and create a Pull Request! Once the pull request has been created, you'll be prompted to sign the CLA (Contributor License Agreement) online.

Not sure where to start? No problem, here are a few suggestions:

* [flogo-contrib](https://github.com/project-flogo/contrib): This repository contains all of the standard contributions, such as activities, triggers, etc. Perhaps there is something missing? Create a new activity or trigger or fix a bug in an existing activity or trigger. Don't forget to check all of the other repositores in the [project-flogo org](https://github.com/project-flogo) on GitHub, as some contributions are large enough to have their own repo.
* Browse all of the [Project Flogo repositories] and look for issues tagged `kind/help-wanted` or `good first issue`

If you have any questions, feel free to post an issue and tag it as a question, email flogo-oss@tibco.com or chat with the team and community:

* The [project-flogo/Lobby](https://gitter.im/project-flogo/Lobby) Gitter channel should be used for general discussions, start here for all things Flogo!
* The [project-flogo/developers](https://gitter.im/project-flogo/developers) Gitter channel should be used for developer/contributor focused conversations. 

For additional details, refer to the [Contribution Guidelines](https://github.com/TIBCOSoftware/flogo/blob/master/CONTRIBUTING.md).

# License 
Project Flogo is licensed under a BSD-style license. Refer to [LICENSE](https://github.com/TIBCOSoftware/flogo/blob/master/LICENSE) for license text.

## Usage Guidelines

We’re excited that you’re using Project Flogo to power your project(s). Please adhere to the [usage guidelines](http://flogo.io/brand-guidelines) when referencing the use of Project Flogo within your project(s) and don't forget to let others know you're using Project Flogo by proudly displaying one of the following badges or the Flynn logo, found in the [branding](branding) folder of this project.


flogo

Gatt is a Go package for building Bluetooth Low Energy peripherals

# Package gatt provides a Bluetooth Low Energy GATT implementation.

Gatt (Generic Attribute Profile) is the protocol used to write BLE peripherals (servers) and centrals (clients).

As a peripheral, you can create services, characteristics, and descriptors,
advertise, accept connections, and handle requests.

As a central, you can scan, connect, discover services, and make requests.

## SETUP

### gatt supports both Linux and OS X.

### On Linux:
To gain complete and exclusive control of the HCI device, gatt uses
HCI_CHANNEL_USER (introduced in Linux v3.14) instead of HCI_CHANNEL_RAW.
Those who must use an older kernel may patch in these relevant commits
from Marcel Holtmann:

    Bluetooth: Introduce new HCI socket channel for user operation
    Bluetooth: Introduce user channel flag for HCI devices
    Bluetooth: Refactor raw socket filter into more readable code

Note that because gatt uses HCI_CHANNEL_USER, once gatt has opened the
device no other program may access it.

Before starting a gatt program, make sure that your BLE device is down:

    sudo hciconfig
    sudo hciconfig hci0 down  # or whatever hci device you want to use

If you have BlueZ 5.14+ (or aren't sure), stop the built-in
bluetooth server, which interferes with gatt, e.g.:

    sudo service bluetooth stop

Because gatt programs administer network devices, they must
either be run as root, or be granted appropriate capabilities:

    sudo <executable>
    # OR
    sudo setcap 'cap_net_raw,cap_net_admin=eip' <executable>
    <executable>

## Usage
Please see [godoc.org](http://godoc.org/github.com/paypal/gatt) for documentation.

## Examples

### Build and run the examples on a native environment (Linux or OS X)

Go is a compiled language, which means to run the examples you need to build them first.

    # Build the sample server.
    go build examples/server.go
    # Start the sample server.
    sudo ./server

Alternatively, you can use "go run" to build and run the examples in a single step:

    # Build and run the sample server.
    sudo go run examples/server.go

Discoverer and explorer demonstrates central (client) functions:

    # Discover surrounding peripherals.
    sudo go run examples/discoverer.go

    # Connect to and explorer a peripheral device.
    sudo go run examples/explorer.go <peripheral ID>

### Cross-compile and deploy to a target device

    # Build and run the server example on a ARMv5 target device.
    GOARCH=arm GOARM=5 GOOS=linux go build examples/server.go
    cp server <target device>
    # Start the server on the target device
    sudo ./server

See the server.go, discoverer.go, and explorer.go in the examples/
directory for writing server or client programs that run on Linux
and OS X.

Users, especially on Linux platforms, seeking finer-grained control
over the devices can see the examples/server_lnx.go for the usage
of Option, which are platform specific.

See the rest of the docs for other options and finer-grained control.

## Note
Note that some BLE central devices, particularly iOS, may aggressively
cache results from previous connections. If you change your services or
characteristics, you may need to reboot the other device to pick up the
changes. This is a common source of confusion and apparent bugs. For an
OS X central, see http://stackoverflow.com/questions/20553957.

## Known Issues

Currently OS X vesion  does not support subscribing to indications. 
Please check [#32](https://github.com/paypal/gatt/issues/32) for the status of this issue.

## REFERENCES

gatt started life as a port of bleno, to which it is indebted:
https://github.com/sandeepmistry/bleno. If you are having
problems with gatt, particularly around installation, issues
filed with bleno might also be helpful references.

To try out your GATT server, it is useful to experiment with a
generic BLE client. LightBlue is a good choice. It is available
free for both iOS and OS X.

gatt is similar to [bleno](https://github.com/sandeepmistry/bleno) and [noble](https://github.com/sandeepmistry/noble), which offer BLE GATT implementations for node.js.

Gatt is released under a [BSD-style license](./LICENSE.md).


gatt

Gobot is a framework for robotics, physical computing, and the Internet of Things

gobot

IoT is a simple framework for implementing a Google IoT Core device

IoT
===

A simple framework for implementing a Google IoT device.

This package makes use of the [context package] to handle request cancelation, timeouts, and deadlines.

[![gocover.io](https://gocover.io/_badge/github.com/vaelen/iot)](https://gocover.io/github.com/vaelen/iot)
[![Go Report Card](https://goreportcard.com/badge/github.com/vaelen/iot)](https://goreportcard.com/report/github.com/vaelen/iot)
[![Go Docs](https://godoc.org/github.com/vaelen/iot?status.svg)](https://godoc.org/github.com/vaelen/iot)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)  

Copyright 2018, Andrew C. Young <<andrew@vaelen.org>>

License: [MIT]

Here is an example showing how to use this library:
```go
package main

import (
	"context"
	"log"
	"github.com/vaelen/iot"
	// Your client must include the paho package
	// to use the default Eclipse Paho MQTT client.
	_ "github.com/vaelen/iot/paho"
)

func main() {
	ctx := context.Background()

	id := &iot.ID{
		DeviceID:  "deviceName",
		Registry:  "my-registry",
		Location:  "asia-east1",
		ProjectID: "my-project",
	}

	credentials, err := iot.LoadRSACredentials("rsa_cert.pem", "rsa_private.pem")
	if err != nil {
		panic("Couldn't load credentials")
	}

	options := iot.DefaultOptions(id, credentials)
	options.DebugLogger = log.Println
	options.InfoLogger = log.Println
	options.ErrorLogger = log.Println
	options.ConfigHandler = func(thing iot.Thing, config []byte) {
		// Do something here to process the updated config and create an updated state string
		state := []byte("ok")
		thing.PublishState(ctx, state)
	}

	thing := iot.New(options)

	err = thing.Connect(ctx, "ssl://mqtt.googleapis.com:443")
	if err != nil {
		panic("Couldn't connect to server")
	}
	defer thing.Disconnect(ctx)

	// This publishes to /events
	thing.PublishEvent(ctx, []byte("Top level telemetry event"))
	// This publishes to /events/a
	thing.PublishEvent(ctx, []byte("Sub folder telemetry event"), "a")
	// This publishes to /events/a/b
	thing.PublishEvent(ctx, []byte("Sub folder telemetry event"), "a", "b")
}
```

Thanks to [Infostellar] for supporting my development of this project.

[Andrew C. Young]: http;//vaelen.org
[Infostellar]: http://infostellar.net
[context package]: https://golang.org/pkg/context/
[MIT]: ../blob/master/LICENSE


RuleGo is a lightweight, high-performance, embedded, orchestrable component-based rule engine for IoT edge

# RuleGo

[![GoDoc](https://pkg.go.dev/badge/github.com/rulego/rulego)](https://pkg.go.dev/github.com/rulego/rulego) 
[![Go Report](https://goreportcard.com/badge/github.com/rulego/rulego)](https://goreportcard.com/report/github.com/rulego/rulego)
[![codecov](https://codecov.io/gh/rulego/rulego/graph/badge.svg?token=G6XCGY7KVN)](https://codecov.io/gh/rulego/rulego)
[![test](https://github.com/rulego/rulego/workflows/test/badge.svg)](https://github.com/rulego/rulego/actions/workflows/test.yml)
[![build](https://github.com/rulego/rulego/workflows/build/badge.svg)](https://github.com/rulego/rulego/actions/workflows/build.yml)
[![build](https://github.com/rulego/rulego/workflows/build/badge.svg)](https://github.com/rulego/rulego/actions/workflows/build.yml)
[![QQ-720103251](https://img.shields.io/badge/QQ-720103251-orange)](https://qm.qq.com/q/8RDaYcOry8)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go?tab=readme-ov-file#iot-internet-of-things)

English| [简体中文](README_ZH.md)

[Official Website](https://rulego.cc) | [Docs](https://rulego.cc/en/pages/introduction/) | [Contribution Guide](CONTRIBUTION.md)

<img src="doc/imgs/logo.png" alt="logo" width="100"/>   

`RuleGo` is a lightweight, high-performance, embedded, orchestrable component-based rule engine built on the Go language.

It can help you quickly build loosely coupled and flexible systems that can respond and adjust to changes in business requirements in real time.

`RuleGo` also provides a large number of reusable components that support the aggregation, filtering, distribution, transformation, enrichment, and execution of various actions on data, and can also interact and integrate with various protocols and systems.
It has a wide range of application potential in low-code, business code orchestration, data integration, workflows, large model intelligent agents, edge computing, automation, IoT, and other scenarios.

## Features

* **Lightweight:** No external middleware dependencies, efficient data processing and linkage on low-cost devices, suitable for IoT edge computing.
* **High Performance:** Thanks to Go's high-performance characteristics, RuleGo also employs technologies such as coroutine pools and object pools.
* **Dual Mode:** Embedded and Standalone Deployment modes. Supports embedding `RuleGo` into existing applications. It can also be deployed independently as middleware, providing rule engine and orchestration services.
* **Componentized:** All business logic is component-based, allowing flexible configuration and reuse.
* **Rule Chains:** Flexibly combine and reuse different components to achieve highly customized and scalable business processes.
* **Workflow Orchestration:** Supports dynamic orchestration of rule chain components, replacing or adding business logic without restarting the application.
* **Easy Extension:** Provides rich and flexible extension interfaces, making it easy to implement custom components or introduce third-party components.
* **Dynamic Loading:** Supports dynamic loading of components and extensions through Go plugins.
* **Nested Rule Chains:** Supports nesting of sub-rule chains to reuse processes.
* **Built-in Components:** Includes a large number of components such as `Message Type Switch`, `JavaScript Switch`, `JavaScript Filter`, `JavaScript Transformer`, `HTTP Push`, `MQTT Push`, `Send Email`, `Log Recording`, etc. Other components can be extended as needed.
* **Context Isolation Mechanism:** Reliable context isolation mechanism, no need to worry about data streaming in high concurrency situations.
* **AOP Mechanism:** Allows adding extra behavior to the execution of rule chains or directly replacing the original logic of rule chains or nodes without modifying their original logic.
* **Data Integration:** Allows dynamic configuration of Endpoints, such as `HTTP Endpoint`, `MQTT Endpoint`, `TCP/UDP Endpoint`, `UDP Endpoint`, `Kafka Endpoint`, `Schedule Endpoint`, etc.

## Use Cases

`RuleGo` is an orchestrable rule engine that excels at decoupling your systems.

- If your system's business is complex and the code is bloated
- If your business scenarios are highly customized or frequently changing
- If your system needs to interface with a large number of third-party applications or protocols
- Or if you need an end-to-end IoT solution
- Or if you need centralized processing of heterogeneous system data
- Or if you want to try hot deployment in the Go language...
  Then the RuleGo framework will be a very good solution.

#### Typical Use Cases

* **Edge Computing:** Deploy RuleGo on edge servers to preprocess data, filter, aggregate, or compute before reporting to the cloud. Data processing rules and distribution rules can be dynamically configured and modified through rule chains without restarting the system.
* **IoT:** Collect device data reports, make rule judgments through rule chains, and trigger one or more actions, such as sending emails, alarms, and linking with other devices or systems.
* **Data Distribution:** Distribute data to different systems using HTTP, MQTT, or gRPC based on different message types.
* **Application Integration:** Use RuleGo as glue to connect various systems or protocols, such as SSH, webhook, Kafka, message queues, databases, ChatGPT, third-party application systems.
* **Centralized Processing of Heterogeneous System Data:** Receive data from different sources (such as MQTT, HTTP, WS, TCP/UDP, etc.), then filter, format convert, and distribute to databases, business systems, or dashboards.
* **Highly Customized Business:** Decouple highly customized or frequently changing business and manage it with RuleGo rule chains. Business requirements change without needing to restart the main program.
* **Complex Business Orchestration:** Encapsulate business into custom components, orchestrate and drive these custom components through RuleGo, and support dynamic adjustment and replacement of business logic.
* **Microservice Orchestration:** Orchestrate and drive microservices through RuleGo, or dynamically call third-party services to process business and return results.
* **Decoupling of Business Code and Logic:** For example, user points calculation systems, risk control systems.
* **Automation:** For example, CI/CD systems, process automation systems, marketing automation systems.
* **Low Code:** For example, low-code platforms, iPaaS systems, ETL, LangFlow-like systems (interfacing with large models to extract user intent, then triggering rule chains to interact with other systems or process business).

## Architecture Diagram

<img src="doc/imgs/architecture.png" width="100%">
<p align="center">RuleGo Architecture Diagram</p>

## Rule Chain Running Example Diagram

  <img src="doc/imgs/rulechain/demo.png" style="height:40%;width:100%;"/>

[More Running Modes](http://8.134.32.225:9090/ui/)

## Installation

Install `RuleGo` using the `go get` command:

```bash
go get github.com/rulego/rulego
# or
go get gitee.com/rulego/rulego
```

## Usage

`RuleGo` is extremely simple to use. Just follow these 3 steps:

1. Define rule chains using JSON:
   - [Rule Chain DSL Doc](https://rulego.cc/en/pages/rule-chain/) 
   - [example_chain.json](testdata/rule/chain_call_rest_api.json)

2. Import the RuleGo package and use the rule chain definition to create a rule engine instance:

```go
import "github.com/rulego/rulego"
//Load the rule chain definition file.
ruleFile := fs.LoadFile("chain_call_rest_api.json")
// Create a rule engine instance using the rule chain definition
ruleEngine, err := rulego.New("rule01", ruleFile)
```

3. Hand over the message payload, message type, and message metadata to the rule engine instance for processing, and then the rule engine will process the message according to the rule chain's definition:

```go
// Define message metadata
metaData := types.NewMetadata()
metaData.PutValue("productType", "test01")
// Define message payload and message type
msg := types.NewMsg(0, "TELEMETRY_MSG", types.JSON, metaData, "{\"temperature\":35}")

// Hand over the message to the rule engine for processing
ruleEngine.OnMsg(msg)
```
> Real time update of rule chain logic without restarting the application
### Rule Engine Management API

- Dynamically update rule chains
```go
// Dynamically update rule chain logic
err := ruleEngine.ReloadSelf(ruleFile)
// Update a node under the rule chain
ruleEngine.ReloadChild("node01", nodeFile)
// Get the rule chain definition
ruleEngine.DSL()
```

- Rule Engine Instance Management:
```go
// Load all rule chain definitions in a folder into the rule engine pool
rulego.Load("/rules", rulego.WithConfig(config))
// Get an already created rule engine instance by ID
ruleEngine, ok := rulego.Get("rule01")
// Delete an already created rule engine instance
rulego.Del("rule01")
```

- Config:[Documentation](https://rulego.cc/en/pages/config/)
```go
// Create a default configuration
config := rulego.NewConfig()
// Debug node callback, the node configuration must be set to debugMode:true to trigger the call
// Both node entry and exit information will call this callback function
config.OnDebug = func (chainId,flowType string, nodeId string, msg types.RuleMsg, relationType string, err error) {
}
// Use the configuration
ruleEngine, err := rulego.New("rule01", []byte(ruleFile), rulego.WithConfig(config))
```

### Rule Chain Definition DSL
[Rule Chain Definition DSL](https://rulego.cc/en/pages/rule-chain/)

### Rule Chain Node Components
The core feature of `RuleGo` is its component-based architecture, where all business logic is encapsulated in components that can be flexibly configured and reused. Currently, 
`RuleGo` has built-in a vast array of commonly used components.
- [Standard Components](https://rulego.cc/en/pages/standard-components/)
- [rulego-components](https://github.com/rulego/rulego-components)  :[Documentation](https://rulego.cc/en/pages/extension-overview/)
- [rulego-components-ai](https://github.com/rulego/rulego-components-ai)
- [rulego-components-ci](https://github.com/rulego/rulego-components-ci)
- [rulego-components-iot](https://github.com/rulego/rulego-components-iot)
- [rulego-components-etl](https://github.com/rulego/rulego-components-etl)
- [rulego-marketplace](https://github.com/rulego/rulego-marketplace) :Dynamic component and rule chain marketplace
- [Custom Node Component Example](examples/custom_component) :[Documentation](https://rulego.cc/en/pages/custom-components-overview/)

## Data Integration
`RuleGo` provides the Endpoint module for unified data integration and processing of heterogeneous systems. For details, refer to: [Endpoint](endpoint/README.md)

### Input Endpoint Components
- [Endpoint Components](https://rulego.cc/en/pages/endpoint-extension/)
- [Endpoint DSL](https://rulego.cc/en/pages/endpoint-dsl/)

### RuleGo-Server
We have provided a ready-to-use automation workflow platform based on `RuleGo`: [RuleGo-Server](https://github.com/rulego/rulego-server) ,
and a front-end visual editor: [RuleGo-Editor](https://editor.rulego.cc/) .
## Performance

`RuleGo` completes most of its work during initialization, so running the rule chain almost doesn't add extra overhead to the system, and the resource consumption is extremely low, making it particularly suitable for running on edge servers.
Additionally, RuleGo uses Directed Acyclic Graph (DAG) to represent the rule chain, where each input message only needs to be processed along the path in the graph without matching all the rules, which greatly improves the efficiency of message processing and routing, and also saves system resources.

Performance test cases:
```
Machine: Raspberry Pi 2 (900MHz Cortex-A7*4,1GB LPDDR2)  
Data size: 260B   
Rule chain: JS script filtering->JS complex transformation->HTTP push   
Test results: 100 concurrent and 500 concurrent, memory consumption does not change much around 19M
```

[More performance test cases](https://rulego.cc/en/pages/performance/)

## Ecosystem
- [RuleGo-Editor](https://editor.rulego.cc/) : Rule chain visual editor
- [RuleGo-Server](https://github.com/rulego/rulego-server) : Automation workflow platform
- [rulego-components](https://gitee.com/rulego/rulego-components) : Extension component library
- [rulego-components-ai](https://github.com/rulego/rulego-components-ai) : AI scenario component library
- [rulego-components-ci](https://github.com/rulego/rulego-components-ci) : CI/CD scenario component library
- [rulego-components-iot](https://github.com/rulego/rulego-components-iot) : IoT scenario component library
- [rulego-components-etl](https://github.com/rulego/rulego-components-etl) : ETL scenario component library
- [rulego-marketplace](https://github.com/rulego/rulego-marketplace) : Dynamic component and rule chain marketplace

## Contribution
Any form of contribution is welcome, including submitting issues, suggestions, documentation, tests or code. [Contribution Guide](CONTRIBUTION.md)

## License
`RuleGo` uses Apache 2.0 license, please refer to [LICENSE](LICENSE) file for details.

## Contact Us
Email: rulego@outlook.com

rulego

Lightweight stream processing engine for IoT

[![Build Status](https://travis-ci.org/sensorbee/sensorbee.svg?branch=master)](https://travis-ci.org/sensorbee/sensorbee)
[![Coverage Status](https://coveralls.io/repos/github/sensorbee/sensorbee/badge.svg?branch=master)](https://coveralls.io/github/sensorbee/sensorbee?branch=master)

**This project has been discontinued.**

# SensorBee: Lightweight stream processing engine for IoT

See http://sensorbee.io/ for details.


sensorbee

Kubernetes native IoT development framework

<div align="right">

[中文](README-zh.md) | English | [日本語](README-ja.md)

[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat&logo=github&color=2370ff&labelColor=454545)](http://makeapullrequest.com)
[![Go Report Card](https://goreportcard.com/badge/github.com/Edgenesis/shifu)](https://goreportcard.com/report/github.com/Edgenesis/shifu)
[![codecov](https://codecov.io/gh/Edgenesis/shifu/branch/main/graph/badge.svg?token=OX2UN22O3Z)](https://codecov.io/gh/Edgenesis/shifu)
[![Build Status](https://dev.azure.com/Edgenesis/shifu/_apis/build/status/shifu-build-muiltistage?branchName=main)](https://dev.azure.com/Edgenesis/shifu/_build/latest?definitionId=19&branchName=main)
[![golangci-lint](https://github.com/Edgenesis/shifu/actions/workflows/golangci-lint.yml/badge.svg)](https://github.com/Edgenesis/shifu/actions/workflows/golangci-lint.yml)

</div>
 
<div align="center">

<img width="300px" src="./img/shifu-logo.svg"></img>
<div align="center">

<h1 style="border-bottom: none">
<br>
    Kubernetes native IoT Gateway
    <br />
</h1>
Shifu is a Kubernetes native, production-grade, protocol & vendor agnostic IoT gateway.
</div>
</div>

<div align="center">
    <a href="https://discord.gg/2tbdBrkGHv"><img src="https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white" height="25"></a>
    &nbsp;
    <a href="https://x.com/ShifuFramework"><img src="https://img.shields.io/twitter/follow/ShifuFramework" height="25"></a>
    &nbsp;
    <a href="https://www.linkedin.com/company/edgenesis/"><img src="https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white" height="25"></a>
    &nbsp;
    <a href="https://www.youtube.com/channel/UCsaj5f4IKKKn9OMiTVYCvRA"><img src="https://img.shields.io/youtube/channel/subscribers/UCsaj5f4IKKKn9OMiTVYCvRA" height="25"></a>
    &nbsp;
    <a href="https://github.com/Edgenesis/shifu"><img src="https://img.shields.io/github/stars/Edgenesis/shifu" height="25"></a>
</div>

## Shifu's value: Let's develop APPs, not infra
<div align="center">
<img width="900px" src="./img/iot-stack-with-shifu.svg"></img>
</div>

## CNCF Livestream with Live Demo

[![Cloud Native Live](https://img.youtube.com/vi/qMrdM1QcLMk/maxresdefault.jpg)](https://www.youtube.com/watch?v=qMrdM1QcLMk)

## Features
**Kubernetes native** — developing your application while managing your devices, spare the need for maintaining an additional O&M infrastructure.

**Open Platform** — No vendor lock-in. You can easily deploy Shifu on the edge(from RaspberryPi to edge clusters) or on the cloud(public, private and hybrid cloud are all supported).

**Protocol agnostic** — HTTP, MQTT, RTSP, Siemens S7, TCP socket, OPC UA...The microservice architecture of Shifu enables it to quickly adapt to new protocols.

## Terms 
**shifu** - a Kubernetes CRD for integrating IoT devices into the cluster.

**DeviceShifu** - a Kubernetes pod as well as the atomic unit of Shifu. DeviceShifu mainly contains the driver of the device and represents a device in the cluster. Or you can call it "digital twin" of the device.

<div align="center">
<img width="900px" src="./img/shifu-architecture.png"></img>
</div>

## How to connect a proprietary-protocol camera with five lines of code
<div align="center">

<img width="900px" src="./img/five-lines-to-connect-to-a-camera.gif"></img>

<img width="900px" src="./img/star.gif"></img>
</div>

## Community

Welcome to the Shifu community to share your thoughts and ideas! Any suggestion will be deeply valued.
We couldn't be more excited to have you.

[![Join Discord](https://img.shields.io/badge/Discord-Join-5865F2?style=flat&logo=discord&logoColor=white)](https://discord.gg/CkRwsJ7raw)
[![Follow X](https://img.shields.io/twitter/follow/ShifuFramework)](https://x.com/ShifuFramework)
[![GitHub Discussions](https://img.shields.io/badge/GitHub%20Discussions-post-orange)](https://github.com/Edgenesis/shifu/discussions)
[![YouTube Subscribers](https://img.shields.io/youtube/channel/subscribers/UCsaj5f4IKKKn9OMiTVYCvRA)](https://www.youtube.com/channel/UCsaj5f4IKKKn9OMiTVYCvRA)

## Get Started

Welcome to check 🗒️[Shifu Documentation](https://shifu.dev/) for detailed information on:
- 🔧[Install](https://shifu.dev/docs/guides/install/install-shifu-dev)
- 🔌[Connect devices](https://shifu.dev/docs/guides/cases/)
- 👨‍💻[Application Development](https://shifu.dev/docs/guides/application/)
- 🎮[Try Our KillerCoda Demo](https://killercoda.com/shifu/shifu-demo)

## Contributing

Feel free to [create an issue](https://github.com/Edgenesis/shifu/issues/new/choose) or [submit a pull request](https://github.com/Edgenesis/shifu/pulls)!

We will forever be grateful to all the [contributors](https://github.com/Edgenesis/shifu/graphs/contributors).

## Shifu is officially a [CNCF landscape project](https://landscape.cncf.io/)

<div align="center">
<img width="900px" src="./img/cncf-logo.png"></img>
</div>

<div align="center">
<img width="900px" src="./img/cncf.png"></img>
</div>

## Stargazers over time

[![Stargazers over time](https://starchart.cc/Edgenesis/shifu.svg)](https://starchart.cc/Edgenesis/shifu)

## License
This project is distributed under Apache 2.0 License.


shifu

<img width="100%" height="auto" src="doc/static/img/banner-v3.svg" alt="smart home logo">

# The **Smart Home**

[![Go Report Card](https://goreportcard.com/badge/github.com/e154/smart-home)](https://goreportcard.com/report/github.com/e154/smart-home)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![telegram group](https://img.shields.io/badge/telegram-group-blue)](https://t.me/SmartHomGo)

| Branch | Status                                                                                                                                                          |
|--------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| master | [![Build and Deploy](https://github.com/e154/smart-home/actions/workflows/build.yml/badge.svg)](https://github.com/e154/smart-home/actions/workflows/build.yml) |
| dev    | [![Testing](https://github.com/e154/smart-home/actions/workflows/test.yml/badge.svg)](https://github.com/e154/smart-home/actions/workflows/test.yml)            |
| docs   | [![Docs](https://github.com/e154/smart-home/actions/workflows/docs.yml/badge.svg)](https://github.com/e154/smart-home/actions/workflows/docs.yml)               |

### Overview

With the help of the software package **Smart Home** you can control many devices. Distributed network of devices based
on software package **Smart Home** has no geographical boundaries and allows manage devices anywhere in the Internet
through a system of nodes - microservices. You will be able to interact with these devices as if they were on your local
network. Create scripts and reactions to events in the web interface of the configurator through a flexible scripting
system.

The system does not require a permanent connection to the Internet, it is completely autonomous and has no dependencies
on external services.

The basic principles underlying the system being developed are ease of setup, low cost of content and accessibility of
the component base.

- [Features](#features)
- [Demo access](#demo-access)
- [Supported system](#supported-system)
- [Quick installation](#quick-installation)
    - [Postgresql](#database-postgresql)
- [Docker](#docker)
- [Support](#support)
- [Contributors](#contributors)
- [See also](#see-also)
- [License](#license)

### Features

1. The ultimate smart thing solution - server, configurator, gateway
2. Free and open source
3. Cross-platform Linux, MacOS, Windows ...
4. Convenient WEB-configurator for fine-tuning
5. Powerful visual interface editor
5. Organization of remote access without white IP FREE
6. Role system for separation of access rights
7. Plugin system
7. Programs in javaScript, coffeeScript, typeScript
8. Notification system SMS, Email, Slack, Telegram, Web push, html5
9. Embedded MQTT server/client/bridge
9. MODBUS, [ZIGBEE2MQTT](https://www.zigbee2mqtt.io/), rpc calling, etc
10. Autonomous system.
11. Telegram bots
11. Automation scenarios
11. Quick backup/recovery
12. Have Docker images to enhance system security
13. Minimum consumption of resources.
14. Optimized for embedded devices like Raspberry Pi
15. 100% local home automation
16. Create and restore full backups of your whole configuration with ease
17. Management web interface integrated into Smart home

### Demo access

dashboard:<br />
[dashboard](https://gate.e154.ru:8443) (https://gate.e154.ru:8443) <br />
[dashboard](http://gate.e154.ru:8080) (http://gate.e154.ru:8080) <br />

server id:<br />
**cf4463fc-2f39-4271-a034-5c0c8087c56c**

user: admin@e154.ru <br />
pass: admin

user: user@e154.ru <br />
pass: user

openapi v3 spec:<br />
[swagger](https://gate.e154.ru:8443/#/etc/swagger) (https://gate.e154.ru:8443/#/etc/swagger)

### Supported system

* macOS 386 10.6
* macOS amd64 10.6
* linux 386
* linux amd64
* linux arm-5
* linux arm-6
* linux arm-7
* linux arm-64
* linux mips64
* linux mips64le
* windows 386
* windows amd64

Schematic smart home map

<img src="doc/static/img/smart-home-network.svg" alt="smart-home map" width="630">

### Database postgresql

[Installing PostgreSQL 15](https://e154.github.io/smart-home/docs/install/postgresql/)

### Editing configuration files

```bash
cp conf/config.dev.json conf/config.json
```

### Main server install

Download the latest server version from [releases](https://github.com/e154/smart-home/releases)

show help options

```bash
./server-linux-amd64 help
```

run the server

```bash
./server-linux-amd64
```

### Docker

```bash
git clone https://github.com/e154/smart-home
cd smart-home
docker-compose up
```

It's all

### Support

Smart home Wiki: [e154.github.io/smart-home](https://e154.github.io/smart-home/)
Bugs and feature requests: GitHub issues

### Contributors

- [Alex Filippov](https://github.com/e154)

All the contributors are welcome. If you would like to be the contributor please accept some rules.

- The pull requests will be accepted only in "develop" branch
- All modifications or additions should be tested

Thank you for your understanding!

### Star History

<a href="https://star-history.com/#e154/smart-home&Date">
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=e154/smart-home&type=Date&theme=dark" />
   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=e154/smart-home&type=Date" />
   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=e154/smart-home&type=Date" />
 </picture>
</a>

### LICENSE

[GPLv3 Public License](https://github.com/e154/smart-home/blob/master/LICENSE)


smart-home

Project Eywa is essentially a connection manager that keeps track of connected devices

Eywa
====


What is Eywa?
-------------

**"Eywa is the guiding force and deity of Pandora and the Na'vi. All living things on Pandora connect to Eywa."** -- [Avatar Wiki](http://james-camerons-avatar.wikia.com/wiki/Eywa)

**Project Eywa** is essentially a connection manager that keeps track of connected devices. But more than just connecting devices, it is also capable of designing flexible APIs, sending control commands to them, collecting data from them, real-time monitoring and debugging, in the end, providing query interfaces that can be used for data visualization.

Eywa lets the teams of embedded system developers forget about reinventing the backend services and provides a commonly used protocol, websocket, to make real-time communication easily achievable.

Why is it useful?
-----------------

We are a group of people who are interested in **Home Automations** and **Smart Devices**. Often time, these projects involve connecting devices into cloud, tracking the usage of different functionalities, collecting the data and also controlling them. After worked on several similar projects, we found there is no reason to reinvent the wheel each time for different applications. So we came up with **Project Eywa** to help small teams like us reduce their development circles.

What features does it have?
---------------------------

Here is a growing list of features we want to support:

- [x] Connection Manager
- [x] Device Control
- [x] Command Line Tools
- [x] Connection Attach Mode
- [ ] Admin Panel
- [x] Basic Authentication
- [x] SSL protection
- [x] Data Indexing
- [ ] Data Streaming
- [x] Data Export
- [x] Data Retention
- [ ] Data Visualization
- [x] Query Interface
- [ ] Clustering
- [ ] Custom Web hooks
- [ ] Custom Monitors
- [ ] M2M (machine to machine) communication
- [x] HTTP Long-Polling
- [x] Websocket
- [ ] MQTT integration
- [x] Dockerized image

Our Admin Panel and Data Visualization dashboard will be releasing soon.

Please let us know if you want more features by creating issues. Pull requests are also very much welcome!

Performance
-----------

How performant is Eywa? Well, we did a simple benchmark and the [benchmark script](https://github.com/xcodersun/eywa/blob/master/benchmark/benchmark.go) is also available in the repo under `benchmark` directory.

The latest benchmark shows, on a machine of 12 CPUs + 32GB mem from [Digital Ocean](https://www.digitalocean.com/). A single Eywa node can keep track of more than 1.5 million devices, with a lot of potential. CPU is merely used, but memory is the limiting factor.

For more details please check out wiki on [Performance](https://github.com/xcodersun/eywa/wiki/Performance).

How to use?
-----------

You can get started with our [wiki](https://github.com/xcodersun/eywa/wiki).


Community / Contributing
------------------------

Eywa maintains a forum [goeywa](https://groups.google.com/forum/#!forum/goeywa), where you should feel free to ask questions, request features, or to announce projects that are built with Eywa. You should also see updates and road maps on Eywa in this forum.

Contributions to Eywa are very much welcomed. Fork us if you would like to.


eywa

Suite of libraries for IoT devices, experimental for x/exp/io

# Go libraries/drivers for IoT devices

[![GoDoc](http://godoc.org/github.com/goiot/devices?status.svg)](http://godoc.org/github.com/goiot/devices)
[![Build Status](https://travis-ci.org/goiot/devices.svg?branch=master)](https://travis-ci.org/goiot/devices)

This repo contains a suite of libraries for IoT devices/sensors/actuators. The suite is meant to be as dependency free
and as idiomatic as possible.

If you are interested in helping, feel free to look at the open issues mentioning help needed.
If you have questions on how you implement some of the features, don't hesitate to ask. If you are trying to integrate
these libraries in your projects and have questions, please open an issue.

Note that there are a LOT of IoT devices and while we would love to have libs for all of them, we will need your help.

## Supported devices

### [Grove](http://www.seeedstudio.com/wiki/Grove_System)

* [3 Axis Digital Accelerometer](https://github.com/goiot/devices/tree/master/accel3xdigital)
* [LCD RGB Backlight](https://github.com/goiot/devices/tree/master/lcdrgbbacklight)
* [OLED 96 x 96](https://github.com/goiot/devices/tree/master/oled96x96)

### [Adafruit](https://www.adafruit.com/)

* [DotStar RGB LED (APA102)](https://github.com/goiot/devices/tree/master/dotstar)
* [Monochrome 0.96" 128x64 OLED graphic display (SSD1306)](https://github.com/goiot/devices/tree/master/monochromeoled)

### [Pimoroni](https://shop.pimoroni.com/)

* [PiGlow](https://github.com/goiot/devices/tree/master/piglow)

### Generic

The following libraries can be used on multiple devices that use the same underlying component.
Often various manufacturers create their own version of a device using the same component.
If you have device that doesn't have a driver listed above, look at the main component used and see
it it matches one of the ones mentioned below.

* [APA102 LED strip](https://github.com/goiot/devices/tree/master/dotstar)
* [SSD1306 OLED](https://github.com/goiot/devices/tree/master/monochromeoled)

## Repo organization

Device libraries are organized by manufacturers and should use names that easy to google or identify.
Each device package contains a README file with references and details about the device (and usually a picture and links to datasheets). You will also find an examples folder with basic examples on how to use the library.

## Test setup

Testing IoT devices is quite complicated, most of us use a [Raspberry Pi](https://www.raspberrypi.org/), connect the devices
directly or via [shield](http://www.dexterindustries.com/grovepi/) and run the examples to test. Yes, it's far from perfect :(

## More information / Advanced topics

Checkout the [wiki](https://github.com/goiot/devices/wiki) for more info.


devices

An extensive Philips Hue client library for Go

[![Go](https://github.com/amimof/huego/actions/workflows/go.yaml/badge.svg)](https://github.com/amimof/huego/actions/workflows/go.yaml) [![Go Report Card](https://goreportcard.com/badge/github.com/amimof/huego)](https://goreportcard.com/report/github.com/amimof/huego) [![codecov](https://codecov.io/gh/amimof/huego/branch/master/graph/badge.svg)](https://codecov.io/gh/amimof/huego) [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/avelino/awesome-go)

# Huego

An extensive Philips Hue client library for [`Go`](https://golang.org/) with an emphasis on simplicity. It is designed to be clean, unbloated and extensible. With `Huego` you can interact with any Philips Hue bridge and its resources including `Lights`, `Groups`, `Scenes`, `Sensors`, `Rules`, `Schedules`, `Resourcelinks`, `Capabilities` and `Configuration` .

![](./logo/logo.png)


## Installation
Get the package and import it in your code.
```
go get github.com/amimof/huego
```
You may use [`New()`](https://godoc.org/github.com/amimof/huego#New) if you have already created an user and know the IP address to your bridge.
```Go
package main

import (
  "github.com/amimof/huego"
  "fmt"
)

func main() {
  bridge := huego.New("192.168.1.59", "username")
  l, err := bridge.GetLights()
  if err != nil {
    panic(err)
  }
  fmt.Printf("Found %d lights", len(l))
}
```
Or discover a bridge on your network with [`Discover()`](https://godoc.org/github.com/amimof/huego#Discover) and create a new user with [`CreateUser()`](https://godoc.org/github.com/amimof/huego#Bridge.CreateUser). To successfully create a user, the link button on your bridge must have been pressed before calling `CreateUser()` in order to authorise the request.
```Go
func main() {
  bridge, _ := huego.Discover()
  user, _ := bridge.CreateUser("my awesome hue app") // Link button needs to be pressed
  bridge = bridge.Login(user)
  light, _ := bridge.GetLight(3)
  light.Off()
}
``` 

## Documentation

See [godoc.org/github.com/amimof/huego](https://godoc.org/github.com/amimof/huego) for the full package documentation.

## Contributing

All help in any form is highly appreciated and your are welcome participate in developing `Huego` together. To contribute submit a `Pull Request`. If you want to provide feedback, open up a Github `Issue` or contact me personally. 

The Best Go Libraries For IoT (Internet of Things) (13)