Merge pull request #24 from maxlerebourg/20-implement-shared-cache-with-an-external-redis-as-an-option

Create Environnement to work on redis cache
Merge branch 'main' into 20-implement-shared-cache-with-an-external-redis-as-an-option
2026-09-02 20:28:50 +02:00 · 2022-11-06 13:02:58 +01:00 · 2022-11-06 13:02:40 +01:00 · 2022-11-06 13:01:25 +01:00 · 2022-11-06 12:57:32 +01:00 · 2022-11-06 12:50:19 +01:00
25 changed files with 1822 additions and 337 deletions
@@ -3,7 +3,7 @@ name: Main
 on:
  push:
    branches:
-      - master
+      - main
  pull_request:

 jobs:
@@ -1,2 +1,6 @@
 .idea/
 .DS_Store
+config
+db
+logs
+docker-compose.dev.yml
@@ -4,10 +4,9 @@ iconPath: .assets/icon.png

 import: github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin

-summary: 'Crowdsec Bouncer Traefik Plugin'
+summary: Middleware plugin which forwards the request IP to local Crowdsec agent, which can be used to allow/deny the request  

 testData:
-  bouncer:
-    enabled: true
-    crowdsecLapiKey: 40796d93c2958f9e58345514e67740e5
+  Enabled: false
+  CrowdsecLapiKey: 40796d93c2958f9e58345514e67740e5

@@ -18,3 +18,46 @@ vendor:

 clean:
 	rm -rf ./vendor
+
+run_dev:
+	docker-compose -f docker-compose.dev.yml up -d --remove-orphans
+
+run_local:
+	docker-compose -f docker-compose.local.yml up -d --remove-orphans
+
+run_behindproxy:
+	docker-compose -f exemples/behind-proxy/docker-compose.cloudflare.yml up -d --remove-orphans
+
+run_cacheredis:
+	docker-compose -f exemples/redis-cache/docker-compose.redis.yml up -d --remove-orphans
+
+run:
+	docker-compose -f docker-compose.yml up -d --remove-orphans
+
+restart_dev:
+	docker-compose -f docker-compose.dev.yml restart
+
+restart_local:
+	docker-compose -f docker-compose.local.yml restart
+
+restart:
+	docker-compose -f docker-compose.yml restart
+
+show_logs:
+	docker-compose -f docker-compose.yml restart
+
+show_local_logs:
+	docker-compose -f docker-compose.local.yml logs -f
+
+show_dev_logs:
+	docker-compose -f docker-compose.dev.yml logs -f
+
+clean_all_docker:
+	docker-compose -f exemples/behind-proxy/docker-compose.cloudflare.yml down --remove-orphans
+	docker-compose -f exemples/behind-proxy/docker-compose.redis.yml down --remove-orphans
+	docker-compose -f docker-compose.local.yml down --remove-orphans
+	docker-compose -f docker-compose.yml down --remove-orphans
+
+show_metrics:
+	docker exec crowdsec cscli metrics
+
@@ -1,4 +1,8 @@
-[![Build Status](https://github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/workflows/Main/badge.svg?branch=master)](https://github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/actions)
+![GitHub](https://img.shields.io/github/license/maxlerebourg/crowdsec-bouncer-traefik-plugin)
+![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/maxlerebourg/crowdsec-bouncer-traefik-plugin)
+![GitHub tag (latest SemVer)](https://img.shields.io/github/v/tag/maxlerebourg/crowdsec-bouncer-traefik-plugin)
+[![Build Status](https://github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/actions/workflows/go-cross.yml/badge.svg)](https://github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/actions)
+[![Go Report Card](https://goreportcard.com/badge/github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin)](https://goreportcard.com/badge/github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin)

 # Crowdsec Bouncer Traefik plugin

@@ -6,30 +10,85 @@ This plugins aims to implement a Crowdsec Bouncer into a traefik plugin.
 > [CrowdSec](https://www.crowdsec.net/) is an open-source and collaborative IPS (Intrusion Prevention   System) and a security suite.
 > We leverage local behavior analysis and crowd power to build the largest CTI network in the world.

-The purpose is to enable treafik to authorize and block requests from IP based and their reputation and behavior.
+The purpose is to enable treafik to authorize or block requests from IP based and their reputation and behavior.

 The crowdsec utility will provide the community blocklist which contains highly reported and validated IP banned from the crowdsec network.

 When used with crowdsec it will leverage the local API which will analyze traefik logs and take decisions on the requests made by users/bots. Malicious actors will be banned based on patterns against your website.

-There is 3 operating mode for this plugin:
- none -> If the client IP is on ban list, it will get a http code 403 response.
-         Otherwise, request will continue as usual. All request call the Crowdsec LAPI
+There are 3 operating modes (CrowdsecMode) for this plugin:

- live ->  If the client IP is on ban list, it will get a http code 403 response.
-          Otherwise, request will continue as usual.
-          The bouncer can leverage use of a local cache in order to reduce the number
-          of requests made to the Crowdsec LAPI. It will keep in cache the status for
-          each IP that makes queries.
-
- stream -> Stream Streaming mode allows you to keep in the local cache only the Banned IPs,
- 			every requests that does not hit the cache is authorized.
- 			Every minute, the cache is updated with news from the Crowdsec LAPI.
+| Mode | Description |
+|------|------|
+| none | If the client IP is on ban list, it will get a http code 403 response. Otherwise, request will continue as usual. All request call the Crowdsec LAPI |
+| live | If the client IP is on ban list, it will get a http code 403 response. Otherwise, request will continue as usual.    The bouncer can leverage use of a local cache in order to reduce the number of requests made to the Crowdsec LAPI. It will keep in cache the status for  each IP that makes queries. |
+| stream | Stream Streaming mode allows you to keep in the local cache only the Banned IPs, every requests that does not hit the cache is authorized. Every minute, the cache is updated with news from the Crowdsec LAPI. |

 The recommanded mode for performance is the streaming mode, decisions are updated every 60 sec by default and that's the only communication between traefik and crowdsec. Every requests that happens hits the cache for quick decisions.

+The cache can be local to the Traefik instance using the filesystem or use of a separated redis instance.  
+The redis instance is currently in beta and support Redis 7.0.X version
+
 ## Usage

+To get started, use the `docker-compose.yml` file.
+
+You can run it with:
+```bash
+make run
+```
+
+### Note
+
+**/!\ Since Release 1.10, cache is no longer duplicated but shared by all services**
+*This lowers the overhead of the cache in memory and the numbers of cache to fetch it from crowdsec in situation with many services*
+
+
+### Variables
+- Enabled
+  - bool
+  - enable the plugin
+  - default: false
+- LogLevel
+  - string
+  - default: `INFO`, expected value are: `INFO`, `DEBUG`
+- CrowdsecMode
+  - string
+  - default: `live`, expected value are: `none`, `live`, `stream`
+- CrowdsecLapiScheme
+  - string
+  - default: `http`, expected value are: `http`, `https`
+- CrowdsecLapiHost
+  - string
+  - default: "crowdsec:8080"
+  - Crowdsec LAPI available on which host and port.
+- CrowdsecLapiKey
+  - string
+  - Crowdsec LAPI generated key for the bouncer : **must be unique by service**. 
+- UpdateIntervalSeconds
+  - int64
+  - default: 60
+  - Used only in `stream` mode, interval between fetching blacklisted IPs from LAPI
+- DefaultDecisionSeconds
+  - int64
+  - default: 60
+  - Used only in `live` mode, decision duration of accepted IPs
+- ForwardedHeadersTrustedIPs
+  - []string
+  - default: []
+  - List of IPs of trusted Proxies that are in front of traefik (ex: Cloudflare)
+- ForwardedHeadersCustomName
+  - string
+  - default: "X-Forwarded-For"
+  - Name of the header where the real IP of the client should be retrieved
+- RedisCacheEnabled
+  - bool
+  - default: false
+  - enable redis cache instead of filesystem cache
+- RedisCacheHost
+  - string 
+  - default: "redis:6379"
+  - hostname and port for the redis service


 ### Configuration
@@ -42,7 +101,7 @@ The following declaration (given here in YAML) defines a plugin:
 # Static configuration

 experimental:
-  localPlugins:
+  plugins:
    bouncer:
      moduleName: github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
 ```
@@ -58,7 +117,7 @@ http:
      entryPoints:
        - web
      middlewares:
-        - my-plugin
+        - crowdsec

  services:
    service-foo:
@@ -70,13 +129,57 @@ http:
    crowdsec:
      plugin:
        bouncer:
-          enabled: true
-          crowdseclapikey: 40796d93c2958f9e58345514e67740e5
+          enabled: false
          updateIntervalSeconds: 60
          defaultDecisionSeconds: 60
-          crowdsecLapiHost: 
-          crowdsecLapiScheme: 
-          crowdsecMode: stream
+          crowdsecMode: live
+          crowdsecLapiKey: privateKey
+          crowdsecLapiHost: crowdsec:8080
+          crowdsecLapiScheme: http
+          forwardedHeadersTrustedIPs: 
+            - 10.0.10.23/32
+            - 10.0.20.0/24
+          forwardedHeadersCustomName: X-Custom-Header
+          redisCacheEnabled: false
+          redisCacheHost: "redis:6379"
+```
+These are the default values of the plugin except for LapiKey.
+
+#### Generate LAPI KEY
+You need to generate a crowdsec API key for the LAPI.
+You can follow the documentation here: https://docs.crowdsec.net/docs/user_guides/lapi_mgmt/
+
+```bash
+docker-compose -f docker-compose-local.yml up -d crowdsec
+docker exec crowdsec cscli bouncers add crowdsecBouncer
+```
+
+This LAPI key must be set where is noted FIXME-LAPI-KEY in the docker-compose-test.yml
+```yaml
+...
+whoami:
+  labels:
+    - "traefik.http.middlewares.crowdsec.plugin.bouncer.crowdseclapikey=FIXME-LAPI-KEY"
+    - "traefik.http.middlewares.crowdsec.plugin.bouncer.crowdseclapischeme=http"
+    - "traefik.http.middlewares.crowdsec.plugin.bouncer.crowdseclapihost=crowdsec:8080"
+...
+crowdsec:
+  environment:
+    BOUNCER_KEY_TRAEFIK: FIXME-LAPI-KEY
+...
+```
+
+You can then run all the containers:
+```bash
+docker-compose up -d
+```
+
+#### Add manually an IP to the blocklist (testing purpose)
+
+```bash
+docker-compose up -d crowdsec
+docker exec crowdsec cscli decisions add --ip 10.0.0.10 # this will be effective 4h
+docker exec crowdsec cscli decisions remove --ip 10.0.0.10
 ```

 ### Local Mode
@@ -103,53 +206,58 @@ The source code of the plugin should be organized as follows:
                    └── vendor/* 
 ```

-For local developpement a docker-compose-local.yml is provided and reproduce the directory layout needed by traefik. This works once you have generated and filled your LAPI-KEY, if not look below for informations
+For local developpement a docker-compose.local.yml is provided and reproduce the directory layout needed by traefik. This works once you have generated and filled your LAPI-KEY (crowdsecLapiKey), if not look below for informations

 ```bash
-docker-compose -f docker-compose-local.yml up -d
+docker-compose -f docker-compose.local.yml up -d
 ```
-
-#### Generate LAPI-KEY
-You need to generate a crowdsec API key for the LAPI.
-You can follow the documentation here: https://docs.crowdsec.net/docs/user_guides/lapi_mgmt/
-
+Equivalent to
 ```bash
-docker-compose -f docker-compose-local.yml up -d crowdsec
-docker exec crowdsec cscli bouncers add crowdsecBouncer
+make run_local
 ```

-This LApi key must be set where is noted FIXME-LAPI-KEY in the docker-compose-test.yml
+### Exemples
+
+1. Behind another proxy service (ex: clouflare)
+
+You need to configure your Traefik to trust Forwarded headers by your front proxy
+In the exemple we use another instance of traefik with the container named cloudflare to simulate a front proxy
+
+The "internal" Traefik instance is configured to trust the cloudflare forward headers
 ```yaml
-...
-whoami:
-  labels:
-    - "traefik.http.middlewares.crowdsec.plugin.bouncer.crowdseclapikey=FIXME-LAPI-KEY"
-...
-crowdsec:
-  environment:
-    BOUNCER_KEY_TRAEFIK: FIXME-LAPI-KEY
-...
+  - "--entrypoints.web.forwardedheaders.trustedips=172.21.0.5"
 ```

-You can then run all the containers:
-```bash
-docker-compose -f docker-compose-local.yml up -d
+We configure the middleware to trust as well the IP:
+```yaml
+    - "traefik.http.middlewares.crowdsec1.plugin.bouncer.forwardedheaderstrustedips=172.21.0.5"
 ```

-#### Add manually an IP to the blocklist
-
+To run the environnement run:
 ```bash
-docker-compose -f docker-compose-local.yml up -d crowdsec
-docker exec crowdsec cscli decisions add --ip 10.0.0.10
+make run_behindproxy
+```
+
+2. With Redis as an external shared cache
+
+The plugin must be configured to connect to a redis instance
+```yaml
+  redisCacheHost: "redis:6379"
+```
+Here **redis** is the hostname of a container located in the same network as Traefik and **6379** the default port of redis
+
+To run the demo environnement run:
+```bash
+make run_cacheredis
 ```

 ### About

-[maxlerebourg](https://github.com/maxlerebourg) and [I](https://github.com/mhanotaux) have been using traefik since 2020.
-We come from developper and security engineer background and wanted to add the power of a very promesing technologie (Crowdsec) into the edge router we love.
+Me and [mathieuHa](https://github.com/mathieuHa) have been using traefik since 2020 at [Primadviz](https://primadviz.com).
+We come from web developper and security engineer background and wanted to add the power of a very promesing technology (Crowdsec) into the edge router we love.

 We initially run into this project: https://github.com/fbonalair/traefik-crowdsec-bouncer
 It was using traefik and forward auth middleware to verify every requests.
 They had to go through a webserver which then contacts of another webservice (the crowdsec LAPI) to make a decision based on the source IP.
-We initially proposed some improvement by implementing a streaming mode and a local cache
+We initially proposed some improvement by implementing a streaming mode and a local cache.
 With the Traefik hackathon we deciced to implement our solution directly as a traefik plugin which could be found by every one on plugins.traefik.io and be more performant.
@@ -1,4 +1,4 @@
 filenames:
- - /var/log/traefik/*.log
+ - /var/log/traefik/access.log
 labels:
  type: traefik
@@ -5,126 +5,112 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"io/ioutil"
-	"log"
-	"net"
 	"net/http"
 	"net/url"
 	"text/template"
 	"time"

-	ttl_map "github.com/leprosus/golang-ttl-map"
+	cache "github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/pkg/cache"
+	ip "github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/pkg/ip"
+	logger "github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/pkg/logger"
 )

 const (
-	crowdsecAuthHeader  = "X-Api-Key"
-	crowdsecRoute       = "v1/decisions"
-	crowdsecStreamRoute = "v1/decisions/stream"
-	cacheBannedValue    = "t"
-	cacheNoBannedValue  = "f"
+	streamMode              = "stream"
+	liveMode                = "live"
+	noneMode                = "none"
+	crowdsecLapiHeader      = "X-Api-Key"
+	crowdsecLapiRoute       = "v1/decisions"
+	crowdsecLapiStreamRoute = "v1/decisions/stream"
+	cacheTimeoutKey         = "updated"
 )

-var cache = ttl_map.New()
+var (
+	crowdsecStreamHealthy = false
+	ticker                chan bool
+)

+// Config the plugin configuration.
 type Config struct {
-	Enabled                bool   `json:"enabled,omitempty"`
-	CrowdsecMode           string `json:"crowdsecMode,omitempty"`
-	CrowdsecLapiScheme     string `json:"crowdsecLapiScheme,omitempty"`
-	CrowdsecLapiHost       string `json:"crowdsecLapiHost,omitempty"`
-	CrowdsecLapiKey        string `json:"crowdsecLapiKey,omitempty"`
-	UpdateIntervalSeconds  int64  `json:"updateIntervalSeconds,omitempty"`
-	DefaultDecisionSeconds int64  `json:"defaultDecisionSeconds,omitempty"`
+	Enabled                    bool     `json:"enabled,omitempty"`
+	LogLevel                   string   `json:"logLevel,omitempty"`
+	CrowdsecMode               string   `json:"crowdsecMode,omitempty"`
+	CrowdsecLapiScheme         string   `json:"crowdsecLapiScheme,omitempty"`
+	CrowdsecLapiHost           string   `json:"crowdsecLapiHost,omitempty"`
+	CrowdsecLapiKey            string   `json:"crowdsecLapiKey,omitempty"`
+	ForwardedHeadersCustomName string   `json:"forwardedheaderscustomheader,omitempty"`
+	UpdateIntervalSeconds      int64    `json:"updateIntervalSeconds,omitempty"`
+	DefaultDecisionSeconds     int64    `json:"defaultDecisionSeconds,omitempty"`
+	ForwardedHeadersTrustedIPs []string `json:"forwardedHeadersTrustedIps,omitempty"`
+	RedisCacheEnabled          bool     `json:"redisCacheEnabled,omitempty"`
+	RedisCacheHost             string   `json:"redisCacheHost,omitempty"`
 }

+// CreateConfig creates the default plugin configuration.
 func CreateConfig() *Config {
 	return &Config{
-		Enabled:                false,
-		CrowdsecMode:           "stream",
-		CrowdsecLapiScheme:     "http",
-		CrowdsecLapiHost:       "crowdsec:8080",
-		CrowdsecLapiKey:        "",
-		UpdateIntervalSeconds:  60,
-		DefaultDecisionSeconds: 60,
+		Enabled:                    false,
+		LogLevel:                   "INFO",
+		CrowdsecMode:               liveMode,
+		CrowdsecLapiScheme:         "http",
+		CrowdsecLapiHost:           "crowdsec:8080",
+		CrowdsecLapiKey:            "",
+		UpdateIntervalSeconds:      60,
+		DefaultDecisionSeconds:     60,
+		ForwardedHeadersTrustedIPs: []string{},
+		ForwardedHeadersCustomName: "X-Forwarded-For",
+		RedisCacheEnabled:          false,
+		RedisCacheHost:             "redis:6379",
 	}
 }

+// Bouncer a Bouncer struct.
 type Bouncer struct {
 	next     http.Handler
 	name     string
 	template *template.Template

 	enabled                bool
-	crowdsecStreamHealthy  bool
 	crowdsecScheme         string
 	crowdsecHost           string
 	crowdsecKey            string
 	crowdsecMode           string
 	updateInterval         int64
 	defaultDecisionTimeout int64
+	customHeader           string
+	poolStrategy           *ip.PoolStrategy
 	client                 *http.Client
 }

 // New creates the crowdsec bouncer plugin.
 func New(ctx context.Context, next http.Handler, config *Config, name string) (http.Handler, error) {
-	requiredStrings := map[string]string{
-		"CrowdsecLapiScheme": config.CrowdsecLapiScheme,
-		"CrowdsecLapiHost":   config.CrowdsecLapiHost,
-		"CrowdsecLapiKey":    config.CrowdsecLapiKey,
-		"CrowdsecMode":       config.CrowdsecMode,
-	}
-	for key, val := range requiredStrings {
-		if len(val) == 0 {
-			return nil, fmt.Errorf("%v cannot be empty", key)
-		}
-	}
-	requiredInt := map[string]int64{
-		"UpdateIntervalSeconds":  config.UpdateIntervalSeconds,
-		"DefaultDecisionSeconds": config.DefaultDecisionSeconds,
-	}
-	for key, val := range requiredInt {
-		if val < 1 {
-			return nil, fmt.Errorf("%v cannot be less than 1", key)
-		}
-	}
-	// none -> If the client IP is on ban list, it will get a http code 403 response.
-	//         Otherwise, request will continue as usual. All request call the Crowdsec LAPI
-	// live ->  If the client IP is on ban list, it will get a http code 403 response.
-	//          Otherwise, request will continue as usual.
-	//          The bouncer can leverage use of a local cache in order to reduce the number
-	//          of requests made to the Crowdsec LAPI. It will keep in cache the status for
-	//          each IP that makes queries.
-	// stream -> Stream Streaming mode allows you to keep in the local cache only the Banned IPs,
-	// 			every requests that does not hit the cache is authorized.
-	// 			Every minute, the cache is updated with news from the Crowdsec LAPI.
-	if !contains([]string{"none", "live", "stream"}, config.CrowdsecMode) {
-		return nil, fmt.Errorf("CrowdsecMode must be one of: none, live or stream")
-	}
-	if !contains([]string{"http", "https"}, config.CrowdsecLapiScheme) {
-		return nil, fmt.Errorf("CrowdsecLapiScheme must be one of: http, https")
-	}
-	testUrl := url.URL{
-		Scheme: config.CrowdsecLapiScheme,
-		Host:   config.CrowdsecLapiHost,
-		Path:   crowdsecRoute,
-	}
-	_, err := http.NewRequest(http.MethodGet, testUrl.String(), nil)
+	logger.Init(config.LogLevel)
+	err := validateParams(config)
 	if err != nil {
-		return nil, fmt.Errorf("CrowdsecLapiScheme://CrowdsecLapiHost: '%v://%v' must be an URL", config.CrowdsecLapiScheme, config.CrowdsecLapiHost)
+		logger.Info(fmt.Sprintf("%w", err))
+		return nil, err
 	}

+	checker, _ := ip.NewChecker(config.ForwardedHeadersTrustedIPs)
+
 	bouncer := &Bouncer{
 		next:     next,
 		name:     name,
 		template: template.New("CrowdsecBouncer").Delims("[[", "]]"),

 		enabled:                config.Enabled,
-		crowdsecStreamHealthy:  false,
 		crowdsecMode:           config.CrowdsecMode,
 		crowdsecScheme:         config.CrowdsecLapiScheme,
 		crowdsecHost:           config.CrowdsecLapiHost,
 		crowdsecKey:            config.CrowdsecLapiKey,
 		updateInterval:         config.UpdateIntervalSeconds,
+		customHeader:           config.ForwardedHeadersCustomName,
 		defaultDecisionTimeout: config.DefaultDecisionSeconds,
+		poolStrategy: &ip.PoolStrategy{
+			Checker: checker,
+		},
 		client: &http.Client{
 			Transport: &http.Transport{
 				MaxIdleConns:    10,
@@ -133,113 +119,65 @@ func New(ctx context.Context, next http.Handler, config *Config, name string) (h
 			Timeout: 5 * time.Second,
 		},
 	}
-	// if we are on a stream mode, we fetch in a go routine every minute the new decisions
-	if config.CrowdsecMode == "stream" {
-		go handleStreamCache(bouncer, true)
+	if config.RedisCacheEnabled {
+		cache.InitRedisClient(config.RedisCacheHost)
 	}
+	if config.CrowdsecMode == streamMode && ticker == nil {
+		ticker = startTicker(config, func() {
+			handleStreamCache(bouncer)
+		})
+		go handleStreamCache(bouncer)
+	}
+
 	return bouncer, nil
 }

-// TODO the serve HTTP should be split as it's too long
-func (a *Bouncer) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
-	if !a.enabled {
-		log.Printf("Crowdsec Bouncer not enabled")
-		a.next.ServeHTTP(rw, req)
+// ServeHTTP principal function of plugin.
+func (bouncer *Bouncer) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	if !bouncer.enabled {
+		bouncer.next.ServeHTTP(rw, req)
 		return
 	}

-	// TODO Make sur remote address does not include the port
-	remoteHost, _, err := net.SplitHostPort(req.RemoteAddr)
+	remoteHost, err := ip.GetRemoteIP(req, bouncer.poolStrategy, bouncer.customHeader)
 	if err != nil {
-		log.Printf("failed to extract ip from remote address: %v", err)
-		a.next.ServeHTTP(rw, req)
+		logger.Info(fmt.Sprintf("%w", err))
+		bouncer.next.ServeHTTP(rw, req)
 		return
 	}
+	logger.Debug(fmt.Sprintf("ServeHTTP ip:%v", remoteHost))

-	if a.crowdsecMode == "stream" || a.crowdsecMode == "live" {
-		isBanned, err := getDecision(remoteHost)
+	if bouncer.crowdsecMode != noneMode {
+		isBanned, err := cache.GetDecision(remoteHost)
 		if err == nil {
+			logger.Debug(fmt.Sprintf("ServeHTTP cacheHit isBanned:%v", isBanned))
 			if isBanned {
 				rw.WriteHeader(http.StatusForbidden)
 			} else {
-				a.next.ServeHTTP(rw, req)
+				bouncer.next.ServeHTTP(rw, req)
 			}
 			return
 		}
 	}

-	// Right here if we cannot join the stream we forbid the request to go on
-	if a.crowdsecMode == "stream" {
-		if a.crowdsecStreamHealthy {
-			a.next.ServeHTTP(rw, req)
+	// Right here if we cannot join the stream we forbid the request to go on.
+	if bouncer.crowdsecMode == streamMode {
+		if crowdsecStreamHealthy {
+			bouncer.next.ServeHTTP(rw, req)
 		} else {
 			rw.WriteHeader(http.StatusForbidden)
 		}
-		return
+	} else {
+		handleNoStreamCache(bouncer, rw, req, remoteHost)
 	}
-
-	// We are now in none or live mode
-	noneUrl := url.URL{
-		Scheme:   a.crowdsecScheme,
-		Host:     a.crowdsecHost,
-		Path:     crowdsecRoute,
-		RawQuery: fmt.Sprintf("ip=%v&banned=true", remoteHost),
-	}
-	request, _ := http.NewRequest(http.MethodGet, noneUrl.String(), nil)
-	request.Header.Add(crowdsecAuthHeader, a.crowdsecKey)
-	res, err := a.client.Do(request)
-	if err != nil {
-		log.Printf("failed to get decision: %s", err)
-		rw.WriteHeader(http.StatusForbidden)
-		return
-	}
-	defer res.Body.Close()
-	if res.StatusCode != 200 {
-		log.Printf("failed to get decision, status code: %d", res.StatusCode)
-		rw.WriteHeader(http.StatusForbidden)
-		return
-	}
-	body, err := ioutil.ReadAll(res.Body)
-	if err != nil {
-		log.Printf("failed to read body: %s", err)
-		rw.WriteHeader(http.StatusForbidden)
-		return
-	}
-	if !bytes.Equal(body, []byte("null")) {
-		var decisions []Decision
-		err = json.Unmarshal(body, &decisions)
-		if err != nil {
-			log.Printf("failed to parse body: %s", err)
-			rw.WriteHeader(http.StatusForbidden)
-			return
-		}
-		if len(decisions) == 0 {
-			if a.crowdsecMode == "live" {
-				setDecision(remoteHost, false, a.defaultDecisionTimeout)
-			}
-			a.next.ServeHTTP(rw, req)
-			return
-		}
-		duration, err := time.ParseDuration(decisions[0].Duration)
-		if err != nil {
-			log.Printf("failed to parse duration: %s", err)
-			rw.WriteHeader(http.StatusForbidden)
-			return
-		}
-		rw.WriteHeader(http.StatusForbidden)
-		setDecision(remoteHost, true, int64(duration.Seconds()))
-		return
-	}
-	if a.crowdsecMode == "live" {
-		setDecision(remoteHost, false, a.defaultDecisionTimeout)
-	}
-	a.next.ServeHTTP(rw, req)
 }

-// CUSTOM CODE
-// TODO place in another file
+// CUSTOM CODE.
+// TODO place in another file.
+
+// Decision Body returned from Crowdsec LAPI.
 type Decision struct {
-	Id        int    `json:"id"`
+	ID        int    `json:"id"`
 	Origin    string `json:"origin"`
 	Type      string `json:"type"`
 	Scope     string `json:"scope"`
@@ -249,88 +187,195 @@ type Decision struct {
 	Simulated bool   `json:"simulated"`
 }

+// Stream Body returned from Crowdsec Stream LAPI.
 type Stream struct {
 	Deleted []Decision `json:"deleted"`
 	New     []Decision `json:"new"`
 }

 func contains(source []string, target string) bool {
-	for _, a := range source {
-		if a == target {
+	for _, item := range source {
+		if item == target {
 			return true
 		}
 	}
 	return false
 }

-// Get Decision check in the cache if the IP has the banned / not banned value
-// Otherwise return with an error to add the IP in cache if we are on
-func getDecision(clientIP string) (bool, error) {
-	isBanned, ok := cache.Get(clientIP)
-	if ok && len(isBanned.(string)) > 0 {
-		if isBanned == cacheNoBannedValue {
-			return false, nil
-		} else {
-			return true, nil
+func startTicker(config *Config, work func()) chan bool {
+	ticker := time.NewTicker(time.Duration(config.UpdateIntervalSeconds) * time.Second)
+	stop := make(chan bool, 1)
+	go func() {
+		defer logger.Debug("ticker:stopped")
+		for {
+			select {
+			case <-ticker.C:
+				go work()
+			case <-stop:
+				return
+			}
 		}
-	}
-	return false, fmt.Errorf("no data")
+	}()
+	return stop
 }

-func setDecision(clientIP string, isBanned bool, duration int64) {
-	if isBanned {
-		cache.Set(clientIP, cacheBannedValue, duration)
-	} else {
-		cache.Set(clientIP, cacheNoBannedValue, duration)
+// We are now in none or live mode.
+func handleNoStreamCache(bouncer *Bouncer, rw http.ResponseWriter, req *http.Request, remoteHost string) {
+	routeURL := url.URL{
+		Scheme:   bouncer.crowdsecScheme,
+		Host:     bouncer.crowdsecHost,
+		Path:     crowdsecLapiRoute,
+		RawQuery: fmt.Sprintf("ip=%v&banned=true", remoteHost),
 	}
-}
-
-func handleStreamCache(a *Bouncer, initialized bool) {
-	// TODO clean properly on exit
-	time.AfterFunc(time.Duration(a.updateInterval)*time.Second, func() {
-		handleStreamCache(a, false)
-	})
-	streamUrl := url.URL{
-		Scheme:   a.crowdsecScheme,
-		Host:     a.crowdsecHost,
-		Path:     crowdsecStreamRoute,
-		RawQuery: fmt.Sprintf("startup=%t", initialized),
-	}
-	req, _ := http.NewRequest(http.MethodGet, streamUrl.String(), nil)
-	req.Header.Add(crowdsecAuthHeader, a.crowdsecKey)
-	res, err := a.client.Do(req)
-	if err != nil || res.StatusCode == http.StatusForbidden {
-		log.Printf("error while fetching decisions: %s", err)
-		a.crowdsecStreamHealthy = false
-		return
-	}
-	if res.StatusCode == http.StatusForbidden {
-		log.Printf("error while fetching decisions, status code: %d", res.StatusCode)
-		a.crowdsecStreamHealthy = false
-		return
-	}
-	defer res.Body.Close()
-	body, err := ioutil.ReadAll(res.Body)
+	body, err := crowdsecQuery(bouncer, routeURL.String())
 	if err != nil {
-		log.Printf("error while reading body: %s", err)
-		a.crowdsecStreamHealthy = false
+		logger.Info(fmt.Sprintf("%w", err))
+		rw.WriteHeader(http.StatusForbidden)
+		return
+	}
+
+	if bytes.Equal(body, []byte("null")) {
+		if bouncer.crowdsecMode == liveMode {
+			cache.SetDecision(remoteHost, false, bouncer.defaultDecisionTimeout)
+		}
+		bouncer.next.ServeHTTP(rw, req)
+		return
+	}
+
+	var decisions []Decision
+	err = json.Unmarshal(body, &decisions)
+	if err != nil {
+		logger.Info(fmt.Sprintf("failed to parse body: %s", err))
+		rw.WriteHeader(http.StatusForbidden)
+		return
+	}
+	if len(decisions) == 0 {
+		if bouncer.crowdsecMode == liveMode {
+			cache.SetDecision(remoteHost, false, bouncer.defaultDecisionTimeout)
+		}
+		bouncer.next.ServeHTTP(rw, req)
+		return
+	}
+	rw.WriteHeader(http.StatusForbidden)
+	duration, err := time.ParseDuration(decisions[0].Duration)
+	if err != nil {
+		logger.Info(fmt.Sprintf("failed to parse duration: %s", err))
+		return
+	}
+	if bouncer.crowdsecMode == liveMode {
+		cache.SetDecision(remoteHost, true, int64(duration.Seconds()))
+	}
+}
+
+func handleStreamCache(bouncer *Bouncer) {
+	// TODO clean properly on exit.
+	// Instead of blocking the goroutine interval for all the secondary node,
+	// if the master service is shut down, other goroutine can take the lead
+	// because updated routine information is in the cache
+	logger.Debug("handleStreamCache")
+	_, err := cache.GetDecision(cacheTimeoutKey)
+	if err == nil {
+		return
+	}
+	cache.SetDecision(cacheTimeoutKey, false, bouncer.updateInterval-1)
+	streamRouteURL := url.URL{
+		Scheme:   bouncer.crowdsecScheme,
+		Host:     bouncer.crowdsecHost,
+		Path:     crowdsecLapiStreamRoute,
+		RawQuery: fmt.Sprintf("startup=%t", !crowdsecStreamHealthy),
+	}
+	body, err := crowdsecQuery(bouncer, streamRouteURL.String())
+	if err != nil {
+		logger.Info(fmt.Sprintf("%w", err))
+		crowdsecStreamHealthy = false
 		return
 	}
 	var stream Stream
 	err = json.Unmarshal(body, &stream)
 	if err != nil {
-		log.Printf("error while parsing body: %s", err)
-		a.crowdsecStreamHealthy = false
+		logger.Info(fmt.Sprintf("error while parsing body: %s", err))
+		crowdsecStreamHealthy = false
 		return
 	}
 	for _, decision := range stream.New {
 		duration, err := time.ParseDuration(decision.Duration)
 		if err == nil {
-			setDecision(decision.Value, true, int64(duration.Seconds()))
+			cache.SetDecision(decision.Value, true, int64(duration.Seconds()))
 		}
 	}
 	for _, decision := range stream.Deleted {
-		cache.Del(decision.Value)
+		cache.DeleteDecision(decision.Value)
 	}
-	a.crowdsecStreamHealthy = true
+	crowdsecStreamHealthy = true
+}
+
+func crowdsecQuery(bouncer *Bouncer, stringURL string) ([]byte, error) {
+	var req *http.Request
+	req, _ = http.NewRequest(http.MethodGet, stringURL, nil)
+	req.Header.Add(crowdsecLapiHeader, bouncer.crowdsecKey)
+	res, err := bouncer.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("error while fetching %v: %s", stringURL, err)
+	}
+	if res.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("error while fetching %v, status code: %d", stringURL, res.StatusCode)
+	}
+	defer func(body io.ReadCloser) {
+		err = body.Close()
+		if err != nil {
+			logger.Info(fmt.Sprintf("failed to close body reader: %s", err))
+		}
+	}(res.Body)
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return nil, fmt.Errorf("error while reading body: %s", err)
+	}
+	return body, nil
+}
+
+func validateParams(config *Config) error {
+	requiredStrings := map[string]string{
+		"CrowdsecLapiScheme": config.CrowdsecLapiScheme,
+		"CrowdsecLapiHost":   config.CrowdsecLapiHost,
+		"CrowdsecLapiKey":    config.CrowdsecLapiKey,
+		"CrowdsecMode":       config.CrowdsecMode,
+	}
+	requiredInt := map[string]int64{
+		"UpdateIntervalSeconds":  config.UpdateIntervalSeconds,
+		"DefaultDecisionSeconds": config.DefaultDecisionSeconds,
+	}
+	for key, val := range requiredInt {
+		if val < 1 {
+			return fmt.Errorf("%v: cannot be less than 1", key)
+		}
+	}
+	for key, val := range requiredStrings {
+		if len(val) == 0 {
+			return fmt.Errorf("%v: cannot be empty", key)
+		}
+	}
+	if !contains([]string{noneMode, liveMode, streamMode}, config.CrowdsecMode) {
+		return fmt.Errorf("CrowdsecMode: must be one of 'none', 'live' or 'stream'")
+	}
+	if !contains([]string{"http", "https"}, config.CrowdsecLapiScheme) {
+		return fmt.Errorf("CrowdsecLapiScheme: must be one of 'http' or 'https'")
+	}
+	testURL := url.URL{
+		Scheme: config.CrowdsecLapiScheme,
+		Host:   config.CrowdsecLapiHost,
+	}
+	_, err := http.NewRequest(http.MethodGet, testURL.String(), nil)
+	if err != nil {
+		return fmt.Errorf("CrowdsecLapiScheme://CrowdsecLapiHost: '%v://%v' must be an URL", config.CrowdsecLapiScheme, config.CrowdsecLapiHost)
+	}
+	if len(config.ForwardedHeadersTrustedIPs) > 0 {
+		_, err = ip.NewChecker(config.ForwardedHeadersTrustedIPs)
+		if err != nil {
+			return fmt.Errorf("ForwardedHeadersTrustedIPs must be a list of IP/CIDR :%w", err)
+		}
+	} else {
+		logger.Debug("No IP provided for ForwardedHeadersTrustedIPs")
+	}
+
+	return nil
 }
@@ -1,22 +1,20 @@
-package crowdsec_bouncer_traefik_plugin_test
+package crowdsec_bouncer_traefik_plugin

 import (
 	"context"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-
-	crowdsec_bouncer_traefik_plugin "github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
 )

 func TestCrowdSec(t *testing.T) {
-	cfg := crowdsec_bouncer_traefik_plugin.CreateConfig()
-	cfg.CrowdsecLapiKey = "caca"
+	cfg := CreateConfig()
+	cfg.CrowdsecLapiKey = "test"

 	ctx := context.Background()
 	next := http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {})

-	handler, err := crowdsec_bouncer_traefik_plugin.New(ctx, next, cfg, "demo-plugin")
+	handler, err := New(ctx, next, cfg, "demo-plugin")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1,54 +0,0 @@
-version: "3.8"
-
-services:
-  traefik:
-    image: "traefik:v2.8.7"
-    container_name: "traefik"
-    command:
-      # - "--log.level=DEBUG"
-      - "--accesslog"
-      - "--accesslog.filepath=/var/log/traefik/traefik.log"
-      - "--api.insecure=true"
-      - "--providers.docker=true"
-      - "--providers.docker.exposedbydefault=false"
-      - "--entrypoints.web.address=:80"
-      - "--experimental.localplugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
-    volumes:
-      - "/var/run/docker.sock:/var/run/docker.sock:ro"
-      - "logs:/var/log/traefik"
-      - ./:/plugins-local/src/github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
-    ports:
-      - 8000:80
-      - 8080:8080
-
-  whoami:
-    image: traefik/whoami
-    container_name: "simple-service"
-    labels:
-      - "traefik.enable=true"
-      - "traefik.http.routers.whoami.rule=Host(`localhost`)"
-      - "traefik.http.routers.whoami.entrypoints=web"
-      - "traefik.http.routers.whoami.middlewares=crowdsec@docker"
-      - "traefik.http.middlewares.crowdsec.plugin.bouncer.enabled=true"
-      - "traefik.http.middlewares.crowdsec.plugin.bouncer.crowdseclapikey=FIXME-LAPI-KEY"
-
-  crowdsec:
-    image: crowdsecurity/crowdsec:v1.4.1
-    container_name: "crowdsec"
-    command: rm -rf /etc/crowdsec/acquis.yaml
-    environment:
-      COLLECTIONS: crowdsecurity/traefik
-      CUSTOM_HOSTNAME: crowdsec
-      BOUNCER_KEY_TRAEFIK: FIXME-LAPI-KEY
-    depends_on:
-      - 'traefik'
-    volumes:
-      - ./acquis.yaml:/etc/crowdsec/acquis.yaml:ro
-      - logs:/var/log/traefik:ro
-      - crowdsec-db:/var/lib/crowdsec/data/
-      - crowdsec-config:/etc/crowdsec/
-
-volumes:
-  logs:
-  crowdsec-db:
-  crowdsec-config:
@@ -0,0 +1,69 @@
+version: "3.8"
+
+services:
+  traefik:
+    image: "traefik:v2.9.4"
+    container_name: "traefik"
+    command:
+      # - "--log.level=DEBUG"
+      - "--accesslog"
+      - "--accesslog.filepath=/var/log/traefik/access.log"
+      - "--api.insecure=true"
+      - "--providers.docker=true"
+      - "--providers.docker.exposedbydefault=false"
+      - "--entrypoints.web.address=:80"
+
+      - "--experimental.localplugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - logs-local:/var/log/traefik
+      - ./:/plugins-local/src/github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
+    ports:
+      - 80:80
+      - 8080:8080
+    depends_on:
+      - crowdsec
+
+  whoami1:
+    image: traefik/whoami
+    container_name: "simple-service1"
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.router1.rule=Host(`localhost`) && Path(`/foo`)"
+      - "traefik.http.routers.router1.entrypoints=web"
+      - "traefik.http.routers.router1.middlewares=crowdsec1@docker" 
+      - "traefik.http.services.service1.loadbalancer.server.port=80"
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.enabled=true"
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.crowdseclapikey=40796d93c2958f9e58345514e67740e5"
+
+  whoami2:
+    image: traefik/whoami
+    container_name: "simple-service2"
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.router2.rule=Host(`localhost`) && Path(`/bar`)"
+      - "traefik.http.routers.router2.entrypoints=web"
+      - "traefik.http.routers.router2.middlewares=crowdsec2@docker"
+      - "traefik.http.services.service2.loadbalancer.server.port=80"
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.enabled=true"
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.crowdseclapikey=44c36dac5c4140af9f06f397508e82c7"
+
+  crowdsec:
+    image: crowdsecurity/crowdsec:v1.4.1
+    container_name: "crowdsec"
+    environment:
+      COLLECTIONS: crowdsecurity/traefik
+      CUSTOM_HOSTNAME: crowdsec
+      BOUNCER_KEY_TRAEFIK_1: 40796d93c2958f9e58345514e67740e5
+      BOUNCER_KEY_TRAEFIK_2: 44c36dac5c4140af9f06f397508e82c7
+    volumes:
+      - ./acquis.yaml:/etc/crowdsec/acquis.yaml:ro
+      - logs-local:/var/log/traefik:ro
+      - crowdsec-db-local:/var/lib/crowdsec/data/
+      - crowdsec-config-local:/etc/crowdsec/
+    labels:
+      - "traefik.enable=false"
+volumes:
+  logs-local:
+  crowdsec-db-local:
+  crowdsec-config-local:
@@ -2,50 +2,79 @@ version: "3.8"

 services:
  traefik:
-    image: "traefik:v2.8.7"
+    image: "traefik:v2.9.4"
    container_name: "traefik"
    command:
-      # - "--log.level=DEBUG"
      - "--accesslog"
-      - "--accesslog.filepath=/var/log/traefik/traefik.log"
+      - "--accesslog.filepath=/var/log/traefik/access.log"
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
-      - "--experimental.localplugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
+
+      - "--experimental.plugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
+      - "--experimental.plugins.bouncer.version=v1.1.0"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "logs:/var/log/traefik"
    ports:
      - 8000:80
      - 8080:8080
+    depends_on:
+      - 'crowdsec'

-  whoami:
+  whoami1:
    image: traefik/whoami
-    container_name: "simple-service"
+    container_name: "simple-service-1"
    labels:
      - "traefik.enable=true"
-      - "traefik.http.routers.whoami.rule=Host(`localhost`)"
-      - "traefik.http.routers.whoami.entrypoints=web"
-      - "traefik.http.routers.whoami.middlewares=crowdsec@docker"
-      - "traefik.http.middlewares.crowdsec.plugin.bouncer.enabled=true"
-      - "traefik.http.middlewares.crowdsec.plugin.bouncer.crowdseclapikey=FIXME-LAPI-KEY"
+      # Definition of the router
+      - "traefik.http.routers.router1.rule=Path(`/foo`)"
+      - "traefik.http.routers.router1.entrypoints=web"
+      - "traefik.http.routers.router1.middlewares=crowdsec2@docker"
+      # Definition of the service
+      - "traefik.http.services.service1.loadbalancer.server.port=80"
+      # Definition of the middleware
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.enabled=true"
+      # crowdseclapikey must be unique to the middleware attached to the service
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.crowdseclapikey=FIXME-LAPI-KEY-1"
+      # forwardedheaderstrustedips should be the IP of the proxy that is in front of traefik (if any)
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.forwardedheaderstrustedips=172.21.0.5"
+  
+  whoami2:
+    image: traefik/whoami
+    container_name: "simple-service-2"
+    labels:
+      - "traefik.enable=true"
+      # Definition of the router
+      - "traefik.http.routers.router2.rule=Path(`/bar`)"
+      - "traefik.http.routers.router2.entrypoints=web"
+      - "traefik.http.routers.router2.middlewares=crowdsec2@docker"
+      # Definition of the service
+      - "traefik.http.services.service2.loadbalancer.server.port=80"
+      # Definitin of the middleware
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.enabled=true"
+      # crowdseclapikey must be unique to the middleware attached to the service
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.crowdseclapikey=FIXME-LAPI-KEY-2"
+      # forwardedheaderstrustedips should be the IP of the proxy that is in front of traefik (if any)
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.forwardedheaderstrustedips=172.21.0.5"

  crowdsec:
    image: crowdsecurity/crowdsec:v1.4.1
    container_name: "crowdsec"
-    command: rm -rf /etc/crowdsec/acquis.yaml
    environment:
      COLLECTIONS: crowdsecurity/traefik
      CUSTOM_HOSTNAME: crowdsec
-      BOUNCER_KEY_TRAEFIK: FIXME-LAPI-KEY
-    depends_on:
-      - 'traefik'
+      # We need to register one api key per service we will use
+      BOUNCER_KEY_TRAEFIK_1: FIXME-LAPI-KEY-1
+      BOUNCER_KEY_TRAEFIK_2: FIXME-LAPI-KEY-2
    volumes:
      - ./acquis.yaml:/etc/crowdsec/acquis.yaml:ro
      - logs:/var/log/traefik:ro
      - crowdsec-db:/var/lib/crowdsec/data/
      - crowdsec-config:/etc/crowdsec/
+    labels:
+      - "traefik.enable=false"

 volumes:
  logs:
@@ -0,0 +1,4 @@
+filenames:
+ - /var/log/traefik/access.log
+labels:
+  type: traefik
@@ -0,0 +1,15 @@
+http:
+  # Add the router
+  routers:
+    router0:
+      entryPoints:
+      - web
+      service: service-foo
+      rule: Path(`/foo`)
+
+  # Add the service
+  services:
+    service-foo:
+      loadBalancer:
+        servers:
+        - url: http://traefik/foo:80
@@ -0,0 +1,86 @@
+version: "3.8"
+
+services:
+  cloudflare:
+    image: "traefik:v2.9.1"
+    container_name: "cloudflare"
+    command:
+      # - "--log.level=DEBUG"
+      - "--accesslog"
+      - "--accesslog.filepath=/var/log/traefik/access.log"
+      - "--api.insecure=true"
+      - "--entrypoints.web.address=:80"
+      - "--providers.file.filename=/cloud.yaml"
+      - "--experimental.localplugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - ./cloudflare-exemple.yaml:/cloud.yaml:ro
+      - logs-cloudflare:/var/log/traefik
+    ports:
+      - 80:80
+      - 8080:8080
+
+  traefik:
+    image: "traefik:v2.9.1"
+    container_name: "traefik"
+    command:
+      # - "--log.level=DEBUG"
+      - "--accesslog"
+      - "--accesslog.filepath=/var/log/traefik/access.log"
+      - "--api.insecure=true"
+      - "--providers.docker=true"
+      - "--providers.docker.exposedbydefault=false"
+      - "--entrypoints.web.address=:80"
+      - "--entrypoints.web.forwardedheaders.trustedips=172.21.0.5"
+
+      - "--experimental.plugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
+      - "--experimental.plugins.bouncer.version=v1.1.0"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - logs-dev:/var/log/traefik
+    ports:
+      - 90:80
+      - 9080:8080
+    depends_on:
+      - crowdsec
+
+  whoami1:
+    image: traefik/whoami
+    container_name: "simple-service1"
+    labels:
+      - "traefik.enable=true"
+      # Definition of the router
+      - "traefik.http.routers.router1.rule=Path(`/foo`)"
+      - "traefik.http.routers.router1.entrypoints=web"
+      - "traefik.http.routers.router1.middlewares=crowdsec1@docker" 
+      # Definition of the service
+      - "traefik.http.services.service1.loadbalancer.server.port=80"
+      # Definitin of the middleware
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.enabled=true"
+      # crowdseclapikey must be uniq to the middleware attached to the service
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.crowdseclapikey=40796d93c2958f9e58345514e67740e5"
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.crowdsecmode=live"
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.forwardedheaderstrustedips=172.21.0.5"
+  
+
+  crowdsec:
+    image: crowdsecurity/crowdsec:v1.4.1
+    container_name: "crowdsec"
+    environment:
+      COLLECTIONS: crowdsecurity/traefik
+      CUSTOM_HOSTNAME: crowdsec
+      BOUNCER_KEY_TRAEFIK_DEV_1: 40796d93c2958f9e58345514e67740e5
+      BOUNCER_KEY_TRAEFIK_DEV_2: 44c36dac5c4140af9f06f397508e82c7
+    volumes:
+      - ./acquis.yaml:/etc/crowdsec/acquis.yaml:ro
+      - logs-dev:/var/log/traefik:ro
+      - crowdsec-db-dev:/var/lib/crowdsec/data/
+      - crowdsec-config-dev:/etc/crowdsec/
+    labels:
+      - "traefik.enable=false"
+
+volumes:
+  logs-dev:
+  logs-cloudflare:
+  crowdsec-db-dev:
+  crowdsec-config-dev:
@@ -0,0 +1,4 @@
+filenames:
+ - /var/log/traefik/access.log
+labels:
+  type: traefik
@@ -0,0 +1,94 @@
+version: "3.8"
+
+services:
+  traefik:
+    image: "traefik:v2.9.4"
+    container_name: "traefik"
+    command:
+      # - "--log.level=DEBUG"
+      - "--accesslog"
+      - "--accesslog.filepath=/var/log/traefik/access.log"
+      - "--api.insecure=true"
+      - "--providers.docker=true"
+      - "--providers.docker.exposedbydefault=false"
+      - "--entrypoints.web.address=:80"
+
+      #- "--experimental.plugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
+      #- "--experimental.plugins.bouncer.version=v1.0.9"
+      - "--experimental.localplugins.bouncer.modulename=github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - logs-redis:/var/log/traefik
+      - ./../../:/plugins-local/src/github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
+    ports:
+      - 80:80
+      - 8080:8080
+    depends_on:
+      - crowdsec
+      - redis
+
+  whoami1:
+    image: traefik/whoami
+    container_name: "simple-service1"
+    labels:
+      - "traefik.enable=true"
+      # Definition of the router
+      - "traefik.http.routers.router1.rule=Path(`/foo`)"
+      - "traefik.http.routers.router1.entrypoints=web"
+      - "traefik.http.routers.router1.middlewares=crowdsec1@docker" 
+      # Definition of the service
+      - "traefik.http.services.service1.loadbalancer.server.port=80"
+      # Definition of the middleware
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.enabled=true"
+      # crowdseclapikey must be uniq to the middleware attached to the service
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.crowdseclapikey=40796d93c2958f9e58345514e67740e5"
+      - "traefik.http.middlewares.crowdsec1.plugin.bouncer.rediscacheenabled=true"
+
+  whoami2:
+    image: traefik/whoami
+    container_name: "simple-service2"
+    labels:
+      - "traefik.enable=true"
+      # Definition of the router
+      - "traefik.http.routers.router2.rule=Path(`/bar`)"
+      - "traefik.http.routers.router2.entrypoints=web"
+      - "traefik.http.routers.router2.middlewares=crowdsec1@docker" 
+      # Definition of the service
+      - "traefik.http.services.service2.loadbalancer.server.port=80"
+      # Definition of the middleware
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.enabled=true"
+      # crowdseclapikey must be uniq to the middleware attached to the service
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.crowdseclapikey=44c36dac5c4140af9f06f397508e82c7"
+      - "traefik.http.middlewares.crowdsec2.plugin.bouncer.rediscacheenabled=true"
+
+
+  crowdsec:
+    image: crowdsecurity/crowdsec:v1.4.1
+    container_name: "crowdsec"
+    environment:
+      COLLECTIONS: crowdsecurity/traefik
+      CUSTOM_HOSTNAME: crowdsec
+      BOUNCER_KEY_TRAEFIK_DEV_1: 40796d93c2958f9e58345514e67740e5
+      BOUNCER_KEY_TRAEFIK_DEV_2: 44c36dac5c4140af9f06f397508e82c7
+    volumes:
+      - ./acquis.yaml:/etc/crowdsec/acquis.yaml:ro
+      - logs-redis:/var/log/traefik:ro
+      - crowdsec-db-redis:/var/lib/crowdsec/data/
+      - crowdsec-config-redis:/etc/crowdsec/
+    labels:
+      - "traefik.enable=false"
+  
+  redis:
+    image: "redis:7.0.5-alpine"
+    container_name: "redis"
+    command: "redis-server --save 60 1"
+    volumes:
+      - redis-data:/data
+    ports:
+      - 6379:6379
+
+volumes:
+  logs-redis:
+  crowdsec-db-redis:
+  crowdsec-config-redis:
+  redis-data:
@@ -3,3 +3,5 @@ module github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
 go 1.17

 require github.com/leprosus/golang-ttl-map v1.1.7
+
+require github.com/tehnerd/goUtils v0.0.0-20150515130609-5a2d8fb2ded8 // indirect
@@ -1,2 +1,4 @@
 github.com/leprosus/golang-ttl-map v1.1.7 h1:cF4AAFDDnJTFSV+/42sKLhmMluvLdRlCGS2UaifH6UM=
 github.com/leprosus/golang-ttl-map v1.1.7/go.mod h1:4QWHJPeVBbrkhOhXdhCv9IEiyj/YzkO04/iexy4vSe0=
+github.com/tehnerd/goUtils v0.0.0-20150515130609-5a2d8fb2ded8 h1:/b777evAfRRdUJHasZLgQ/w8D/s1HtbaeDXsCVsV0B0=
+github.com/tehnerd/goUtils v0.0.0-20150515130609-5a2d8fb2ded8/go.mod h1:UuuqaOb+pZOxJZtjF1mBWTo8HYa7HQCbNkwUEaG9uU0=
@@ -0,0 +1,93 @@
+package cache
+
+import (
+	"fmt"
+
+	ttl_map "github.com/leprosus/golang-ttl-map"
+
+	logger "github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/pkg/logger"
+	simpleredis "github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin/pkg/redis"
+)
+
+const (
+	cacheBannedValue   = "t"
+	cacheNoBannedValue = "f"
+)
+
+var cache = ttl_map.New()
+var redis simpleredis.SimpleRedis
+
+var redisEnabled = false
+
+func getDecisionLocalCache(clientIP string) (bool, error) {
+	banned, isCached := cache.Get(clientIP)
+	bannedString, isValid := banned.(string)
+	if isCached && isValid && len(bannedString) > 0 {
+		return bannedString == cacheBannedValue, nil
+	}
+	return false, fmt.Errorf("no cache data")
+}
+
+func setDecisionLocalCache(clientIP string, value string, duration int64) {
+	cache.Set(clientIP, value, duration)
+}
+
+func deleteDecisionLocalCache(clientIP string) {
+	cache.Del(clientIP)
+}
+
+func getDecisionRedisCache(clientIP string) (bool, error) {
+	banned, err := redis.Get(clientIP)
+	bannedString := string(banned)
+	if err == nil && len(bannedString) > 0 {
+		return bannedString == cacheBannedValue, nil
+	}
+	return false, fmt.Errorf("no cache data")
+}
+
+func setDecisionRedisCache(clientIP string, value string, duration int64) {
+	redis.Set(clientIP, []byte(value), duration)
+}
+
+func deleteDecisionRedisCache(clientIP string) {
+	redis.Del(clientIP)
+}
+
+func DeleteDecision(clientIP string) {
+	if redisEnabled {
+		deleteDecisionRedisCache(clientIP)
+	} else {
+		deleteDecisionLocalCache(clientIP)
+	}
+}
+
+// GetDecision check in the cache if the IP has the banned / not banned value.
+// Otherwise return with an error to add the IP in cache if we are on.
+func GetDecision(clientIP string) (bool, error) {
+	if redisEnabled {
+		return getDecisionRedisCache(clientIP)
+	} else {
+		return getDecisionLocalCache(clientIP)
+	}
+}
+
+func SetDecision(clientIP string, isBanned bool, duration int64) {
+	var value string
+	if isBanned {
+		logger.Debug(fmt.Sprintf("%v banned", clientIP))
+		value = cacheBannedValue
+	} else {
+		value = cacheNoBannedValue
+	}
+	if redisEnabled {
+		setDecisionRedisCache(clientIP, value, duration)
+	} else {
+		setDecisionLocalCache(clientIP, value, duration)
+	}
+}
+
+func InitRedisClient(host string) {
+	redisEnabled = true
+	redis.Init(host)
+	logger.Debug("connect to redis")
+}
@@ -0,0 +1,127 @@
+package ip
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+)
+
+// CHECKER
+
+// Checker allows to check that addresses are in a trusted IPs.
+type Checker struct {
+	authorizedIPs    []*net.IP
+	authorizedIPsNet []*net.IPNet
+}
+
+// NewChecker builds a new Checker given a list of CIDR-Strings to trusted IPs.
+func NewChecker(trustedIPs []string) (*Checker, error) {
+	if len(trustedIPs) == 0 {
+		return nil, errors.New("no trusted IPs provided")
+	}
+
+	checker := &Checker{}
+
+	for _, ipMask := range trustedIPs {
+		if ipAddr := net.ParseIP(ipMask); ipAddr != nil {
+			checker.authorizedIPs = append(checker.authorizedIPs, &ipAddr)
+			continue
+		}
+
+		_, ipAddr, err := net.ParseCIDR(ipMask)
+		if err != nil {
+			return nil, fmt.Errorf("parsing CIDR trusted IPs %s: %w", ipAddr, err)
+		}
+		checker.authorizedIPsNet = append(checker.authorizedIPsNet, ipAddr)
+	}
+
+	return checker, nil
+}
+
+// Contains checks if provided address is in the trusted IPs.
+func (ip *Checker) Contains(addr string) (bool, error) {
+	if len(addr) == 0 {
+		return false, errors.New("empty IP address")
+	}
+
+	ipAddr, err := parseIP(addr)
+	if err != nil {
+		return false, fmt.Errorf("unable to parse address: %s: %w", addr, err)
+	}
+
+	return ip.ContainsIP(ipAddr), nil
+}
+
+// ContainsIP checks if provided address is in the trusted IPs.
+func (ip *Checker) ContainsIP(addr net.IP) bool {
+	for _, authorizedIP := range ip.authorizedIPs {
+		if authorizedIP.Equal(addr) {
+			return true
+		}
+	}
+
+	for _, authorizedNet := range ip.authorizedIPsNet {
+		if authorizedNet.Contains(addr) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func parseIP(addr string) (net.IP, error) {
+	userIP := net.ParseIP(addr)
+	if userIP == nil {
+		return nil, fmt.Errorf("can't parse IP from address %s", addr)
+	}
+
+	return userIP, nil
+}
+
+// STRATEGY
+
+// PoolStrategy is a strategy based on an IP Checker.
+// It allows to check whether addresses are in a given pool of IPs.
+type PoolStrategy struct {
+	Checker *Checker
+}
+
+// GetIP checks the list of Forwarded IPs (most recent first) against the
+// Checker pool of IPs. It returns the first IP that is not in the pool, or the
+// empty string otherwise.
+func (s *PoolStrategy) getIP(req *http.Request, customHeader string) string {
+	if s.Checker == nil {
+		return ""
+	}
+
+	xff := req.Header.Get(customHeader)
+
+	xffs := strings.Split(xff, ",")
+
+	for i := len(xffs) - 1; i >= 0; i-- {
+		xffTrimmed := strings.TrimSpace(xffs[i])
+		if len(xffTrimmed) == 0 {
+			continue
+		}
+		if contain, _ := s.Checker.Contains(xffTrimmed); !contain {
+			return xffTrimmed
+		}
+	}
+
+	return ""
+}
+
+// GetRemoteIP It returns the first IP that is not in the pool, or the empty string otherwise.
+func GetRemoteIP(req *http.Request, strategy *PoolStrategy, customHeader string) (string, error) {
+	remoteIP := strategy.getIP(req, customHeader)
+	if len(remoteIP) != 0 {
+		return remoteIP, nil
+	}
+	remoteIP, _, err := net.SplitHostPort(req.RemoteAddr)
+	if err != nil {
+		return "", fmt.Errorf("failed to extract ip from remote address: %w", err)
+	}
+	return remoteIP, nil
+}
@@ -0,0 +1,35 @@
+package logger
+
+import (
+	"io"
+	"log"
+	"os"
+)
+
+var (
+	loggerInfo  = log.New(io.Discard, "INFO: CrowdsecBouncerTraefikPlugin: ", log.Ldate|log.Ltime)
+	loggerDebug = log.New(io.Discard, "DEBUG: CrowdsecBouncerTraefikPlugin: ", log.Ldate|log.Ltime)
+)
+
+// Init Set Default log level to info in case log level to defined
+func Init(logLevel string) {
+	switch logLevel {
+		case "INFO":
+			loggerInfo.SetOutput(os.Stdout)
+		case "DEBUG":
+			loggerInfo.SetOutput(os.Stdout)
+			loggerDebug.SetOutput(os.Stdout)
+		default:
+			loggerInfo.SetOutput(os.Stdout)
+	}
+}
+
+// Info Log info
+func Info(str string) {
+	loggerInfo.Printf(str)
+}
+
+// Info Log debug
+func Debug(str string) {
+	loggerDebug.Printf(str)
+}
@@ -0,0 +1,212 @@
+package simpleredis
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/tehnerd/goUtils/netutils"
+)
+
+type RedisCmd struct {
+	Command  string
+	Name     string
+	Data     []byte
+	Duration int64
+	Error    error
+}
+
+type SimpleRedis struct {
+	redisChanRead  chan RedisCmd
+	redisChanWrite chan RedisCmd
+	redisHost      string
+	redisCmd       RedisCmd
+}
+
+func genRedisArray(params ...[]byte) []byte {
+	MSG := ""
+	for cntr := 0; cntr < len(params); cntr++ {
+		MSG = strings.Join([]string{MSG, string(params[cntr])}, " ")
+	}
+	MSG = strings.Trim(MSG, " ")
+	MSG = strings.Join([]string{MSG, "\r\n"}, "")
+	return []byte(MSG)
+}
+
+func parseResponse(response []byte, dataBuf []byte, Len *int) ([]byte, []byte, error) {
+	dataBuf = append(dataBuf, response...)
+	lenCRLF := 2
+	if *Len != 0 {
+		if len(dataBuf) < *Len {
+			return nil, dataBuf, nil
+		} else {
+			return dataBuf[:*Len], dataBuf[*Len:], nil
+		}
+	}
+	for {
+		switch string(dataBuf[0]) {
+		case "+", "-", ":":
+			//simple strings, error,int. usually ther are in format (+|-|:)DATA\r\n"
+			if len(dataBuf) < 3 {
+				return nil, dataBuf, nil
+			}
+			cntr := 1
+			for ; cntr < len(dataBuf); cntr++ {
+				if dataBuf[cntr] == '\r' {
+					break
+				}
+			}
+			if cntr == len(dataBuf) {
+				return nil, dataBuf, nil
+			}
+			response = dataBuf[1:cntr]
+			return response, dataBuf[cntr+2:], nil
+		case "$":
+			//bulk string. format $LEN\r\nDATA\r\n. up to 512MB
+			cntr := 1
+			for ; cntr < len(dataBuf); cntr++ {
+				if string(dataBuf[cntr]) == "\r" {
+					break
+				}
+			}
+			if cntr == len(dataBuf) || cntr+lenCRLF > len(dataBuf) {
+				return nil, dataBuf, nil
+			}
+			dataLen, err := strconv.Atoi(string(dataBuf[1:cntr]))
+			if err != nil {
+				return nil, dataBuf[cntr:], nil
+			}
+
+			if dataLen == -1 {
+				return nil, dataBuf[cntr:], fmt.Errorf("NOT FOUND")
+			}
+			if cntr+lenCRLF > len(dataBuf)-lenCRLF {
+				*Len = dataLen
+				return nil, dataBuf[cntr+lenCRLF:], nil
+			}
+			if len(dataBuf[cntr+lenCRLF:len(dataBuf)-lenCRLF]) < dataLen {
+				*Len = dataLen
+				return nil, dataBuf[cntr+lenCRLF:], nil
+			} else {
+				return dataBuf[cntr+lenCRLF : cntr+dataLen+lenCRLF], dataBuf[cntr+dataLen+lenCRLF:], nil
+			}
+		case "*":
+			panic("array")
+		default:
+			if len(dataBuf) > 1 {
+				dataBuf = dataBuf[1:]
+			} else {
+				return nil, dataBuf, nil
+			}
+		}
+	}
+}
+
+func initContext(hostnamePort string, redisCmdWrite, redisCmdRead chan RedisCmd) {
+	tcpRemoteAddress, err := net.ResolveTCPAddr("tcp", hostnamePort)
+	if err != nil {
+		panic("cant resolve remote redis address")
+	}
+	var ladr *net.TCPAddr
+	msgBuf := make([]byte, 65000)
+	initMsg := []byte("*1\r\n$4\r\nPING\r\n")
+	writeChan := make(chan []byte)
+	readChan := make(chan []byte)
+	flushChan := make(chan int)
+	go netutils.AutoRecoonectedTCP(ladr, tcpRemoteAddress, msgBuf, initMsg, writeChan, readChan, flushChan)
+	<-readChan
+	dataBuf := make([]byte, 0)
+	dataLen := 0
+	for {
+		select {
+		case cmd := <-redisCmdWrite:
+			switch cmd.Command {
+			case "SET":
+				data := genRedisArray([]byte("SET"), []byte(cmd.Name), cmd.Data, []byte("EX"), []byte(fmt.Sprintf("%v", cmd.Duration)))
+				writeChan <- data
+			case "GET":
+				data := genRedisArray([]byte("GET"), []byte(cmd.Name))
+				writeChan <- data
+			case "DEL":
+				data := genRedisArray([]byte("DEL"), []byte(cmd.Name))
+				writeChan <- data
+			}
+		case response := <-readChan:
+			data, dataBuf, err := parseResponse(response, dataBuf, &dataLen)
+			if dataLen != 0 {
+				for data == nil {
+					response = <-readChan
+					data, dataBuf, err = parseResponse(response, dataBuf, &dataLen)
+				}
+			}
+			if err != nil {
+				select {
+				case redisCmdRead <- RedisCmd{
+					Error: err,
+				}:
+				case <-time.After(time.Second * 5):
+				}
+			}
+			if data != nil && string(data) != "PONG" {
+				select {
+				case redisCmdRead <- RedisCmd{
+					Data: data,
+				}:
+				case <-time.After(time.Second * 5):
+				}
+				dataLen = 0
+			}
+		case <-flushChan:
+			dataBuf = dataBuf[:]
+			dataLen = 0
+			select {
+			case redisCmdRead <- RedisCmd{}:
+			case <-time.After(time.Second * 5):
+			}
+		}
+	}
+}
+
+func (sr *SimpleRedis) Init(redisHost string) {
+	sr.redisHost = redisHost
+	sr.redisChanWrite = make(chan RedisCmd)
+	sr.redisChanRead = make(chan RedisCmd)
+	go initContext(sr.redisHost, sr.redisChanWrite, sr.redisChanRead)
+}
+
+func (sr *SimpleRedis) Get(name string) ([]byte, error) {
+	sr.redisCmd.Command = "GET"
+	sr.redisCmd.Name = name
+	sr.redisChanWrite <- sr.redisCmd
+	resp := <-sr.redisChanRead
+	if resp.Error != nil {
+		return nil, resp.Error
+	}
+	return resp.Data, nil
+}
+
+func (sr *SimpleRedis) Set(name string, data []byte, duration int64) error {
+	sr.redisCmd.Command = "SET"
+	sr.redisCmd.Name = name
+	sr.redisCmd.Data = data
+	sr.redisCmd.Duration = duration
+	sr.redisChanWrite <- sr.redisCmd
+	resp := <-sr.redisChanRead
+	if resp.Error != nil {
+		return resp.Error
+	}
+	return nil
+}
+
+func (sr *SimpleRedis) Del(name string) error {
+	sr.redisCmd.Command = "DEL"
+	sr.redisCmd.Name = name
+	sr.redisChanWrite <- sr.redisCmd
+	resp := <-sr.redisChanRead
+	if resp.Error != nil {
+		return resp.Error
+	}
+	return nil
+}
@@ -0,0 +1,525 @@
+package netutils
+
+import (
+	"math/rand"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	//"sync/atomic"
+	"time"
+)
+
+//Receive msg from tcp socket and send it as a []byte to readChan
+func ReadFromTCP2(sock *net.TCPConn, msgBuf []byte, readChan chan []byte,
+	feedbackChanFromSocket chan int) {
+	loop := 1
+	for loop == 1 {
+		bytes, err := sock.Read(msgBuf)
+		if err != nil {
+			feedbackChanFromSocket <- 1
+			loop = 0
+			continue
+		}
+		b := make([]byte, 0)
+		b = append(b, msgBuf[:bytes]...)
+		readChan <- b
+	}
+}
+
+//Receive msg from tcp socket and send it as a []byte to readChan
+func ReadFromTCP(sock *net.TCPConn, msgBuf []byte, readChan chan []byte,
+	feedbackChanFromSocket chan int) {
+	feedbackToSocket := make(chan bool)
+	feedbackFromSocket := make(chan bool)
+	reuseBufferChan := make(chan []byte, 1)
+	go readFromTCP(sock, readChan, feedbackFromSocket,
+		feedbackToSocket, reuseBufferChan)
+	go func() {
+		<-feedbackFromSocket
+		feedbackChanFromSocket <- 1
+	}()
+}
+
+/*simple write to TCP, for oneway connections only (no communitcation w/ "read" part of the socket
+in terms of error propogation)*/
+func WriteToTCPw2(sock *net.TCPConn, writeChan chan []byte,
+	feedbackChan chan int) {
+	loop := 1
+	for loop == 1 {
+		select {
+		case msg := <-writeChan:
+			_, err := sock.Write(msg)
+			if err != nil {
+				feedbackChan <- 1
+				continue
+			}
+		case <-feedbackChan:
+			loop = 0
+		}
+	}
+}
+
+/*simple write to TCP, for oneway connections only (no communitcation w/ "read" part of the socket
+in terms of error propogation)*/
+func WriteToTCPw(sock *net.TCPConn, writeChan chan []byte,
+	feedbackChan chan int) {
+	feedbackToSocket := make(chan bool)
+	feedbackFromSocket := make(chan bool)
+	go writeToTCP(sock, writeChan, feedbackFromSocket, feedbackToSocket)
+	go func() {
+		<-feedbackFromSocket
+		feedbackChan <- 1
+	}()
+}
+
+//simple write to tcp w/ erorr propagation to/from "read" part of the socket
+func WriteToTCPrw2(sock *net.TCPConn, writeChan chan []byte,
+	feedbackChanFromSocket, feedbackChanToSocket chan int) {
+	loop := 1
+	for loop == 1 {
+		select {
+		case msg := <-writeChan:
+			_, err := sock.Write(msg)
+			if err != nil {
+				select {
+				case feedbackChanFromSocket <- 1:
+					continue
+				case loop = <-feedbackChanToSocket:
+					loop = 0
+					continue
+				}
+			}
+		case <-feedbackChanToSocket:
+			loop = 0
+		}
+	}
+}
+
+//simple write to tcp w/ erorr propagation to/from "read" part of the socket
+func WriteToTCPrw(sock *net.TCPConn, writeChan chan []byte,
+	feedbackChanFromSocket, feedbackChanToSocket chan int) {
+	feedbackToSocket := make(chan bool)
+	feedbackFromSocket := make(chan bool)
+	go writeToTCP(sock, writeChan, feedbackFromSocket, feedbackToSocket)
+	go func() {
+		select {
+		case <-feedbackFromSocket:
+			feedbackChanFromSocket <- 1
+		case <-feedbackChanToSocket:
+			feedbackToSocket <- true
+
+		}
+	}()
+
+}
+
+func makeBuffer(reuseBufferChan chan []byte) []byte {
+	select {
+	case buf := <-reuseBufferChan:
+		return buf
+	default:
+		return make([]byte, 10000)
+	}
+}
+
+//Receive msg from tcp socket and send it as a []byte to readChan,with buffer reuse
+func readFromTCP(sock *net.TCPConn, readChan chan []byte,
+	feedbackFromSocket, feedbackToSocket chan bool,
+	reuseBufferChan chan []byte) {
+	loop := 1
+	var buf []byte
+	for loop == 1 {
+		buf = makeBuffer(reuseBufferChan)
+		bytes, err := sock.Read(buf)
+		if err != nil {
+			select {
+			case feedbackFromSocket <- true:
+				loop = 0
+				continue
+			case <-feedbackToSocket:
+				loop = 0
+				continue
+			}
+		}
+		select {
+		case readChan <- buf[:bytes]:
+		case <-feedbackToSocket:
+			loop = 0
+			continue
+
+		}
+	}
+}
+
+//TCP's write routine, with feedback's chans
+func writeToTCP(sock *net.TCPConn, writeChan chan []byte,
+	feedbackFromSocket, feedbackToSocket chan bool) {
+	loop := 1
+	for loop == 1 {
+		select {
+		case msg := <-writeChan:
+			_, err := sock.Write(msg)
+			if err != nil {
+				select {
+				case feedbackFromSocket <- true:
+				case <-feedbackToSocket:
+				}
+				loop = 0
+				continue
+			}
+		case <-feedbackToSocket:
+			loop = 0
+			continue
+		}
+	}
+}
+
+//reconnecting to remote host for both read and write purpose
+func ReconnectTCPRW(ladr, radr *net.TCPAddr, msgBuf []byte, writeChan chan []byte,
+	readChan chan []byte, feedbackChanToSocket, feedbackChanFromSocket chan int,
+	init_msg []byte) {
+	loop := 1
+	for loop == 1 {
+		sock, err := net.DialTCP("tcp", ladr, radr)
+		if err != nil {
+			time.Sleep(time.Duration(20+rand.Intn(15)) * time.Second)
+			continue
+		}
+		//testing health of the new socket. GO sometimes doesnt rise the error when
+		// we receive RST from remote side
+		_, err = sock.Write(init_msg)
+		if err != nil {
+			sock.Close()
+			time.Sleep(time.Duration(20+rand.Intn(15)) * time.Second)
+			continue
+		}
+		loop = 0
+		go ReadFromTCP(sock, msgBuf, readChan, feedbackChanFromSocket)
+		go WriteToTCPrw(sock, writeChan, feedbackChanFromSocket, feedbackChanToSocket)
+	}
+}
+
+func ReconnectTCPRWReuse(ladr, radr *net.TCPAddr,
+	readChan, writeChan, reuseBufferChan chan []byte,
+	readFeedbackFrom, readFeedbackTo chan bool,
+	writeFeedbackFrom, writeFeedbackTo chan bool) {
+	loop := 1
+	for loop == 1 {
+		sock, err := net.DialTCP("tcp", ladr, radr)
+		if err != nil {
+			time.Sleep(time.Duration(20+rand.Intn(15)) * time.Second)
+			continue
+		}
+		loop = 0
+		go readFromTCP(sock, readChan, readFeedbackFrom, readFeedbackTo,
+			reuseBufferChan)
+		go writeToTCP(sock, writeChan, writeFeedbackFrom, writeFeedbackTo)
+	}
+}
+
+func AutoRecoonectedTCP(ladr, radr *net.TCPAddr, msgBuf, initMsg []byte,
+	writeChan, readChan chan []byte, flushChan chan int) {
+	feedbackChanFromSocket := make(chan int)
+	feedbackChanToSocket := make(chan int)
+	go ReconnectTCPRW(ladr, radr, msgBuf, writeChan, readChan, feedbackChanToSocket,
+		feedbackChanFromSocket, initMsg)
+	for {
+		select {
+		case feedbackFromSocket := <-feedbackChanFromSocket:
+			feedbackChanToSocket <- feedbackFromSocket
+			flushChan <- 1
+			go ReconnectTCPRW(ladr, radr, msgBuf, writeChan,
+				readChan, feedbackChanToSocket,
+				feedbackChanFromSocket, initMsg)
+
+		}
+	}
+
+}
+
+func AutoRecoonectedTCPReuse(ladr, radr *net.TCPAddr,
+	readChan, writeChan chan []byte,
+	reuseChan chan []byte,
+	flushChan chan bool) {
+	readFeedbackFrom := make(chan bool)
+	readFeedbackTo := make(chan bool)
+	writeFeedbackFrom := make(chan bool)
+	writeFeedbackTo := make(chan bool)
+	go ReconnectTCPRWReuse(ladr, radr, readChan, writeChan, reuseChan,
+		readFeedbackFrom, readFeedbackTo,
+		writeFeedbackFrom, writeFeedbackTo)
+	for {
+		select {
+		case <-readFeedbackFrom:
+			writeFeedbackTo <- true
+		case <-writeFeedbackFrom:
+			readFeedbackTo <- true
+		}
+		flushChan <- true
+		go ReconnectTCPRWReuse(ladr, radr, readChan, writeChan, reuseChan,
+			readFeedbackFrom, readFeedbackTo,
+			writeFeedbackFrom, writeFeedbackTo)
+	}
+
+}
+
+//reconnecting to remote host for write only
+func ReconnectTCPW(radr net.TCPAddr, writeChan chan []byte, feedbackChan chan int) {
+	loop := 1
+	for loop == 1 {
+		time.Sleep(time.Duration(20+rand.Intn(15)) * time.Second)
+		sock, err := net.DialTCP("tcp", nil, &radr)
+		if err != nil {
+			continue
+		}
+		//testing health of the new socket. GO sometimes doesnt rise the error when
+		// we receive RST from remote side
+		_, err = sock.Write([]byte{1})
+		if err != nil {
+			sock.Close()
+			continue
+		}
+		loop = 0
+		go WriteToTCPw(sock, writeChan, feedbackChan)
+	}
+}
+
+/* --------------------- CONNECTION MANAGER -------------------------
+Connection manager will allow send data and receive data from remote hosts.
+it will have single ConnectionMsg (see below) read chan and single
+ConnectionMsg write chan toward it's clients
+as well as single read chan from sockets, but multiple write sockets.
+it will route msgs according to Host field in connectionManager struct
+(if it received from client, it will send this msg toward Host's sockets;
+if recved from socket, will proxy it toward client(and client will know from which remote host
+it was received)
+-------------------------------------------------------------------- */
+/*
+MsgType's could be:
+from Api's client to ConnectionManager:
+"Data" - msg with Data to Host
+"Connect" - connect to new Host
+...
+from ConnectionManager to Api's client:
+"BufferFlush" - notification that connection to remote Host not longer working.
+advice to flush all the msg buffers assosiated with remote host
+*/
+type ConnectionMsg struct {
+	Host string
+	Data []byte
+	Type string
+}
+
+/*
+Receive msg from tcp socket and send it as a ConnectionMsg to readChan
+TODO: think about more generic version to be more DRYer (to work in both CM and []byte chans
+*/
+func CMReadFromTCP(sock *net.TCPConn, readChan chan ConnectionMsg,
+	peerAddress string) {
+	msgBuf := make([]byte, 65000)
+	loop := 1
+	var msg ConnectionMsg
+	msg.Host = peerAddress
+	msg.Type = "Data"
+	for loop == 1 {
+		bytes, err := sock.Read(msgBuf)
+		if err != nil {
+			msg.Type = "ReadError"
+			readChan <- msg
+			loop = 0
+			continue
+		}
+		b := make([]byte, 0)
+		b = append(b, msgBuf[:bytes]...)
+		msg.Data = b
+		readChan <- msg
+	}
+}
+
+/*
+ConnectionManager write instance to tcp w/ erorr propagation to/from "read" part of the socket
+TODO: think about more generic version to be more DRYer (to work in both CM and []byte chans
+*/
+func CMWriteToTCP(sock *net.TCPConn, writeChan, readChan chan ConnectionMsg,
+	peerAddress string) {
+	loop := 1
+	var errorMsg ConnectionMsg
+	errorMsg.Host = peerAddress
+	errorMsg.Type = "WriteError"
+	for loop == 1 {
+		select {
+		case msg := <-writeChan:
+			switch msg.Type {
+			case "Data":
+				_, err := sock.Write(msg.Data)
+				if err != nil {
+					for loop == 1 {
+						select {
+						case readChan <- errorMsg:
+						case errorMsg := <-writeChan:
+							if errorMsg.Type != "ConnectionError" {
+								continue
+							}
+						}
+						loop = 0
+					}
+				}
+			case "ConnectionError":
+				loop = 0
+			default:
+				continue
+			}
+		}
+	}
+}
+
+func StartConnection(tcpConn *net.TCPConn, writeChan,
+	readChan chan ConnectionMsg, peerAddress string) {
+	go CMReadFromTCP(tcpConn, readChan, peerAddress)
+	go CMWriteToTCP(tcpConn, writeChan, readChan, peerAddress)
+}
+
+func CMListenForConnection(mutex *sync.RWMutex, localPort int,
+	writeChanMap map[string]chan ConnectionMsg,
+	connectionStateMap map[string]int,
+	readChan chan ConnectionMsg) {
+	laddr := strings.Join([]string{":", strconv.Itoa(localPort)}, "")
+	tcpLaddr, err := net.ResolveTCPAddr("tcp", laddr)
+	if err != nil {
+		panic("cant resolve local address for binding")
+	}
+	tcpListener, err := net.ListenTCP("tcp", tcpLaddr)
+	if err != nil {
+		panic("cant listen on local address for binding")
+	}
+	for {
+		tcpConn, err := tcpListener.AcceptTCP()
+		if err == nil {
+			radr := strings.Split(tcpConn.RemoteAddr().String(), ":")[0]
+			// check if we already has connection to remote peer as a client
+			mutex.Lock()
+			if val, exist := connectionStateMap[radr]; exist && val == 1 {
+				tcpConn.Close()
+				mutex.Unlock()
+				continue
+			}
+			connectionStateMap[radr] = 1
+			if writeChan, exist := writeChanMap[radr]; exist {
+				mutex.Unlock()
+				go StartConnection(tcpConn, writeChan, readChan, radr)
+			} else {
+				writeChanMap[radr] = make(chan ConnectionMsg)
+				mutex.Unlock()
+				go StartConnection(tcpConn, writeChanMap[radr], readChan, radr)
+			}
+		}
+	}
+}
+
+func CMConnectToRemotePeer(mutex *sync.RWMutex, peerTcpAddr *net.TCPAddr,
+	radr string,
+	writeChan chan ConnectionMsg,
+	readChan chan ConnectionMsg,
+	connectionStateMap map[string]int) {
+	connectLoop := 1
+	for connectLoop == 1 {
+		mutex.RLock()
+		if connectionStateMap[radr] == 1 {
+			connectLoop = 0
+			mutex.RUnlock()
+			continue
+		}
+		mutex.RUnlock()
+		tcpConn, err := net.DialTCP("tcp", nil, peerTcpAddr)
+		if err != nil {
+			time.Sleep(time.Second * time.Duration(rand.Int63n(15)))
+			continue
+		}
+		mutex.Lock()
+		if connectionStateMap[radr] == 0 {
+			connectionStateMap[radr] = 1
+			go StartConnection(tcpConn, writeChan, readChan, radr)
+			mutex.Unlock()
+			connectLoop = 0
+			continue
+		} else {
+			mutex.Unlock()
+			tcpConn.Close()
+			connectLoop = 0
+			continue
+		}
+	}
+}
+
+func ConnectionManager(msgChan chan ConnectionMsg, localPort int) {
+	writeChanMap := make(map[string]chan ConnectionMsg)
+	connectionStateMap := make(map[string]int)
+	readChan := make(chan ConnectionMsg)
+	var connectionMutex sync.RWMutex
+	go CMListenForConnection(&connectionMutex, localPort, writeChanMap,
+		connectionStateMap, readChan)
+	for {
+		select {
+		case msgToPeer := <-msgChan:
+			switch msgToPeer.Type {
+			case "Data":
+				if state, exists := connectionStateMap[msgToPeer.Host]; exists && state == 1 {
+					/*FIXME/THINK: There could be deadlock if connectin closes before we will
+					be able to send to the chan */
+					writeChan := writeChanMap[msgToPeer.Host]
+					writeChan <- msgToPeer
+				} else {
+					msgChan <- ConnectionMsg{Type: "ConnectionNotExist"}
+				}
+			case "Connect":
+				if len(strings.Split(msgToPeer.Host, ":")) > 1 {
+					radr := strings.Split(msgToPeer.Host, ":")[0]
+					connectionMutex.Lock()
+					if _, exist := writeChanMap[radr]; !exist {
+						writeChanMap[radr] = make(chan ConnectionMsg)
+					}
+					connectionMutex.Unlock()
+					peerTcpAddr, err := net.ResolveTCPAddr("tcp", msgToPeer.Host)
+					if err != nil {
+						//XXX: think about , mb make something less drastic
+						panic("cant resolve remote address")
+					}
+					go CMConnectToRemotePeer(&connectionMutex, peerTcpAddr, radr,
+						writeChanMap[radr], readChan, connectionStateMap)
+				} else {
+					connectionMutex.Lock()
+					if _, exist := writeChanMap[msgToPeer.Host]; !exist {
+						writeChanMap[msgToPeer.Host] = make(chan ConnectionMsg)
+					}
+					connectionMutex.Unlock()
+					remoteAddr := strings.Join([]string{msgToPeer.Host, strconv.Itoa(localPort)}, ":")
+					peerTcpAddr, err := net.ResolveTCPAddr("tcp", remoteAddr)
+					if err != nil {
+						//XXX: again panic could be overkill
+						panic("cant resolve remote address")
+					}
+					go CMConnectToRemotePeer(&connectionMutex, peerTcpAddr, msgToPeer.Host,
+						writeChanMap[msgToPeer.Host], readChan, connectionStateMap)
+				}
+			}
+		case msgFromPeer := <-readChan:
+			switch msgFromPeer.Type {
+			case "Data":
+				msgChan <- msgFromPeer
+			case "WriteError", "ReadError":
+				connectionMutex.Lock()
+				connectionStateMap[msgFromPeer.Host] = 0
+				connectionMutex.Unlock()
+				if msgFromPeer.Type == "ReadError" {
+					writeChanMap[msgFromPeer.Host] <- ConnectionMsg{Type: "ConnectionError"}
+				}
+				var msgToApiClient ConnectionMsg
+				msgToApiClient.Host = msgFromPeer.Host
+				msgToApiClient.Type = "BufferFlush"
+				msgChan <- msgToApiClient
+
+			}
+		}
+	}
+}
@@ -0,0 +1,42 @@
+package netutils
+
+import (
+	"errors"
+	"net"
+)
+
+/*
+	we need to provide a function, which will read/write to/from socket and read/write to/from sockets feedback chans
+*/
+func ListenForConnection(port string, fn func(chan []byte, chan []byte, chan int, chan int)) error {
+	addr := ":" + port
+	tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
+	if err != nil {
+		return errors.New("cant resolve local tcp address")
+	}
+	loop := 1
+	servSock, err := net.ListenTCP("tcp", tcpAddr)
+	if err != nil {
+		return errors.New("cant bind to local tcp address")
+	}
+
+	for loop == 1 {
+		sock, err := servSock.AcceptTCP()
+		if err != nil {
+			continue
+		}
+		go ServeTcpConn(sock, fn)
+	}
+	return nil
+}
+
+func ServeTcpConn(sock *net.TCPConn, fn func(chan []byte, chan []byte, chan int, chan int)) {
+	readChan := make(chan []byte)
+	writeChan := make(chan []byte)
+	feedbackFrom := make(chan int, 1)
+	feedbackTo := make(chan int, 1)
+	buf := make([]byte, 65535)
+	go ReadFromTCP(sock, buf, readChan, feedbackFrom)
+	go WriteToTCPrw(sock, writeChan, feedbackFrom, feedbackTo)
+	fn(readChan, writeChan, feedbackFrom, feedbackTo)
+}
@@ -1,3 +1,6 @@
 # github.com/leprosus/golang-ttl-map v1.1.7
 ## explicit; go 1.15
 github.com/leprosus/golang-ttl-map
+# github.com/tehnerd/goUtils v0.0.0-20150515130609-5a2d8fb2ded8
+## explicit
+github.com/tehnerd/goUtils/netutils
Author	SHA1	Message	Date
maxlerebourg	4a5f1eca6a	Merge pull request #24 from maxlerebourg/20-implement-shared-cache-with-an-external-redis-as-an-option Create Environnement to work on redis cache	2022-11-06 13:02:58 +01:00
maxlerebourg	cdda369fb8	Merge branch 'main' into 20-implement-shared-cache-with-an-external-redis-as-an-option	2022-11-06 13:02:40 +01:00
Max Lerebourg	f0f28fecef	🍱 fix readme	2022-11-06 13:01:25 +01:00
Max Lerebourg	23620207f7	🍱 fix before version	2022-11-06 12:57:32 +01:00
maxlerebourg	4a674da9f9	Merge pull request #29 from maxlerebourg/max-impl-redis Max impl redis	2022-11-06 12:50:19 +01:00
MathieuHa	0dfd18f18e	Update documentation for cache	2022-11-05 21:55:29 +01:00
MathieuHa	d8ee0a34eb	Update documentation, exemples and code for redis support	2022-11-05 21:45:43 +01:00
maxlerebourg	b50074dca4	Merge pull request #26 from maxlerebourg/max-impl-redis Max impl redis	2022-11-05 20:01:51 +01:00
maxlerebourg	5044004ec2	Update cache.go	2022-10-26 10:26:19 +02:00
Max Lerebourg	41a46c0584	✨ add delete	2022-10-24 21:56:38 +02:00
Max Lerebourg	0a186cf9a9	✨ add redis ttl	2022-10-24 21:38:56 +02:00
Max Lerebourg	ffcf4356fc	✨ redis included	2022-10-20 02:42:24 +02:00
Max Lerebourg	f94e48aa03	not working...	2022-10-19 08:22:00 +02:00
Max Lerebourg	a197194591	not working...	2022-10-19 08:21:01 +02:00
Max Lerebourg	44e329cd57	🍱 fix	2022-10-17 22:14:49 +02:00
maxlerebourg	81ffeabcec	Merge pull request #25 from maxlerebourg/prepare-for-release-1.1.0 Update exemple traefik to version 2.9.1 and version of plugin 1.1.0 in exemples	2022-10-17 21:03:28 +02:00
MathieuHa	e14d179612	Update exemple traefik to version 2.9.1 and version of plugin 1.1.0	2022-10-17 21:01:32 +02:00
MathieuHa	4058836678	Test library github.com/gomodule/redigo/redis	2022-10-17 20:58:27 +02:00
MathieuHa	87ed9e9c4e	add bad library	2022-10-16 23:10:39 +02:00
MathieuHa	395c80dccf	First version not working, unsafe library	2022-10-16 23:08:21 +02:00
MathieuHa	59268ee33d	Merge remote-tracking branch 'origin' into 20-implement-shared-cache-with-an-external-redis-as-an-option	2022-10-16 22:07:01 +02:00
MathieuHa	781a83465e	Create Environnement to work on redis cache	2022-10-16 20:47:29 +02:00
maxlerebourgandMathieuHa	8696501f61	✨ add one instance of cache for all the service (#19 ) * ✨ add one instance of cache for all the service * 🐛 fix the healthy issue * 🐛 fix lint * 🍱 upgrade codebase * 🍱 fix lint * 🐛 when there is master node shut down * Set live mode as default, clean docker and recipes * Restore live mode in readme as default * 🍱 add channel management * 🍱 order funcs * 🍱 revert service in docker compose * ✨ logLevel added + cache put out the bouncer * 🍱 fix * 🍱 fix * 🍱 fix Co-authored-by: MathieuHa <mathieu@hanotaux.fr>	2022-10-16 20:14:41 +02:00
maxlerebourg	f22fc2cd09	Merge pull request #22 from maxlerebourg/21-allow-the-real-ip-the-be-fetched-from-a-custom-header ✨ Add Custom header usage to find the user IP	2022-10-15 21:03:46 +02:00
MathieuHa	8eec1c5656	✨ Add Custom header usage to find the user IP	2022-10-15 18:49:41 +02:00
mathieuHa MathieuHa Max Lerebourg	552b30a9ef	16 read ip address from x forwarded for or x real ip instead of remoteaddr if it exists (#17 ) * Handle X forwarded for in the plugin * Update docker-compose.cloudflare.yml Change to version v1.0.9 * 🍱 fix + isolate cache * 🍱 missing files * 🍱 lint Co-authored-by: MathieuHa <mathieu@hanotaux.fr> Co-authored-by: Max Lerebourg <maxlerebourg@gmail.com>	2022-10-15 14:00:32 +02:00
mathieuHa	6dde683a0a	Add Missing line break for docker-compose	2022-10-15 09:59:14 +02:00
mathieuHa	be0306eb49	Update README.md Change number of modes	2022-10-15 09:57:22 +02:00
maxlerebourg	b69bd77409	Merge pull request #15 from maxlerebourg/remove_alone 🍱 remove alone mode	2022-10-15 09:54:15 +02:00
Max Lerebourg	64a117d7b0	🍱 change default mode to live	2022-10-11 19:56:14 +02:00
Max Lerebourg	d0ba71c0c8	🍱 clean code	2022-10-11 19:34:08 +02:00
Max Lerebourg	2e780b304d	🍱 remove alone mode	2022-10-11 19:28:57 +02:00
Max Lerebourg	4d7615dd19	🍱 fix waiter	2022-10-03 01:23:19 +02:00
MathieuHa	952fcd844f	Clean docker-compose, update function name	2022-10-03 01:01:41 +02:00
MathieuHa	9cf4827768	Add Wait Stream feature	2022-10-03 00:37:41 +02:00
MathieuHa	6d8e811a03	Add metrics recipe to makefile	2022-10-03 00:21:34 +02:00
MathieuHa	18e4d42e8e	Update readme, add makefile operations	2022-10-03 00:10:31 +02:00
MathieuHa	54183fbc97	Update Readme and docker-compose files with docs	2022-10-03 00:04:27 +02:00
Max Lerebourg	c99a0ddc46	✨ fix logger	2022-10-01 20:02:49 +02:00
Max Lerebourg	f876458bb2	✨ fix logger	2022-10-01 20:00:42 +02:00
Max Lerebourg	6c6a80efb4	✨ fix	2022-10-01 19:44:06 +02:00
MathieuHa	cc0261aa86	Add clean message when stream polling start	2022-10-01 19:42:22 +02:00
MathieuHa	465851b536	Fix name of docker volumes	2022-10-01 19:36:18 +02:00
maxlerebourg	9e92aeb449	Merge pull request #13 from maxlerebourg/fixMax ✨ fix loop	2022-10-01 19:33:09 +02:00
MathieuHa	37c7648854	Clean docker-compose and aquis.yaml	2022-10-01 19:28:09 +02:00
Max Lerebourg	dd704d4274	✨ fix	2022-10-01 19:23:20 +02:00
Max Lerebourg	1e4508f091	✨ fix log	2022-10-01 19:18:12 +02:00
Max Lerebourg	89e8b5631e	✨ fix loop	2022-10-01 19:12:48 +02:00
Max Lerebourg	68adb31065	✨ fix loop	2022-10-01 19:09:22 +02:00
mathieuHa	1ebde35693	Update README.md	2022-09-30 21:54:51 +02:00
mathieuHa	26913c5f7e	Update README.md	2022-09-30 21:54:21 +02:00
mathieuHa	ec0ffabc21	Update Readme Show modes in a table Fix gramar	2022-09-30 21:53:54 +02:00
Max Lerebourg	2f2cb60f74	🍱 fix	2022-09-30 01:38:00 +02:00
Max Lerebourg	cb16130ca0	🍱 lint	2022-09-30 00:30:37 +02:00
Max Lerebourg	d4fce42fd7	🍱 lint	2022-09-30 00:03:09 +02:00
Max Lerebourg	253caac5a4	🍱 lint	2022-09-29 22:19:35 +02:00
Max Lerebourg	e122ce488c	🍱 lint	2022-09-29 22:18:08 +02:00
Max Lerebourg	d9d92ed92d	🍱 lint	2022-09-29 22:08:52 +02:00
Max Lerebourg	3452c62860	✨ add alone mode	2022-09-29 21:38:55 +02:00
Max Lerebourg	b545eac5a8	fix lint	2022-09-29 14:01:33 +02:00
Max Lerebourg	2569f26805	fix lint	2022-09-29 11:27:14 +02:00
Max Lerebourg	773f001239	fix lint	2022-09-29 11:18:35 +02:00
Max Lerebourg	6b46c63287	fix logic	2022-09-29 11:16:52 +02:00
Max Lerebourg	c8f59c2233	fix lint	2022-09-29 10:57:11 +02:00
Max Lerebourg	2110c70bbd	fix lint	2022-09-29 10:52:29 +02:00
Max Lerebourg	00bbcfdb94	fix lint	2022-09-29 10:32:09 +02:00
Max Lerebourg	a6012015e6	fix lint	2022-09-29 10:31:25 +02:00
Max Lerebourg	feb40d9b5f	fix lint	2022-09-29 10:08:07 +02:00
Max Lerebourg	6ab8ccb9db	fix lint	2022-09-29 10:02:58 +02:00
Max Lerebourg	dd36df5147	fix lint	2022-09-29 10:00:44 +02:00
Max Lerebourg	ae959e4e0d	fix lint	2022-09-29 09:55:17 +02:00
Max Lerebourg	7f5f69d134	fix lint	2022-09-29 09:52:24 +02:00
Max Lerebourg	1d7c5948f2	fix lint	2022-09-29 09:40:44 +02:00
Max Lerebourg	2559c71930	fix lint	2022-09-29 09:37:25 +02:00
Max Lerebourg	593681fd53	fix lint	2022-09-29 09:36:30 +02:00
Max Lerebourg	c7714cb793	fix lint	2022-09-29 09:33:52 +02:00
Max Lerebourg	75267a1746	fix lint	2022-09-29 09:23:29 +02:00
Max Lerebourg	45eca85f3a	fix lint	2022-09-29 09:18:39 +02:00
Max Lerebourg	1d9bd3fab0	fix lint	2022-09-29 09:16:03 +02:00
Max Lerebourg	0aff6e1789	fix lint	2022-09-29 09:15:14 +02:00
Max Lerebourg	0abf1b7390	fix main action	2022-09-29 09:13:04 +02:00
Max Lerebourg	cb65e48a37	fix readme 8	2022-09-29 09:12:00 +02:00
Max Lerebourg	cba7c1231f	fix lint	2022-09-29 09:11:19 +02:00
Max Lerebourg	da47ef320d	fix readme 7	2022-09-29 09:00:20 +02:00
Max Lerebourg	bbbb5acac5	fix readme 6	2022-09-29 08:59:28 +02:00
Max Lerebourg	6cf89bfc15	fix readme 5	2022-09-29 08:58:48 +02:00
Max Lerebourg	f39317263f	fix readme 4	2022-09-29 07:58:16 +02:00
Max Lerebourg	6dbd498212	fix readme 3	2022-09-29 07:54:11 +02:00
Max Lerebourg	7c2ac9830d	🍱 push .local	2022-09-29 07:45:23 +02:00
mathieuHaandMathieuHa	b985f2d748	update main (#11 ) * Update readme, add about sectioj * Update readme about * Change parameter with capitalized letters * Add docker-compose local and docker-compose for real world utilization * Update readme and .traefik * update readme and docker-compose * Update .traefik Co-authored-by: MathieuHa <mathieu@hanotaux.fr>	2022-09-29 07:44:22 +02:00
Max Lerebourg	a8758eb2e0	fix readme 2	2022-09-29 07:32:57 +02:00
Max Lerebourg	aad92013d1	fix readme 2	2022-09-29 07:30:22 +02:00
Max Lerebourg	4843b86b45	fix readme	2022-09-29 07:19:36 +02:00