OrgGo/Mainflux.mainflux
1
0
Fork 0
mirror of https://github.com/mainflux/mainflux.git synced 2025-04-26 13:48:53 +08:00
Code Issues Projects Releases Wiki Activity

MF-1096 - Fix AuthN and Things Auth ENVARS (#1066)

Browse Source 
* NOISSUE - Fix AuthN and Things Auth ENVARS

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Add DB envars to env.go

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix envars

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Add DefLogLLevelError

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix DB names

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix DB names

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix DB names and HTTP ports

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix .env

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Revert writers DB names

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Rm unused Twins envars

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix reviews

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix reviews

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix typo

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Remove definitions from env.go

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Revert HTTP gRPC ports

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Use default NATS URL as string

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix reviews

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Revert default ports

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix typo

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix cassandra ENVARS

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix cassandra reader ENVARS

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix readers and writers envars

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix readers and writers .env

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix reviews

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>
This commit is contained in:
Manuel Imperiale 2020-04-07 12:02:17 +02:00 committed by GitHub
parent 338c55e554
commit 6c39c85cc8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
51 changed files with 886 additions and 762 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.env
View File

@ -28,6 +28,8 @@ MF_JAEGER_URL=jaeger:6831
MF_AUTHN_LOG_LEVEL=debug
MF_AUTHN_HTTP_PORT=8189
MF_AUTHN_GRPC_PORT=8181
MF_AUTHN_GRPC_URL=authn:8181
MF_AUTHN_GRPC_TIMEOUT=1
MF_AUTHN_DB_PORT=5432
MF_AUTHN_DB_USER=mainflux
MF_AUTHN_DB_PASS=mainflux
@ -60,6 +62,8 @@ MF_THINGS_LOG_LEVEL=debug
MF_THINGS_HTTP_PORT=8182
MF_THINGS_AUTH_HTTP_PORT=8989
MF_THINGS_AUTH_GRPC_PORT=8183
MF_THINGS_AUTH_GRPC_URL=things:8183
MF_THINGS_AUTH_GRPC_TIMEOUT=1
MF_THINGS_DB_PORT=5432
MF_THINGS_DB_USER=mainflux
MF_THINGS_DB_PASS=mainflux
@ -141,31 +145,31 @@ MF_INFLUX_WRITER_PORT=8900
MF_INFLUX_WRITER_BATCH_SIZE=5000
MF_INFLUX_WRITER_BATCH_TIMEOUT=5
MF_INFLUX_WRITER_DB_PORT=8086
MF_INFLUX_WRITER_DB_NAME=mainflux
MF_INFLUX_WRITER_DB_USER=mainflux
MF_INFLUX_WRITER_DB_PASS=mainflux
MF_INFLUX_WRITER_DB=mainflux
MF_INFLUX_WRITER_GRAFANA_PORT=3001
### InfluxDB Reader
MF_INFLUX_READER_LOG_LEVEL=debug
MF_INFLUX_READER_PORT=8905
MF_INFLUX_READER_DB_NAME=mainflux
MF_INFLUX_READER_DB_PORT=8086
MF_INFLUX_READER_DB_USER=mainflux
MF_INFLUX_READER_DB_PASS=mainflux
MF_INFLUX_READER_DB=mainflux
MF_INFLUX_READER_SERVER_CERT=
MF_INFLUX_READER_SERVER_KEY=
### MongoDB Writer
MF_MONGO_WRITER_LOG_LEVEL=debug
MF_MONGO_WRITER_PORT=8901
MF_MONGO_WRITER_DB_NAME=mainflux
MF_MONGO_WRITER_DB=mainflux
MF_MONGO_WRITER_DB_PORT=27017
### MongoDB Reader
MF_MONGO_READER_LOG_LEVEL=debug
MF_MONGO_READER_PORT=8904
MF_MONGO_READER_DB_NAME=mainflux
MF_MONGO_READER_DB=mainflux
MF_MONGO_READER_DB_PORT=27017
MF_MONGO_READER_SERVER_CERT=
MF_MONGO_READER_SERVER_KEY=
@ -176,7 +180,7 @@ MF_POSTGRES_WRITER_PORT=9104
MF_POSTGRES_WRITER_DB_PORT=5432
MF_POSTGRES_WRITER_DB_USER=mainflux
MF_POSTGRES_WRITER_DB_PASS=mainflux
MF_POSTGRES_WRITER_DB_NAME=messages
MF_POSTGRES_WRITER_DB=messages
MF_POSTGRES_WRITER_DB_SSL_MODE=disable
MF_POSTGRES_WRITER_DB_SSL_CERT=""
MF_POSTGRES_WRITER_DB_SSL_KEY=""
@ -190,7 +194,7 @@ MF_POSTGRES_READER_CA_CERTS=""
MF_POSTGRES_READER_DB_PORT=5432
MF_POSTGRES_READER_DB_USER=mainflux
MF_POSTGRES_READER_DB_PASS=mainflux
MF_POSTGRES_READER_DB_NAME=messages
MF_POSTGRES_READER_DB=messages
MF_POSTGRES_READER_DB_SSL_MODE=disable
MF_POSTGRES_READER_DB_SSL_CERT=""
MF_POSTGRES_READER_DB_SSL_KEY=""
@ -201,7 +205,7 @@ MF_TWINS_LOG_LEVEL=debug
MF_TWINS_HTTP_PORT=9021
MF_TWINS_SERVER_CERT=""
MF_TWINS_SERVER_KEY=""
MF_TWINS_DB_NAME=mainflux-twins
MF_TWINS_DB=mainflux-twins
MF_TWINS_DB_HOST=twins-db
MF_TWINS_DB_PORT=27018
MF_TWINS_SINGLE_USER_EMAIL=""

31
bootstrap/README.md
View File

@ -55,7 +55,6 @@ The service is configured using the environment variables presented in the follo
| MF_BOOTSTRAP_SERVER_KEY | Path to server key in pem format | |
| MF_SDK_BASE_URL | Base url for Mainflux SDK | http://localhost |
| MF_SDK_THINGS_PREFIX | SDK prefix for Things service | |
| MF_USERS_URL | Users service URL | localhost:8181 |
| MF_THINGS_ES_URL | Things service event source URL | localhost:6379 |
| MF_THINGS_ES_PASS | Things service event source password | |
| MF_THINGS_ES_DB | Things service event source database | 0 |
@ -64,7 +63,8 @@ The service is configured using the environment variables presented in the follo
| MF_BOOTSTRAP_ES_DB | Bootstrap service event source database | 0 |
| MF_BOOTSTRAP_EVENT_CONSUMER | Bootstrap service event source consumer name | bootstrap |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_BOOTSTRAP_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| MF_AUTHN_GRPC_URL | AuthN service gRPC URL | localhost:8181 |
| MF_AUTHN_GRPC_TIMEOUT | AuthN service gRPC request timeout in seconds | 1 |
## Deployment
@ -101,7 +101,6 @@ version: "2"
MF_BOOTSTRAP_SERVER_KEY: [String path to server key in pem format]
MF_SDK_BASE_URL: [Base SDK URL for the Mainflux services]
MF_SDK_THINGS_PREFIX: [SDK prefix for Things service]
MF_USERS_URL: [Users service URL]
MF_THINGS_ES_URL: [Things service event source URL]
MF_THINGS_ES_PASS: [Things service event source password]
MF_THINGS_ES_DB: [Things service event source database]
@ -110,7 +109,8 @@ version: "2"
MF_BOOTSTRAP_ES_DB: [Bootstrap service event source database]
MF_BOOTSTRAP_EVENT_CONSUMER: [Bootstrap service event source consumer name]
MF_JAEGER_URL: [Jaeger server URL]
MF_BOOTSTRAP_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_AUTHN_GRPC_URL: [AuthN service gRPC URL]
MF_AUTHN_GRPC_TIMEOUT: [AuthN service gRPC request timeout in seconds]
```
To start the service outside of the container, execute the following shell script:
@ -128,7 +128,28 @@ make bootstrap
make install
# set the environment variables and run the service
MF_BOOTSTRAP_LOG_LEVEL=[Bootstrap log level] MF_BOOTSTRAP_DB_HOST=[Database host address] MF_BOOTSTRAP_DB_PORT=[Database host port] MF_BOOTSTRAP_DB_USER=[Database user] MF_BOOTSTRAP_DB_PASS=[Database password] MF_BOOTSTRAP_DB=[Name of the database used by the service] MF_BOOTSTRAP_DB_SSL_MODE=[SSL mode to connect to the database with] MF_BOOTSTRAP_DB_SSL_CERT=[Path to the PEM encoded certificate file] MF_BOOTSTRAP_DB_SSL_KEY=[Path to the PEM encoded key file] MF_BOOTSTRAP_DB_SSL_ROOT_CERT=[Path to the PEM encoded root certificate file] MF_BOOTSTRAP_ENCRYPT_KEY=[Hex-encoded encryption key used for secure bootstrap] MF_BOOTSTRAP_CLIENT_TLS=[Boolean value to enable/disable client TLS] MF_BOOTSTRAP_CA_CERTS=[Path to trusted CAs in PEM format] MF_BOOTSTRAP_PORT=[Service HTTP port] MF_BOOTSTRAP_SERVER_CERT=[Path to server certificate] MF_BOOTSTRAP_SERVER_KEY=[Path to server key] MF_SDK_BASE_URL=[Base SDK URL for the Mainflux services] MF_SDK_THINGS_PREFIX=[SDK prefix for Things service] MF_USERS_URL=[Users service URL] MF_JAEGER_URL=[Jaeger server URL] MF_BOOTSTRAP_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] $GOBIN/mainflux-bootstrap
MF_BOOTSTRAP_LOG_LEVEL=[Bootstrap log level] \
MF_BOOTSTRAP_DB_HOST=[Database host address] \
MF_BOOTSTRAP_DB_PORT=[Database host port] \
MF_BOOTSTRAP_DB_USER=[Database user] \
MF_BOOTSTRAP_DB_PASS=[Database password] \
MF_BOOTSTRAP_DB=[Name of the database used by the service] \
MF_BOOTSTRAP_DB_SSL_MODE=[SSL mode to connect to the database with] \
MF_BOOTSTRAP_DB_SSL_CERT=[Path to the PEM encoded certificate file] \
MF_BOOTSTRAP_DB_SSL_KEY=[Path to the PEM encoded key file] \
MF_BOOTSTRAP_DB_SSL_ROOT_CERT=[Path to the PEM encoded root certificate file] \
MF_BOOTSTRAP_ENCRYPT_KEY=[Hex-encoded encryption key used for secure bootstrap] \
MF_BOOTSTRAP_CLIENT_TLS=[Boolean value to enable/disable client TLS] \
MF_BOOTSTRAP_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_BOOTSTRAP_PORT=[Service HTTP port] \
MF_BOOTSTRAP_SERVER_CERT=[Path to server certificate] \
MF_BOOTSTRAP_SERVER_KEY=[Path to server key] \
MF_SDK_BASE_URL=[Base SDK URL for the Mainflux services] \
MF_SDK_THINGS_PREFIX=[SDK prefix for Things service] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_AUTHN_GRPC_URL=[AuthN service gRPC URL] \
MF_AUTHN_GRPC_TIMEOUT=[AuthN service gRPC request timeout in seconds] \
$GOBIN/mainflux-bootstrap
```
Setting `MF_BOOTSTRAP_CA_CERTS` expects a file in PEM format of trusted CAs. This will enable TLS against the Users gRPC endpoint trusting only those CAs that are provided.

6
cmd/authn/main.go
View File

@ -36,7 +36,7 @@ const (
defDBPort = "5432"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBName = "authn"
defDB = "authn"
defDBSSLMode = "disable"
defDBSSLCert = ""
defDBSSLKey = ""
@ -53,7 +53,7 @@ const (
envDBPort = "MF_AUTHN_DB_PORT"
envDBUser = "MF_AUTHN_DB_USER"
envDBPass = "MF_AUTHN_DB_PASS"
envDBName = "MF_AUTHN_DB"
envDB = "MF_AUTHN_DB"
envDBSSLMode = "MF_AUTHN_DB_SSL_MODE"
envDBSSLCert = "MF_AUTHN_DB_SSL_CERT"
envDBSSLKey = "MF_AUTHN_DB_SSL_KEY"
@ -122,7 +122,7 @@ func loadConfig() config {
Port: mainflux.Env(envDBPort, defDBPort),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Name: mainflux.Env(envDBName, defDBName),
Name: mainflux.Env(envDB, defDB),
SSLMode: mainflux.Env(envDBSSLMode, defDBSSLMode),
SSLCert: mainflux.Env(envDBSSLCert, defDBSSLCert),
SSLKey: mainflux.Env(envDBSSLKey, defDBSSLKey),

32
cmd/bootstrap/main.go
View File

@ -43,7 +43,7 @@ const (
defDBPort = "5432"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBName = "bootstrap"
defDB = "bootstrap"
defDBSSLMode = "disable"
defDBSSLCert = ""
defDBSSLKey = ""
@ -64,15 +64,15 @@ const (
defESDB = "0"
defESConsumerName = "bootstrap"
defJaegerURL = ""
defAuthURL = "localhost:8181"
defAuthTimeout = "1" // in seconds
defAuthnURL = "localhost:8181"
defAuthnTimeout = "1" // in seconds
envLogLevel = "MF_BOOTSTRAP_LOG_LEVEL"
envDBHost = "MF_BOOTSTRAP_DB_HOST"
envDBPort = "MF_BOOTSTRAP_DB_PORT"
envDBUser = "MF_BOOTSTRAP_DB_USER"
envDBPass = "MF_BOOTSTRAP_DB_PASS"
envDBName = "MF_BOOTSTRAP_DB"
envDB = "MF_BOOTSTRAP_DB"
envDBSSLMode = "MF_BOOTSTRAP_DB_SSL_MODE"
envDBSSLCert = "MF_BOOTSTRAP_DB_SSL_CERT"
envDBSSLKey = "MF_BOOTSTRAP_DB_SSL_KEY"
@ -93,8 +93,8 @@ const (
envESDB = "MF_BOOTSTRAP_ES_DB"
envESConsumerName = "MF_BOOTSTRAP_EVENT_CONSUMER"
envJaegerURL = "MF_JAEGER_URL"
envAuthURL = "MF_AUTH_URL"
envAuthTimeout = "MF_AUTH_TIMEOUT"
envAuthnURL = "MF_AUTHN_GRPC_URL"
envAuthnTimeout = "MF_AUTHN_GRPC_TIMEOUT"
)
type config struct {
@ -116,8 +116,8 @@ type config struct {
esDB string
esConsumerName string
jaegerURL string
authURL string
authTimeout time.Duration
authnURL string
authnTimeout time.Duration
}
func main() {
@ -143,7 +143,7 @@ func main() {
authConn := connectToAuth(cfg, logger)
defer authConn.Close()
auth := authapi.NewClient(authTracer, authConn, cfg.authTimeout)
auth := authapi.NewClient(authTracer, authConn, cfg.authnTimeout)
svc := newService(auth, db, logger, esClient, cfg)
errs := make(chan error, 2)
@ -171,16 +171,16 @@ func loadConfig() config {
Port: mainflux.Env(envDBPort, defDBPort),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Name: mainflux.Env(envDBName, defDBName),
Name: mainflux.Env(envDB, defDB),
SSLMode: mainflux.Env(envDBSSLMode, defDBSSLMode),
SSLCert: mainflux.Env(envDBSSLCert, defDBSSLCert),
SSLKey: mainflux.Env(envDBSSLKey, defDBSSLKey),
SSLRootCert: mainflux.Env(envDBSSLRootCert, defDBSSLRootCert),
}
timeout, err := strconv.ParseInt(mainflux.Env(envAuthTimeout, defAuthTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envAuthnTimeout, defAuthnTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envAuthTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envAuthnTimeout, err.Error())
}
encKey, err := hex.DecodeString(mainflux.Env(envEncryptKey, defEncryptKey))
if err != nil {
@ -212,8 +212,8 @@ func loadConfig() config {
esDB: mainflux.Env(envESDB, defESDB),
esConsumerName: mainflux.Env(envESConsumerName, defESConsumerName),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
authURL: mainflux.Env(envAuthURL, defAuthURL),
authTimeout: time.Duration(timeout) * time.Second,
authnURL: mainflux.Env(envAuthnURL, defAuthnURL),
authnTimeout: time.Duration(timeout) * time.Second,
}
}
@ -311,9 +311,9 @@ func connectToAuth(cfg config, logger logger.Logger) *grpc.ClientConn {
logger.Info("gRPC communication is not encrypted")
}
conn, err := grpc.Dial(cfg.authURL, opts...)
conn, err := grpc.Dial(cfg.authnURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
logger.Error(fmt.Sprintf("Failed to connect to authn service: %s", err))
os.Exit(1)
}

108
cmd/cassandra-reader/main.go
View File

@ -34,48 +34,48 @@ import (
const (
sep = ","
defLogLevel = "error"
defPort = "8180"
defCluster = "127.0.0.1"
defKeyspace = "mainflux"
defDBUsername = ""
defDBPassword = ""
defDBPort = "9042"
defThingsURL = "localhost:8181"
defClientTLS = "false"
defCACerts = ""
defServerCert = ""
defServerKey = ""
defJaegerURL = ""
defThingsTimeout = "1" // in seconds
defLogLevel = "error"
defPort = "8180"
defCluster = "127.0.0.1"
defKeyspace = "messages"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBPort = "9042"
defClientTLS = "false"
defCACerts = ""
defServerCert = ""
defServerKey = ""
defJaegerURL = ""
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envLogLevel = "MF_CASSANDRA_READER_LOG_LEVEL"
envPort = "MF_CASSANDRA_READER_PORT"
envCluster = "MF_CASSANDRA_READER_DB_CLUSTER"
envKeyspace = "MF_CASSANDRA_READER_DB_KEYSPACE"
envDBUsername = "MF_CASSANDRA_READER_DB_USERNAME"
envDBPassword = "MF_CASSANDRA_READER_DB_PASSWORD"
envDBPort = "MF_CASSANDRA_READER_DB_PORT"
envThingsURL = "MF_THINGS_URL"
envClientTLS = "MF_CASSANDRA_READER_CLIENT_TLS"
envCACerts = "MF_CASSANDRA_READER_CA_CERTS"
envServerCert = "MF_CASSANDRA_READER_SERVER_CERT"
envServerKey = "MF_CASSANDRA_READER_SERVER_KEY"
envJaegerURL = "MF_JAEGER_URL"
envThingsTimeout = "MF_CASSANDRA_READER_THINGS_TIMEOUT"
envLogLevel = "MF_CASSANDRA_READER_LOG_LEVEL"
envPort = "MF_CASSANDRA_READER_PORT"
envCluster = "MF_CASSANDRA_READER_DB_CLUSTER"
envKeyspace = "MF_CASSANDRA_READER_DB_KEYSPACE"
envDBUser = "MF_CASSANDRA_READER_DB_USER"
envDBPass = "MF_CASSANDRA_READER_DB_PASS"
envDBPort = "MF_CASSANDRA_READER_DB_PORT"
envClientTLS = "MF_CASSANDRA_READER_CLIENT_TLS"
envCACerts = "MF_CASSANDRA_READER_CA_CERTS"
envServerCert = "MF_CASSANDRA_READER_SERVER_CERT"
envServerKey = "MF_CASSANDRA_READER_SERVER_KEY"
envJaegerURL = "MF_JAEGER_URL"
envThingsAuthURL = "MF_THINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMEOUT"
)
type config struct {
logLevel string
port string
dbCfg cassandra.DBConfig
thingsURL string
clientTLS bool
caCerts string
serverCert string
serverKey string
jaegerURL string
thingsTimeout time.Duration
logLevel string
port string
dbCfg cassandra.DBConfig
clientTLS bool
caCerts string
serverCert string
serverKey string
jaegerURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
}
func main() {
@ -95,7 +95,7 @@ func main() {
thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
defer thingsCloser.Close()
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
repo := newService(session, logger)
errs := make(chan error, 2)
@ -121,8 +121,8 @@ func loadConfig() config {
dbCfg := cassandra.DBConfig{
Hosts: strings.Split(mainflux.Env(envCluster, defCluster), sep),
Keyspace: mainflux.Env(envKeyspace, defKeyspace),
Username: mainflux.Env(envDBUsername, defDBUsername),
Password: mainflux.Env(envDBPassword, defDBPassword),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Port: dbPort,
}
@ -131,22 +131,22 @@ func loadConfig() config {
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
return config{
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbCfg: dbCfg,
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbCfg: dbCfg,
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
}
}
@ -176,7 +176,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

16
cmd/cassandra-writer/main.go
View File

@ -29,13 +29,13 @@ const (
svcName = "cassandra-writer"
sep = ","
defNatsURL = mainflux.DefNatsURL
defNatsURL = "nats://localhost:4222"
defLogLevel = "error"
defPort = "8180"
defCluster = "127.0.0.1"
defKeyspace = "mainflux"
defDBUsername = ""
defDBPassword = ""
defKeyspace = "messages"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBPort = "9042"
defSubjectsCfgPath = "/config/subjects.toml"
@ -44,8 +44,8 @@ const (
envPort = "MF_CASSANDRA_WRITER_PORT"
envCluster = "MF_CASSANDRA_WRITER_DB_CLUSTER"
envKeyspace = "MF_CASSANDRA_WRITER_DB_KEYSPACE"
envDBUsername = "MF_CASSANDRA_WRITER_DB_USERNAME"
envDBPassword = "MF_CASSANDRA_WRITER_DB_PASSWORD"
envDBUser = "MF_CASSANDRA_WRITER_DB_USER"
envDBPass = "MF_CASSANDRA_WRITER_DB_PASS"
envDBPort = "MF_CASSANDRA_WRITER_DB_PORT"
envSubjectsCfgPath = "MF_CASSANDRA_WRITER_SUBJECTS_CONFIG"
)
@ -105,8 +105,8 @@ func loadConfig() config {
dbCfg := cassandra.DBConfig{
Hosts: strings.Split(mainflux.Env(envCluster, defCluster), sep),
Keyspace: mainflux.Env(envKeyspace, defKeyspace),
Username: mainflux.Env(envDBUsername, defDBUsername),
Password: mainflux.Env(envDBPassword, defDBPassword),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Port: dbPort,
}

80
cmd/coap/main.go
View File

@ -31,37 +31,37 @@ import (
)
const (
defPort = "5683"
defNatsURL = mainflux.DefNatsURL
defThingsURL = "localhost:8181"
defLogLevel = "error"
defClientTLS = "false"
defCACerts = ""
defPingPeriod = "12"
defJaegerURL = ""
defThingsTimeout = "1" // in seconds
defPort = "5683"
defNatsURL = "nats://localhost:4222"
defLogLevel = "error"
defClientTLS = "false"
defCACerts = ""
defPingPeriod = "12"
defJaegerURL = ""
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envPort = "MF_COAP_ADAPTER_PORT"
envNatsURL = "MF_NATS_URL"
envThingsURL = "MF_THINGS_URL"
envLogLevel = "MF_COAP_ADAPTER_LOG_LEVEL"
envClientTLS = "MF_COAP_ADAPTER_CLIENT_TLS"
envCACerts = "MF_COAP_ADAPTER_CA_CERTS"
envPingPeriod = "MF_COAP_ADAPTER_PING_PERIOD"
envJaegerURL = "MF_JAEGER_URL"
envThingsTimeout = "MF_COAP_ADAPTER_THINGS_TIMEOUT"
envPort = "MF_COAP_ADAPTER_PORT"
envNatsURL = "MF_NATS_URL"
envLogLevel = "MF_COAP_ADAPTER_LOG_LEVEL"
envClientTLS = "MF_COAP_ADAPTER_CLIENT_TLS"
envCACerts = "MF_COAP_ADAPTER_CA_CERTS"
envPingPeriod = "MF_COAP_ADAPTER_PING_PERIOD"
envJaegerURL = "MF_JAEGER_URL"
envThingsAuthURL = "MF_THINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMEOUT"
)
type config struct {
port string
natsURL string
thingsURL string
logLevel string
clientTLS bool
caCerts string
pingPeriod time.Duration
jaegerURL string
thingsTimeout time.Duration
port string
natsURL string
logLevel string
clientTLS bool
caCerts string
pingPeriod time.Duration
jaegerURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
}
func main() {
@ -78,7 +78,7 @@ func main() {
thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
defer thingsCloser.Close()
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
respChan := make(chan string, 10000)
b, err := broker.New(cfg.natsURL)
@ -138,21 +138,21 @@ func loadConfig() config {
log.Fatalf("Value of %s must be between 1 and 24", envPingPeriod)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
return config{
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
natsURL: mainflux.Env(envNatsURL, defNatsURL),
port: mainflux.Env(envPort, defPort),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
pingPeriod: time.Duration(pp),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
natsURL: mainflux.Env(envNatsURL, defNatsURL),
port: mainflux.Env(envPort, defPort),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
pingPeriod: time.Duration(pp),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
}
}
@ -172,7 +172,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

72
cmd/http/main.go
View File

@ -31,34 +31,34 @@ import (
)
const (
defClientTLS = "false"
defCACerts = ""
defPort = "8180"
defLogLevel = "error"
defNatsURL = mainflux.DefNatsURL
defThingsURL = "localhost:8181"
defJaegerURL = ""
defThingsTimeout = "1" // in seconds
defLogLevel = "error"
defClientTLS = "false"
defCACerts = ""
defPort = "8180"
defNatsURL = "nats://localhost:4222"
defJaegerURL = ""
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envClientTLS = "MF_HTTP_ADAPTER_CLIENT_TLS"
envCACerts = "MF_HTTP_ADAPTER_CA_CERTS"
envPort = "MF_HTTP_ADAPTER_PORT"
envLogLevel = "MF_HTTP_ADAPTER_LOG_LEVEL"
envNatsURL = "MF_NATS_URL"
envThingsURL = "MF_THINGS_URL"
envJaegerURL = "MF_JAEGER_URL"
envThingsTimeout = "MF_HTTP_ADAPTER_THINGS_TIMEOUT"
envLogLevel = "MF_HTTP_ADAPTER_LOG_LEVEL"
envClientTLS = "MF_HTTP_ADAPTER_CLIENT_TLS"
envCACerts = "MF_HTTP_ADAPTER_CA_CERTS"
envPort = "MF_HTTP_ADAPTER_PORT"
envNatsURL = "MF_NATS_URL"
envJaegerURL = "MF_JAEGER_URL"
envThingsAuthURL = "MF_THINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMEOUT"
)
type config struct {
thingsURL string
natsURL string
logLevel string
port string
clientTLS bool
caCerts string
jaegerURL string
thingsTimeout time.Duration
natsURL string
logLevel string
port string
clientTLS bool
caCerts string
jaegerURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
}
func main() {
@ -86,7 +86,7 @@ func main() {
}
defer b.Close()
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
svc := adapter.New(b, cc)
svc = api.LoggingMiddleware(svc, logger)
@ -130,20 +130,20 @@ func loadConfig() config {
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
return config{
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
}
}
@ -187,7 +187,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

120
cmd/influxdb-reader/main.go
View File

@ -28,52 +28,52 @@ import (
)
const (
defThingsURL = "localhost:8181"
defLogLevel = "error"
defPort = "8180"
defDBName = "mainflux"
defDBHost = "localhost"
defDBPort = "8086"
defDBUser = "mainflux"
defDBPass = "mainflux"
defClientTLS = "false"
defCACerts = ""
defServerCert = ""
defServerKey = ""
defJaegerURL = ""
defThingsTimeout = "1" // in seconds
defLogLevel = "error"
defPort = "8180"
defDB = "messages"
defDBHost = "localhost"
defDBPort = "8086"
defDBUser = "mainflux"
defDBPass = "mainflux"
defClientTLS = "false"
defCACerts = ""
defServerCert = ""
defServerKey = ""
defJaegerURL = ""
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envThingsURL = "MF_THINGS_URL"
envLogLevel = "MF_INFLUX_READER_LOG_LEVEL"
envPort = "MF_INFLUX_READER_PORT"
envDBName = "MF_INFLUX_READER_DB_NAME"
envDBHost = "MF_INFLUX_READER_DB_HOST"
envDBPort = "MF_INFLUX_READER_DB_PORT"
envDBUser = "MF_INFLUX_READER_DB_USER"
envDBPass = "MF_INFLUX_READER_DB_PASS"
envClientTLS = "MF_INFLUX_READER_CLIENT_TLS"
envCACerts = "MF_INFLUX_READER_CA_CERTS"
envServerCert = "MF_INFLUX_READER_SERVER_CERT"
envServerKey = "MF_INFLUX_READER_SERVER_KEY"
envJaegerURL = "MF_JAEGER_URL"
envThingsTimeout = "MF_INFLUX_READER_THINGS_TIMEOUT"
envLogLevel = "MF_INFLUX_READER_LOG_LEVEL"
envPort = "MF_INFLUX_READER_PORT"
envDB = "MF_INFLUX_READER_DB"
envDBHost = "MF_INFLUX_READER_DB_HOST"
envDBPort = "MF_INFLUX_READER_DB_PORT"
envDBUser = "MF_INFLUX_READER_DB_USER"
envDBPass = "MF_INFLUX_READER_DB_PASS"
envClientTLS = "MF_INFLUX_READER_CLIENT_TLS"
envCACerts = "MF_INFLUX_READER_CA_CERTS"
envServerCert = "MF_INFLUX_READER_SERVER_CERT"
envServerKey = "MF_INFLUX_READER_SERVER_KEY"
envJaegerURL = "MF_JAEGER_URL"
envThingsAuthURL = "MF_THINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMEOUT"
)
type config struct {
thingsURL string
logLevel string
port string
dbName string
dbHost string
dbPort string
dbUser string
dbPass string
clientTLS bool
caCerts string
serverCert string
serverKey string
jaegerURL string
thingsTimeout time.Duration
logLevel string
port string
dbName string
dbHost string
dbPort string
dbUser string
dbPass string
clientTLS bool
caCerts string
serverCert string
serverKey string
jaegerURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
}
func main() {
@ -88,7 +88,7 @@ func main() {
thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
defer thingsCloser.Close()
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
client, err := influxdata.NewHTTPClient(clientCfg)
if err != nil {
@ -118,26 +118,26 @@ func loadConfigs() (config, influxdata.HTTPConfig) {
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
cfg := config{
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbName: mainflux.Env(envDBName, defDBName),
dbHost: mainflux.Env(envDBHost, defDBHost),
dbPort: mainflux.Env(envDBPort, defDBPort),
dbUser: mainflux.Env(envDBUser, defDBUser),
dbPass: mainflux.Env(envDBPass, defDBPass),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbName: mainflux.Env(envDB, defDB),
dbHost: mainflux.Env(envDBHost, defDBHost),
dbPort: mainflux.Env(envDBPort, defDBPort),
dbUser: mainflux.Env(envDBUser, defDBUser),
dbPass: mainflux.Env(envDBPass, defDBPass),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
}
clientCfg := influxdata.HTTPConfig{
@ -165,7 +165,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

8
cmd/influxdb-writer/main.go
View File

@ -26,10 +26,10 @@ import (
const (
svcName = "influxdb-writer"
defNatsURL = mainflux.DefNatsURL
defNatsURL = "nats://localhost:4222"
defLogLevel = "error"
defPort = "8180"
defDBName = "mainflux"
defDB = "messages"
defDBHost = "localhost"
defDBPort = "8086"
defDBUser = "mainflux"
@ -39,7 +39,7 @@ const (
envNatsURL = "MF_NATS_URL"
envLogLevel = "MF_INFLUX_WRITER_LOG_LEVEL"
envPort = "MF_INFLUX_WRITER_PORT"
envDBName = "MF_INFLUX_WRITER_DB_NAME"
envDB = "MF_INFLUX_WRITER_DB"
envDBHost = "MF_INFLUX_WRITER_DB_HOST"
envDBPort = "MF_INFLUX_WRITER_DB_PORT"
envDBUser = "MF_INFLUX_WRITER_DB_USER"
@ -110,7 +110,7 @@ func loadConfigs() (config, influxdata.HTTPConfig) {
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbName: mainflux.Env(envDBName, defDBName),
dbName: mainflux.Env(envDB, defDB),
dbHost: mainflux.Env(envDBHost, defDBHost),
dbPort: mainflux.Env(envDBPort, defDBPort),
dbUser: mainflux.Env(envDBUser, defDBUser),

4
cmd/lora/main.go
View File

@ -27,10 +27,10 @@ import (
)
const (
defLogLevel = "error"
defHTTPPort = "8180"
defLoraMsgURL = "tcp://localhost:1883"
defNatsURL = mainflux.DefNatsURL
defLogLevel = "error"
defNatsURL = "nats://localhost:4222"
defESURL = "localhost:6379"
defESPass = ""
defESDB = "0"

104
cmd/mongodb-reader/main.go
View File

@ -33,46 +33,46 @@ import (
)
const (
defThingsURL = "localhost:8181"
defLogLevel = "error"
defPort = "8180"
defDBName = "mainflux"
defDBHost = "localhost"
defDBPort = "27017"
defClientTLS = "false"
defCACerts = ""
defServerCert = ""
defServerKey = ""
defJaegerURL = ""
defThingsTimeout = "1" // in seconds
defLogLevel = "error"
defPort = "8180"
defDB = "messages"
defDBHost = "localhost"
defDBPort = "27017"
defClientTLS = "false"
defCACerts = ""
defServerCert = ""
defServerKey = ""
defJaegerURL = ""
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envThingsURL = "MF_THINGS_URL"
envLogLevel = "MF_MONGO_READER_LOG_LEVEL"
envPort = "MF_MONGO_READER_PORT"
envDBName = "MF_MONGO_READER_DB_NAME"
envDBHost = "MF_MONGO_READER_DB_HOST"
envDBPort = "MF_MONGO_READER_DB_PORT"
envClientTLS = "MF_MONGO_READER_CLIENT_TLS"
envCACerts = "MF_MONGO_READER_CA_CERTS"
envServerCert = "MF_MONGO_READER_SERVER_CERT"
envServerKey = "MF_MONGO_READER_SERVER_KEY"
envJaegerURL = "MF_JAEGER_URL"
envThingsTimeout = "MF_MONGO_READER_THINGS_TIMEOUT"
envLogLevel = "MF_MONGO_READER_LOG_LEVEL"
envPort = "MF_MONGO_READER_PORT"
envDB = "MF_MONGO_READER_DB"
envDBHost = "MF_MONGO_READER_DB_HOST"
envDBPort = "MF_MONGO_READER_DB_PORT"
envClientTLS = "MF_MONGO_READER_CLIENT_TLS"
envCACerts = "MF_MONGO_READER_CA_CERTS"
envServerCert = "MF_MONGO_READER_SERVER_CERT"
envServerKey = "MF_MONGO_READER_SERVER_KEY"
envJaegerURL = "MF_JAEGER_URL"
envThingsAuthURL = "MF_ThINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMEOUT"
)
type config struct {
thingsURL string
logLevel string
port string
dbName string
dbHost string
dbPort string
clientTLS bool
caCerts string
serverCert string
serverKey string
jaegerURL string
thingsTimeout time.Duration
logLevel string
port string
dbName string
dbHost string
dbPort string
clientTLS bool
caCerts string
serverCert string
serverKey string
jaegerURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
}
func main() {
@ -88,7 +88,7 @@ func main() {
thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
defer thingsCloser.Close()
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
db := connectToMongoDB(cfg.dbHost, cfg.dbPort, cfg.dbName, logger)
@ -113,24 +113,24 @@ func loadConfigs() config {
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
return config{
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbName: mainflux.Env(envDBName, defDBName),
dbHost: mainflux.Env(envDBHost, defDBHost),
dbPort: mainflux.Env(envDBPort, defDBPort),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbName: mainflux.Env(envDB, defDB),
dbHost: mainflux.Env(envDBHost, defDBHost),
dbPort: mainflux.Env(envDBPort, defDBPort),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
}
}
@ -185,7 +185,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

8
cmd/mongodb-writer/main.go
View File

@ -28,10 +28,10 @@ import (
const (
svcName = "mongodb-writer"
defNatsURL = mainflux.DefNatsURL
defLogLevel = "error"
defNatsURL = "nats://localhost:4222"
defPort = "8180"
defDBName = "mainflux"
defDB = "messages"
defDBHost = "localhost"
defDBPort = "27017"
defSubjectsCfgPath = "/config/subjects.toml"
@ -39,7 +39,7 @@ const (
envNatsURL = "MF_NATS_URL"
envLogLevel = "MF_MONGO_WRITER_LOG_LEVEL"
envPort = "MF_MONGO_WRITER_PORT"
envDBName = "MF_MONGO_WRITER_DB_NAME"
envDB = "MF_MONGO_WRITER_DB"
envDBHost = "MF_MONGO_WRITER_DB_HOST"
envDBPort = "MF_MONGO_WRITER_DB_PORT"
envSubjectsCfgPath = "MF_MONGO_WRITER_SUBJECTS_CONFIG"
@ -107,7 +107,7 @@ func loadConfigs() config {
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbName: mainflux.Env(envDBName, defDBName),
dbName: mainflux.Env(envDB, defDB),
dbHost: mainflux.Env(envDBHost, defDBHost),
dbPort: mainflux.Env(envDBPort, defDBPort),
subjectsCfgPath: mainflux.Env(envSubjectsCfgPath, defSubjectsCfgPath),

110
cmd/mqtt/main.go
View File

@ -28,6 +28,9 @@ import (
)
const (
// Logging
defLogLevel = "error"
envLogLevel = "MF_MQTT_ADAPTER_LOG_LEVEL"
// MQTT
defMQTTHost = "0.0.0.0"
defMQTTPort = "1883"
@ -50,16 +53,13 @@ const (
envHTTPTargetHost = "MF_MQTT_ADAPTER_WS_TARGET_HOST"
envHTTPTargetPort = "MF_MQTT_ADAPTER_WS_TARGET_PORT"
envHTTPTargetPath = "MF_MQTT_ADAPTER_WS_TARGET_PATH"
// Logging
defLogLevel = "error"
envLogLevel = "MF_MQTT_ADAPTER_LOG_LEVEL"
// Things
defThingsURL = "localhost:8181"
defThingsTimeout = "1" // in seconds
envThingsURL = "MF_THINGS_URL"
envThingsTimeout = "MF_MQTT_ADAPTER_THINGS_TIMEOUT"
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envThingsAuthURL = "MF_THINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMMEOUT"
// Nats
defNatsURL = mainflux.DefNatsURL
defNatsURL = "nats://localhost:4222"
envNatsURL = "MF_NATS_URL"
// Jaeger
defJaegerURL = ""
@ -82,27 +82,28 @@ const (
)
type config struct {
mqttHost string
mqttPort string
mqttTargetHost string
mqttTargetPort string
httpHost string
httpPort string
httpScheme string
httpTargetHost string
httpTargetPort string
httpTargetPath string
jaegerURL string
logLevel string
thingsURL string
thingsTimeout time.Duration
natsURL string
clientTLS bool
caCerts string
instance string
esURL string
esPass string
esDB string
mqttHost string
mqttPort string
mqttTargetHost string
mqttTargetPort string
httpHost string
httpPort string
httpScheme string
httpTargetHost string
httpTargetPort string
httpTargetPath string
jaegerURL string
logLevel string
thingsURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
natsURL string
clientTLS bool
caCerts string
instance string
esURL string
esPass string
esDB string
}
func main() {
@ -125,7 +126,7 @@ func main() {
rc := connectToRedis(cfg.esURL, cfg.esPass, cfg.esDB, logger)
defer rc.Close()
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
b, err := broker.New(cfg.natsURL)
if err != nil {
@ -163,33 +164,34 @@ func loadConfig() config {
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
return config{
mqttHost: mainflux.Env(envMQTTHost, defMQTTHost),
mqttPort: mainflux.Env(envMQTTPort, defMQTTPort),
mqttTargetHost: mainflux.Env(envMQTTTargetHost, defMQTTTargetHost),
mqttTargetPort: mainflux.Env(envMQTTTargetPort, defMQTTTargetPort),
httpHost: mainflux.Env(envHTTPHost, defHTTPHost),
httpPort: mainflux.Env(envHTTPPort, defHTTPPort),
httpScheme: mainflux.Env(envHTTPScheme, defHTTPScheme),
httpTargetHost: mainflux.Env(envHTTPTargetHost, defHTTPTargetHost),
httpTargetPort: mainflux.Env(envHTTPTargetPort, defHTTPTargetPort),
httpTargetPath: mainflux.Env(envHTTPTargetPath, defHTTPTargetPath),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
instance: mainflux.Env(envInstance, defInstance),
esURL: mainflux.Env(envESURL, defESURL),
esPass: mainflux.Env(envESPass, defESPass),
esDB: mainflux.Env(envESDB, defESDB),
mqttHost: mainflux.Env(envMQTTHost, defMQTTHost),
mqttPort: mainflux.Env(envMQTTPort, defMQTTPort),
mqttTargetHost: mainflux.Env(envMQTTTargetHost, defMQTTTargetHost),
mqttTargetPort: mainflux.Env(envMQTTTargetPort, defMQTTTargetPort),
httpHost: mainflux.Env(envHTTPHost, defHTTPHost),
httpPort: mainflux.Env(envHTTPPort, defHTTPPort),
httpScheme: mainflux.Env(envHTTPScheme, defHTTPScheme),
httpTargetHost: mainflux.Env(envHTTPTargetHost, defHTTPTargetHost),
httpTargetPort: mainflux.Env(envHTTPTargetPort, defHTTPTargetPort),
httpTargetPath: mainflux.Env(envHTTPTargetPath, defHTTPTargetPath),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
thingsURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
instance: mainflux.Env(envInstance, defInstance),
esURL: mainflux.Env(envESURL, defESURL),
esPass: mainflux.Env(envESPass, defESPass),
esDB: mainflux.Env(envESDB, defESDB),
}
}
@ -233,7 +235,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

8
cmd/opcua/main.go
View File

@ -28,14 +28,14 @@ import (
)
const (
defHTTPPort = "8188"
defLogLevel = "error"
defHTTPPort = "8180"
defOPCIntervalMs = "1000"
defOPCPolicy = ""
defOPCMode = ""
defOPCCertFile = ""
defOPCKeyFile = ""
defNatsURL = mainflux.DefNatsURL
defLogLevel = "debug"
defNatsURL = "nats://localhost:4222"
defESURL = "localhost:6379"
defESPass = ""
defESDB = "0"
@ -44,8 +44,8 @@ const (
defRouteMapPass = ""
defRouteMapDB = "0"
envHTTPPort = "MF_OPCUA_ADAPTER_HTTP_PORT"
envLogLevel = "MF_OPCUA_ADAPTER_LOG_LEVEL"
envHTTPPort = "MF_OPCUA_ADAPTER_HTTP_PORT"
envOPCIntervalMs = "MF_OPCUA_ADAPTER_INTERVAL_MS"
envOPCPolicy = "MF_OPCUA_ADAPTER_POLICY"
envOPCMode = "MF_OPCUA_ADAPTER_MODE"

109
cmd/postgres-reader/main.go
View File

@ -34,50 +34,50 @@ const (
svcName = "postgres-writer"
sep = ","
defThingsURL = "localhost:8183"
defLogLevel = "debug"
defPort = "9204"
defClientTLS = "false"
defCACerts = ""
defDBHost = "localhost"
defDBPort = "5432"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBName = "messages"
defDBSSLMode = "disable"
defDBSSLCert = ""
defDBSSLKey = ""
defDBSSLRootCert = ""
defJaegerURL = ""
defThingsTimeout = "1" // in seconds
defLogLevel = "error"
defPort = "8180"
defClientTLS = "false"
defCACerts = ""
defDBHost = "localhost"
defDBPort = "5432"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDB = "messages"
defDBSSLMode = "disable"
defDBSSLCert = ""
defDBSSLKey = ""
defDBSSLRootCert = ""
defJaegerURL = ""
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envThingsURL = "MF_THINGS_URL"
envLogLevel = "MF_POSTGRES_READER_LOG_LEVEL"
envPort = "MF_POSTGRES_READER_PORT"
envClientTLS = "MF_POSTGRES_READER_CLIENT_TLS"
envCACerts = "MF_POSTGRES_READER_CA_CERTS"
envDBHost = "MF_POSTGRES_READER_DB_HOST"
envDBPort = "MF_POSTGRES_READER_DB_PORT"
envDBUser = "MF_POSTGRES_READER_DB_USER"
envDBPass = "MF_POSTGRES_READER_DB_PASS"
envDBName = "MF_POSTGRES_READER_DB_NAME"
envDBSSLMode = "MF_POSTGRES_READER_DB_SSL_MODE"
envDBSSLCert = "MF_POSTGRES_READER_DB_SSL_CERT"
envDBSSLKey = "MF_POSTGRES_READER_DB_SSL_KEY"
envDBSSLRootCert = "MF_POSTGRES_READER_DB_SSL_ROOT_CERT"
envJaegerURL = "MF_JAEGER_URL"
envThingsTimeout = "MF_POSTGRES_READER_THINGS_TIMEOUT"
envLogLevel = "MF_POSTGRES_READER_LOG_LEVEL"
envPort = "MF_POSTGRES_READER_PORT"
envClientTLS = "MF_POSTGRES_READER_CLIENT_TLS"
envCACerts = "MF_POSTGRES_READER_CA_CERTS"
envDBHost = "MF_POSTGRES_READER_DB_HOST"
envDBPort = "MF_POSTGRES_READER_DB_PORT"
envDBUser = "MF_POSTGRES_READER_DB_USER"
envDBPass = "MF_POSTGRES_READER_DB_PASS"
envDB = "MF_POSTGRES_READER_DB"
envDBSSLMode = "MF_POSTGRES_READER_DB_SSL_MODE"
envDBSSLCert = "MF_POSTGRES_READER_DB_SSL_CERT"
envDBSSLKey = "MF_POSTGRES_READER_DB_SSL_KEY"
envDBSSLRootCert = "MF_POSTGRES_READER_DB_SSL_ROOT_CERT"
envJaegerURL = "MF_JAEGER_URL"
envThingsAuthURL = "MF_THINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMEOUT"
)
type config struct {
thingsURL string
logLevel string
port string
clientTLS bool
caCerts string
dbConfig postgres.Config
jaegerURL string
thingsTimeout time.Duration
logLevel string
port string
clientTLS bool
caCerts string
dbConfig postgres.Config
jaegerURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
}
func main() {
@ -94,7 +94,7 @@ func main() {
thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
defer thingsCloser.Close()
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
db := connectToDB(cfg.dbConfig, logger)
defer db.Close()
@ -121,25 +121,32 @@ func loadConfig() config {
Port: mainflux.Env(envDBPort, defDBPort),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Name: mainflux.Env(envDBName, defDBName),
Name: mainflux.Env(envDB, defDB),
SSLMode: mainflux.Env(envDBSSLMode, defDBSSLMode),
SSLCert: mainflux.Env(envDBSSLCert, defDBSSLCert),
SSLKey: mainflux.Env(envDBSSLKey, defDBSSLKey),
SSLRootCert: mainflux.Env(envDBSSLRootCert, defDBSSLRootCert),
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
tls, err := strconv.ParseBool(mainflux.Env(envClientTLS, defClientTLS))
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
return config{
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
dbConfig: dbConfig,
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
dbConfig: dbConfig,
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
}
}
@ -192,7 +199,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

10
cmd/postgres-writer/main.go
View File

@ -27,14 +27,14 @@ const (
svcName = "postgres-writer"
sep = ","
defNatsURL = mainflux.DefNatsURL
defLogLevel = "error"
defPort = "9104"
defNatsURL = "nats://localhost:4222"
defPort = "8180"
defDBHost = "postgres"
defDBPort = "5432"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBName = "messages"
defDB = "messages"
defDBSSLMode = "disable"
defDBSSLCert = ""
defDBSSLKey = ""
@ -48,7 +48,7 @@ const (
envDBPort = "MF_POSTGRES_WRITER_DB_PORT"
envDBUser = "MF_POSTGRES_WRITER_DB_USER"
envDBPass = "MF_POSTGRES_WRITER_DB_PASS"
envDBName = "MF_POSTGRES_WRITER_DB_NAME"
envDB = "MF_POSTGRES_WRITER_DB"
envDBSSLMode = "MF_POSTGRES_WRITER_DB_SSL_MODE"
envDBSSLCert = "MF_POSTGRES_WRITER_DB_SSL_CERT"
envDBSSLKey = "MF_POSTGRES_WRITER_DB_SSL_KEY"
@ -108,7 +108,7 @@ func loadConfig() config {
Port: mainflux.Env(envDBPort, defDBPort),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Name: mainflux.Env(envDBName, defDBName),
Name: mainflux.Env(envDB, defDB),
SSLMode: mainflux.Env(envDBSSLMode, defDBSSLMode),
SSLCert: mainflux.Env(envDBSSLCert, defDBSSLCert),
SSLKey: mainflux.Env(envDBSSLKey, defDBSSLKey),

36
cmd/things/main.go
View File

@ -47,7 +47,7 @@ const (
defDBPort = "5432"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBName = "things"
defDB = "things"
defDBSSLMode = "disable"
defDBSSLCert = ""
defDBSSLKey = ""
@ -60,23 +60,23 @@ const (
defESURL = "localhost:6379"
defESPass = ""
defESDB = "0"
defHTTPPort = "8180"
defAuthHTTPPort = "8989"
defHTTPPort = "8182"
defAuthHTTPPort = "8180"
defAuthGRPCPort = "8181"
defServerCert = ""
defServerKey = ""
defSingleUserEmail = ""
defSingleUserToken = ""
defJaegerURL = ""
defAuthURL = "localhost:8181"
defAuthTimeout = "1" // in seconds
defAuthnURL = "localhost:8181"
defAuthnTimeout = "1" // in seconds
envLogLevel = "MF_THINGS_LOG_LEVEL"
envDBHost = "MF_THINGS_DB_HOST"
envDBPort = "MF_THINGS_DB_PORT"
envDBUser = "MF_THINGS_DB_USER"
envDBPass = "MF_THINGS_DB_PASS"
envDBName = "MF_THINGS_DB"
envDB = "MF_THINGS_DB"
envDBSSLMode = "MF_THINGS_DB_SSL_MODE"
envDBSSLCert = "MF_THINGS_DB_SSL_CERT"
envDBSSLKey = "MF_THINGS_DB_SSL_KEY"
@ -97,8 +97,8 @@ const (
envSingleUserEmail = "MF_THINGS_SINGLE_USER_EMAIL"
envSingleUserToken = "MF_THINGS_SINGLE_USER_TOKEN"
envJaegerURL = "MF_JAEGER_URL"
envAuthURL = "MF_AUTH_URL"
envAuthTimeout = "MF_AUTH_TIMEOUT"
envAuthnURL = "MF_AUTHN_GRPC_URL"
envAuthnTimeout = "MF_AUTHN_GRPC_TIMEOUT"
)
type config struct {
@ -120,8 +120,8 @@ type config struct {
singleUserEmail string
singleUserToken string
jaegerURL string
authURL string
authTimeout time.Duration
authnURL string
authnTimeout time.Duration
}
func main() {
@ -179,9 +179,9 @@ func loadConfig() config {
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envAuthTimeout, defAuthTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envAuthnTimeout, defAuthnTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envAuthTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envAuthnTimeout, err.Error())
}
dbConfig := postgres.Config{
@ -189,7 +189,7 @@ func loadConfig() config {
Port: mainflux.Env(envDBPort, defDBPort),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Name: mainflux.Env(envDBName, defDBName),
Name: mainflux.Env(envDB, defDB),
SSLMode: mainflux.Env(envDBSSLMode, defDBSSLMode),
SSLCert: mainflux.Env(envDBSSLCert, defDBSSLCert),
SSLKey: mainflux.Env(envDBSSLKey, defDBSSLKey),
@ -215,8 +215,8 @@ func loadConfig() config {
singleUserEmail: mainflux.Env(envSingleUserEmail, defSingleUserEmail),
singleUserToken: mainflux.Env(envSingleUserToken, defSingleUserToken),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
authURL: mainflux.Env(envAuthURL, defAuthURL),
authTimeout: time.Duration(timeout) * time.Second,
authnURL: mainflux.Env(envAuthnURL, defAuthnURL),
authnTimeout: time.Duration(timeout) * time.Second,
}
}
@ -273,7 +273,7 @@ func createAuthClient(cfg config, tracer opentracing.Tracer, logger logger.Logge
}
conn := connectToAuth(cfg, logger)
return authapi.NewClient(tracer, conn, cfg.authTimeout), conn.Close
return authapi.NewClient(tracer, conn, cfg.authnTimeout), conn.Close
}
func connectToAuth(cfg config, logger logger.Logger) *grpc.ClientConn {
@ -292,9 +292,9 @@ func connectToAuth(cfg config, logger logger.Logger) *grpc.ClientConn {
logger.Info("gRPC communication is not encrypted")
}
conn, err := grpc.Dial(cfg.authURL, opts...)
conn, err := grpc.Dial(cfg.authnURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
logger.Error(fmt.Sprintf("Failed to connect to authn service: %s", err))
os.Exit(1)
}

34
cmd/twins/main.go
View File

@ -40,45 +40,39 @@ import (
const (
queue = "twins"
defLogLevel = "info"
defHTTPPort = "9021"
defLogLevel = "error"
defHTTPPort = "8180"
defJaegerURL = ""
defServerCert = ""
defServerKey = ""
defDBName = "mainflux"
defDB = "mainflux-twins"
defDBHost = "localhost"
defDBPort = "27017"
defSingleUserEmail = ""
defSingleUserToken = ""
defClientTLS = "false"
defCACerts = ""
defThingID = ""
defThingKey = ""
defChannelID = ""
defNatsURL = mainflux.DefNatsURL
defAuthnTimeout = "1" // in seconds
defAuthnURL = "localhost:8181"
defNatsURL = "nats://localhost:4222"
defAuthnURL = "localhost:8181"
defAuthnTimeout = "1" // in seconds
envLogLevel = "MF_TWINS_LOG_LEVEL"
envHTTPPort = "MF_TWINS_HTTP_PORT"
envJaegerURL = "MF_JAEGER_URL"
envServerCert = "MF_TWINS_SERVER_CERT"
envServerKey = "MF_TWINS_SERVER_KEY"
envDBName = "MF_TWINS_DB_NAME"
envDB = "MF_TWINS_DB"
envDBHost = "MF_TWINS_DB_HOST"
envDBPort = "MF_TWINS_DB_PORT"
envSingleUserEmail = "MF_TWINS_SINGLE_USER_EMAIL"
envSingleUserToken = "MF_TWINS_SINGLE_USER_TOKEN"
envClientTLS = "MF_TWINS_CLIENT_TLS"
envCACerts = "MF_TWINS_CA_CERTS"
envThingID = "MF_TWINS_THING_ID"
envThingKey = "MF_TWINS_THING_KEY"
envChannelID = "MF_TWINS_CHANNEL_ID"
envNatsURL = "MF_NATS_URL"
envAuthnTimeout = "MF_AUTHN_TIMEOUT"
envAuthnURL = "MF_AUTHN_URL"
envAuthnURL = "MF_AUTHN_GRPC_URL"
envAuthnTimeout = "MF_AUTHN_GRPC_TIMEOUT"
)
type config struct {
@ -92,13 +86,11 @@ type config struct {
singleUserToken string
clientTLS bool
caCerts string
thingID string
thingKey string
channelID string
natsURL string
authnTimeout time.Duration
authnURL string
authnTimeout time.Duration
}
func main() {
@ -164,7 +156,7 @@ func loadConfig() config {
}
dbCfg := twmongodb.Config{
Name: mainflux.Env(envDBName, defDBName),
Name: mainflux.Env(envDB, defDB),
Host: mainflux.Env(envDBHost, defDBHost),
Port: mainflux.Env(envDBPort, defDBPort),
}
@ -180,9 +172,7 @@ func loadConfig() config {
singleUserToken: mainflux.Env(envSingleUserToken, defSingleUserToken),
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
thingID: mainflux.Env(envThingID, defThingID),
channelID: mainflux.Env(envChannelID, defChannelID),
thingKey: mainflux.Env(envThingKey, defThingKey),
natsURL: mainflux.Env(envNatsURL, defNatsURL),
authnURL: mainflux.Env(envAuthnURL, defAuthnURL),
authnTimeout: time.Duration(timeout) * time.Second,
@ -240,7 +230,7 @@ func connectToAuth(cfg config, logger logger.Logger) *grpc.ClientConn {
conn, err := grpc.Dial(cfg.authnURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to auth service: %s", err))
logger.Error(fmt.Sprintf("Failed to connect to authn service: %s", err))
os.Exit(1)
}

83
cmd/users/main.go
View File

@ -41,7 +41,7 @@ const (
defDBPort = "5432"
defDBUser = "mainflux"
defDBPass = "mainflux"
defDBName = "users"
defDB = "users"
defDBSSLMode = "disable"
defDBSSLCert = ""
defDBSSLKey = ""
@ -51,13 +51,6 @@ const (
defServerKey = ""
defJaegerURL = ""
defAuthnHTTPPort = "8989"
defAuthnGRPCPort = "8181"
defAuthnTimeout = "1" // in seconds
defAuthnTLS = "false"
defAuthnCACerts = ""
defAuthnURL = "localhost:8181"
defEmailLogLevel = "debug"
defEmailDriver = "smtp"
defEmailHost = "localhost"
@ -70,12 +63,17 @@ const (
defTokenResetEndpoint = "/reset-request" // URL where user lands after click on the reset link from email
defAuthnTLS = "false"
defAuthnCACerts = ""
defAuthnURL = "localhost:8181"
defAuthnTimeout = "1" // in seconds
envLogLevel = "MF_USERS_LOG_LEVEL"
envDBHost = "MF_USERS_DB_HOST"
envDBPort = "MF_USERS_DB_PORT"
envDBUser = "MF_USERS_DB_USER"
envDBPass = "MF_USERS_DB_PASS"
envDBName = "MF_USERS_DB"
envDB = "MF_USERS_DB"
envDBSSLMode = "MF_USERS_DB_SSL_MODE"
envDBSSLCert = "MF_USERS_DB_SSL_CERT"
envDBSSLKey = "MF_USERS_DB_SSL_KEY"
@ -85,13 +83,6 @@ const (
envServerKey = "MF_USERS_SERVER_KEY"
envJaegerURL = "MF_JAEGER_URL"
envAuthnHTTPPort = "MF_AUTHN_HTTP_PORT"
envAuthnGRPCPort = "MF_AUTHN_GRPC_PORT"
envAuthnTimeout = "MF_AUTHN_TIMEOUT"
envAuthnTLS = "MF_AUTHN_CLIENT_TLS"
envAuthnCACerts = "MF_AUTHN_CA_CERTS"
envAuthnURL = "MF_AUTHN_URL"
envEmailDriver = "MF_EMAIL_DRIVER"
envEmailHost = "MF_EMAIL_HOST"
envEmailPort = "MF_EMAIL_PORT"
@ -103,23 +94,26 @@ const (
envEmailTemplate = "MF_EMAIL_TEMPLATE"
envTokenResetEndpoint = "MF_TOKEN_RESET_ENDPOINT"
envAuthnTLS = "MF_AUTHN_CLIENT_TLS"
envAuthnCACerts = "MF_AUTHN_CA_CERTS"
envAuthnURL = "MF_AUTHN_GRPC_URL"
envAuthnTimeout = "MF_AUTHN_GRPC_TIMEOUT"
)
type config struct {
logLevel string
dbConfig postgres.Config
authnHTTPPort string
authnGRPCPort string
authnTimeout time.Duration
authnTLS bool
authnCACerts string
authnURL string
emailConf email.Config
httpPort string
serverCert string
serverKey string
jaegerURL string
resetURL string
logLevel string
dbConfig postgres.Config
emailConf email.Config
httpPort string
serverCert string
serverKey string
jaegerURL string
resetURL string
authnTLS bool
authnCACerts string
authnURL string
authnTimeout time.Duration
}
func main() {
@ -178,7 +172,7 @@ func loadConfig() config {
Port: mainflux.Env(envDBPort, defDBPort),
User: mainflux.Env(envDBUser, defDBUser),
Pass: mainflux.Env(envDBPass, defDBPass),
Name: mainflux.Env(envDBName, defDBName),
Name: mainflux.Env(envDB, defDB),
SSLMode: mainflux.Env(envDBSSLMode, defDBSSLMode),
SSLCert: mainflux.Env(envDBSSLCert, defDBSSLCert),
SSLKey: mainflux.Env(envDBSSLKey, defDBSSLKey),
@ -197,19 +191,18 @@ func loadConfig() config {
}
return config{
logLevel: mainflux.Env(envLogLevel, defLogLevel),
dbConfig: dbConfig,
authnHTTPPort: mainflux.Env(envAuthnHTTPPort, defAuthnHTTPPort),
authnGRPCPort: mainflux.Env(envAuthnGRPCPort, defAuthnGRPCPort),
authnURL: mainflux.Env(envAuthnURL, defAuthnURL),
authnTimeout: time.Duration(timeout) * time.Second,
authnTLS: tls,
emailConf: emailConf,
httpPort: mainflux.Env(envHTTPPort, defHTTPPort),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
resetURL: mainflux.Env(envTokenResetEndpoint, defTokenResetEndpoint),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
dbConfig: dbConfig,
emailConf: emailConf,
httpPort: mainflux.Env(envHTTPPort, defHTTPPort),
serverCert: mainflux.Env(envServerCert, defServerCert),
serverKey: mainflux.Env(envServerKey, defServerKey),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
resetURL: mainflux.Env(envTokenResetEndpoint, defTokenResetEndpoint),
authnTLS: tls,
authnCACerts: mainflux.Env(envAuthnCACerts, defAuthnCACerts),
authnURL: mainflux.Env(envAuthnURL, defAuthnURL),
authnTimeout: time.Duration(timeout) * time.Second,
}
}
@ -266,7 +259,7 @@ func connectToAuthn(cfg config, tracer opentracing.Tracer, logger logger.Logger)
conn, err := grpc.Dial(cfg.authnURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
logger.Error(fmt.Sprintf("Failed to connect to authn service: %s", err))
os.Exit(1)
}

72
cmd/ws/main.go
View File

@ -31,34 +31,34 @@ import (
)
const (
defClientTLS = "false"
defCACerts = ""
defPort = "8180"
defLogLevel = "error"
defNatsURL = mainflux.DefNatsURL
defThingsURL = "localhost:8181"
defJaegerURL = ""
defThingsTimeout = "1" // in seconds
defLogLevel = "error"
defClientTLS = "false"
defCACerts = ""
defPort = "8180"
defNatsURL = "nats://localhost:4222"
defJaegerURL = ""
defThingsAuthURL = "localhost:8181"
defThingsAuthTimeout = "1" // in seconds
envClientTLS = "MF_WS_ADAPTER_CLIENT_TLS"
envCACerts = "MF_WS_ADAPTER_CA_CERTS"
envPort = "MF_WS_ADAPTER_PORT"
envLogLevel = "MF_WS_ADAPTER_LOG_LEVEL"
envNatsURL = "MF_NATS_URL"
envThingsURL = "MF_THINGS_URL"
envJaegerURL = "MF_JAEGER_URL"
envThingsTimeout = "MF_WS_ADAPTER_THINGS_TIMEOUT"
envLogLevel = "MF_WS_ADAPTER_LOG_LEVEL"
envClientTLS = "MF_WS_ADAPTER_CLIENT_TLS"
envCACerts = "MF_WS_ADAPTER_CA_CERTS"
envPort = "MF_WS_ADAPTER_PORT"
envNatsURL = "MF_NATS_URL"
envJaegerURL = "MF_JAEGER_URL"
envThingsAuthURL = "MF_THINGS_AUTH_GRPC_URL"
envThingsAuthTimeout = "MF_THINGS_AUTH_GRPC_TIMEOUT"
)
type config struct {
clientTLS bool
caCerts string
thingsURL string
natsURL string
logLevel string
port string
jaegerURL string
thingsTimeout time.Duration
clientTLS bool
caCerts string
natsURL string
logLevel string
port string
jaegerURL string
thingsAuthURL string
thingsAuthTimeout time.Duration
}
func main() {
@ -75,7 +75,7 @@ func main() {
thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
defer thingsCloser.Close()
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsAuthTimeout)
b, err := broker.New(cfg.natsURL)
if err != nil {
@ -110,20 +110,20 @@ func loadConfig() config {
log.Fatalf("Invalid value passed for %s\n", envClientTLS)
}
timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
timeout, err := strconv.ParseInt(mainflux.Env(envThingsAuthTimeout, defThingsAuthTimeout), 10, 64)
if err != nil {
log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
log.Fatalf("Invalid %s value: %s", envThingsAuthTimeout, err.Error())
}
return config{
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
thingsURL: mainflux.Env(envThingsURL, defThingsURL),
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsTimeout: time.Duration(timeout) * time.Second,
clientTLS: tls,
caCerts: mainflux.Env(envCACerts, defCACerts),
natsURL: mainflux.Env(envNatsURL, defNatsURL),
logLevel: mainflux.Env(envLogLevel, defLogLevel),
port: mainflux.Env(envPort, defPort),
jaegerURL: mainflux.Env(envJaegerURL, defJaegerURL),
thingsAuthURL: mainflux.Env(envThingsAuthURL, defThingsAuthURL),
thingsAuthTimeout: time.Duration(timeout) * time.Second,
}
}
@ -143,7 +143,7 @@ func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(cfg.thingsURL, opts...)
conn, err := grpc.Dial(cfg.thingsAuthURL, opts...)
if err != nil {
logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
os.Exit(1)

19
coap/README.md
View File

@ -13,13 +13,13 @@ default values.
|--------------------------------|--------------------------------------------------------|-----------------------|
| MF_COAP_ADAPTER_PORT | Service listening port | 5683 |
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_THINGS_URL | Things service URL | localhost:8181 |
| MF_COAP_ADAPTER_LOG_LEVEL | Service log level | error |
| MF_COAP_ADAPTER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_COAP_ADAPTER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_COAP_ADAPTER_PING_PERIOD | Hours between 1 and 24 to ping client with ACK message | 12 |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_COAP_ADAPTER_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| MF_THINGS_AUTH_GRPC_URL | Things service Auth gRPC URL | localhost:8181 |
| MF_THINGS_AUTH_GRPC_TIMEOUT | Things service Auth gRPC request timeout in seconds | 1 |
## Deployment
@ -37,13 +37,13 @@ services:
environment:
MF_COAP_ADAPTER_PORT: [Service HTTP port]
MF_NATS_URL: [NATS instance URL]
MF_THINGS_URL: [Things service URL]
MF_COAP_ADAPTER_LOG_LEVEL: [Service log level]
MF_COAP_ADAPTER_CLIENT_TLS: [Flag that indicates if TLS should be turned on]
MF_COAP_ADAPTER_CA_CERTS: [Path to trusted CAs in PEM format]
MF_COAP_ADAPTER_PING_PERIOD: [Hours between 1 and 24 to ping client with ACK message]
MF_JAEGER_URL: [Jaeger server URL]
MF_COAP_ADAPTER_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_THINGS_AUTH_GRPC_URL: [Things service Auth gRPC URL]
MF_THINGS_AUTH_GRPC_TIMEOUT: [Things service Auth gRPC request timeout in seconds]
```
Running this service outside of container requires working instance of the NATS service.
@ -62,7 +62,16 @@ make coap
make install
# set the environment variables and run the service
MF_THINGS_URL=[Things service URL] MF_NATS_URL=[NATS instance URL] MF_COAP_ADAPTER_PORT=[Service HTTP port] MF_COAP_ADAPTER_LOG_LEVEL=[Service log level] MF_COAP_ADAPTER_CLIENT_TLS=[Flag that indicates if TLS should be turned on] MF_COAP_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] MF_COAP_ADAPTER_PING_PERIOD: [Hours between 1 and 24 to ping client with ACK message] MF_JAEGER_URL=[Jaeger server URL] MF_COAP_ADAPTER_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] $GOBIN/mainflux-coap
MF_NATS_URL=[NATS instance URL] \
MF_COAP_ADAPTER_PORT=[Service HTTP port] \
MF_COAP_ADAPTER_LOG_LEVEL=[Service log level] \
MF_COAP_ADAPTER_CLIENT_TLS=[Flag that indicates if TLS should be turned on] \
MF_COAP_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_COAP_ADAPTER_PING_PERIOD: [Hours between 1 and 24 to ping client with ACK message] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_THINGS_AUTH_GRPC_URL=[Things service Auth gRPC URL] \
MF_THINGS_AUTH_GRPC_TIMEOUT=[Things service Auth gRPC request timeout in seconds] \
$GOBIN/mainflux-coap
```
## Usage

3
docker/addons/bootstrap/docker-compose.yml
View File

@ -47,9 +47,10 @@ services:
MF_BOOTSTRAP_DB_SSL_MODE: ${MF_BOOTSTRAP_DB_SSL_MODE}
MF_BOOTSTRAP_PORT: ${MF_BOOTSTRAP_PORT}
MF_SDK_BASE_URL: http://mainflux-things:${MF_THINGS_HTTP_PORT}
MF_AUTH_URL: authn:${MF_AUTHN_GRPC_PORT}
MF_THINGS_ES_URL: es-redis:${MF_REDIS_TCP_PORT}
MF_BOOTSTRAP_ES_URL: es-redis:${MF_REDIS_TCP_PORT}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_AUTHN_GRPC_URL: ${MF_AUTHN_GRPC_URL}
MF_AUTHN_GRPC_TIMMEOUT: ${MF_AUTHN_GRPC_TIMEOUT}
networks:
- docker_mainflux-base-net

3
docker/addons/cassandra-reader/docker-compose.yml
View File

@ -19,13 +19,14 @@ services:
restart: on-failure
environment:
MF_CASSANDRA_READER_LOG_LEVEL: ${MF_CASSANDRA_READER_LOG_LEVEL}
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_CASSANDRA_READER_PORT: ${MF_CASSANDRA_READER_PORT}
MF_CASSANDRA_READER_DB_CLUSTER: ${MF_CASSANDRA_READER_DB_CLUSTER}
MF_CASSANDRA_READER_DB_KEYSPACE: ${MF_CASSANDRA_READER_DB_KEYSPACE}
MF_CASSANDRA_READER_SERVER_CERT: ${MF_CASSANDRA_READER_SERVER_CERT}
MF_CASSANDRA_READER_SERVER_KEY: ${MF_CASSANDRA_READER_SERVER_KEY}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
ports:
- ${MF_CASSANDRA_READER_PORT}:${MF_CASSANDRA_READER_PORT}
networks:

5
docker/addons/influxdb-reader/docker-compose.yml
View File

@ -21,9 +21,8 @@ services:
restart: on-failure
environment:
MF_INFLUX_READER_LOG_LEVEL: debug
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_INFLUX_READER_PORT: ${MF_INFLUX_READER_PORT}
MF_INFLUX_READER_DB_NAME: ${MF_INFLUX_READER_DB_NAME}
MF_INFLUX_READER_DB: ${MF_INFLUX_READER_DB}
MF_INFLUX_READER_DB_HOST: mainflux-influxdb
MF_INFLUX_READER_DB_PORT: ${MF_INFLUX_READER_DB_PORT}
MF_INFLUX_READER_DB_USER: ${MF_INFLUX_READER_DB_USER}
@ -31,6 +30,8 @@ services:
MF_INFLUX_READER_SERVER_CERT: ${MF_INFLUX_READER_SERVER_CERT}
MF_INFLUX_READER_SERVER_KEY: ${MF_INFLUX_READER_SERVER_KEY}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
ports:
- ${MF_INFLUX_READER_PORT}:${MF_INFLUX_READER_PORT}
networks:

4
docker/addons/influxdb-writer/docker-compose.yml
View File

@ -22,7 +22,7 @@ services:
container_name: mainflux-influxdb
restart: on-failure
environment:
INFLUXDB_DB: ${MF_INFLUX_WRITER_DB_NAME}
INFLUXDB_DB: ${MF_INFLUX_WRITER_DB}
INFLUXDB_ADMIN_USER: ${MF_INFLUX_WRITER_DB_USER}
INFLUXDB_ADMIN_PASSWORD: ${MF_INFLUX_WRITER_DB_PASS}
networks:
@ -44,7 +44,7 @@ services:
MF_INFLUX_WRITER_PORT: ${MF_INFLUX_WRITER_PORT}
MF_INFLUX_WRITER_BATCH_SIZE: ${MF_INFLUX_WRITER_BATCH_SIZE}
MF_INFLUX_WRITER_BATCH_TIMEOUT: ${MF_INFLUX_WRITER_BATCH_TIMEOUT}
MF_INFLUX_WRITER_DB_NAME: ${MF_INFLUX_WRITER_DB_NAME}
MF_INFLUX_WRITER_DB: ${MF_INFLUX_WRITER_DB}
MF_INFLUX_WRITER_DB_HOST: mainflux-influxdb
MF_INFLUX_WRITER_DB_PORT: ${MF_INFLUX_WRITER_DB_PORT}
MF_INFLUX_WRITER_DB_USER: ${MF_INFLUX_WRITER_DB_USER}

5
docker/addons/mongodb-reader/docker-compose.yml
View File

@ -20,14 +20,15 @@ services:
restart: on-failure
environment:
MF_MONGO_READER_LOG_LEVEL: ${MF_MONGO_READER_LOG_LEVEL}
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_MONGO_READER_PORT: ${MF_MONGO_READER_PORT}
MF_MONGO_READER_DB_NAME: ${MF_MONGO_READER_DB_NAME}
MF_MONGO_READER_DB: ${MF_MONGO_READER_DB}
MF_MONGO_READER_DB_HOST: mongodb
MF_MONGO_READER_DB_PORT: ${MF_MONGO_READER_DB_PORT}
MF_MONGO_READER_SERVER_CERT: ${MF_MONGO_READER_SERVER_CERT}
MF_MONGO_READER_SERVER_KEY: ${MF_MONGO_READER_SERVER_KEY}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
ports:
- ${MF_MONGO_READER_PORT}:${MF_MONGO_READER_PORT}
networks:

4
docker/addons/mongodb-writer/docker-compose.yml
View File

@ -24,7 +24,7 @@ services:
container_name: mainflux-mongodb
restart: on-failure
environment:
MONGO_INITDB_DATABASE: ${MF_MONGO_WRITER_DB_NAME}
MONGO_INITDB_DATABASE: ${MF_MONGO_WRITER_DB}
ports:
- ${MF_MONGO_WRITER_DB_PORT}:${MF_MONGO_WRITER_DB_PORT}
networks:
@ -43,7 +43,7 @@ services:
MF_MONGO_WRITER_LOG_LEVEL: ${MF_MONGO_WRITER_LOG_LEVEL}
MF_NATS_URL: ${MF_NATS_URL}
MF_MONGO_WRITER_PORT: ${MF_MONGO_WRITER_PORT}
MF_MONGO_WRITER_DB_NAME: ${MF_MONGO_WRITER_DB_NAME}
MF_MONGO_WRITER_DB: ${MF_MONGO_WRITER_DB}
MF_MONGO_WRITER_DB_HOST: mongodb
MF_MONGO_WRITER_DB_PORT: ${MF_MONGO_WRITER_DB_PORT}
ports:

5
docker/addons/postgres-reader/docker-compose.yml
View File

@ -19,7 +19,6 @@ services:
container_name: mainflux-postgres-reader
restart: on-failure
environment:
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_POSTGRES_READER_LOG_LEVEL: ${MF_POSTGRES_READER_LOG_LEVEL}
MF_POSTGRES_READER_PORT: ${MF_POSTGRES_READER_PORT}
MF_POSTGRES_READER_CLIENT_TLS: ${MF_POSTGRES_READER_CLIENT_TLS}
@ -28,12 +27,14 @@ services:
MF_POSTGRES_READER_DB_PORT: ${MF_POSTGRES_READER_DB_PORT}
MF_POSTGRES_READER_DB_USER: ${MF_POSTGRES_READER_DB_USER}
MF_POSTGRES_READER_DB_PASS: ${MF_POSTGRES_READER_DB_PASS}
MF_POSTGRES_READER_DB_NAME: ${MF_POSTGRES_READER_DB_NAME}
MF_POSTGRES_READER_DB: ${MF_POSTGRES_READER_DB}
MF_POSTGRES_READER_DB_SSL_MODE: ${MF_POSTGRES_READER_DB_SSL_MODE}
MF_POSTGRES_READER_DB_SSL_CERT: ${MF_POSTGRES_READER_DB_SSL_CERT}
MF_POSTGRES_READER_DB_SSL_KEY: ${MF_POSTGRES_READER_DB_SSL_KEY}
MF_POSTGRES_READER_DB_SSL_ROOT_CERT: ${MF_POSTGRES_READER_DB_SSL_ROOT_CERT}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
ports:
- ${MF_POSTGRES_READER_PORT}:${MF_POSTGRES_READER_PORT}
networks:

4
docker/addons/postgres-writer/docker-compose.yml
View File

@ -25,7 +25,7 @@ services:
environment:
POSTGRES_USER: ${MF_POSTGRES_WRITER_DB_USER}
POSTGRES_PASSWORD: ${MF_POSTGRES_WRITER_DB_PASS}
POSTGRES_DB: ${MF_POSTGRES_WRITER_DB_NAME}
POSTGRES_DB: ${MF_POSTGRES_WRITER_DB}
networks:
- docker_mainflux-base-net
volumes:
@ -45,7 +45,7 @@ services:
MF_POSTGRES_WRITER_DB_PORT: ${MF_POSTGRES_WRITER_DB_PORT}
MF_POSTGRES_WRITER_DB_USER: ${MF_POSTGRES_WRITER_DB_USER}
MF_POSTGRES_WRITER_DB_PASS: ${MF_POSTGRES_WRITER_DB_PASS}
MF_POSTGRES_WRITER_DB_NAME: ${MF_POSTGRES_WRITER_DB_NAME}
MF_POSTGRES_WRITER_DB: ${MF_POSTGRES_WRITER_DB}
MF_POSTGRES_WRITER_DB_SSL_MODE: ${MF_POSTGRES_WRITER_DB_SSL_MODE}
MF_POSTGRES_WRITER_DB_SSL_CERT: ${MF_POSTGRES_WRITER_DB_SSL_CERT}
MF_POSTGRES_WRITER_DB_SSL_KEY: ${MF_POSTGRES_WRITER_DB_SSL_KEY}

9
docker/addons/twins/docker-compose.yml
View File

@ -23,7 +23,7 @@ services:
container_name: mainflux-twins-db
restart: on-failure
environment:
MONGO_INITDB_DATABASE: ${MF_TWINS_DB_NAME}
MONGO_INITDB_DATABASE: ${MF_TWINS_DB}
ports:
- ${MF_TWINS_DB_PORT}:${MF_TWINS_DB_PORT}
networks:
@ -39,15 +39,14 @@ services:
environment:
MF_TWINS_LOG_LEVEL: ${MF_TWINS_LOG_LEVEL}
MF_TWINS_HTTP_PORT: ${MF_TWINS_HTTP_PORT}
MF_TWINS_DB_NAME: ${MF_TWINS_DB_NAME}
MF_TWINS_DB: ${MF_TWINS_DB}
MF_TWINS_DB_HOST: ${MF_TWINS_DB_HOST}
MF_TWINS_DB_PORT: ${MF_TWINS_DB_PORT}
MF_TWINS_THING_ID: ${MF_TWINS_THING_ID}
MF_TWINS_THING_KEY: ${MF_TWINS_THING_KEY}
MF_TWINS_CHANNEL_ID: ${MF_TWINS_CHANNEL_ID}
MF_NATS_URL: ${MF_NATS_URL}
MF_AUTHN_URL: authn:${MF_AUTHN_GRPC_PORT}
MF_TWINS_MQTT_URL: ${MF_TWINS_MQTT_URL}
MF_AUTHN_GRPC_URL: ${MF_AUTHN_GRPC_URL}
MF_AUTHN_GRPC_TIMEOUT: ${MF_AUTHN_GRPC_TIMEOUT}
ports:
- ${MF_TWINS_HTTP_PORT}:${MF_TWINS_HTTP_PORT}
networks:

20
docker/docker-compose.yml
View File

@ -134,7 +134,8 @@ services:
MF_EMAIL_FROM_NAME: ${MF_EMAIL_FROM_NAME}
MF_EMAIL_TEMPLATE: ${MF_EMAIL_TEMPLATE}
MF_TOKEN_RESET_ENDPOINT: ${MF_TOKEN_RESET_ENDPOINT}
MF_AUTHN_URL: authn:${MF_AUTHN_GRPC_PORT}
MF_AUTHN_GRPC_URL: ${MF_AUTHN_GRPC_URL}
MF_AUTHN_GRPC_TIMEOUT: ${MF_AUTHN_GRPC_TIMEOUT}
ports:
- ${MF_USERS_HTTP_PORT}:${MF_USERS_HTTP_PORT}
networks:
@ -181,9 +182,10 @@ services:
MF_THINGS_HTTP_PORT: ${MF_THINGS_HTTP_PORT}
MF_THINGS_AUTH_HTTP_PORT: ${MF_THINGS_AUTH_HTTP_PORT}
MF_THINGS_AUTH_GRPC_PORT: ${MF_THINGS_AUTH_GRPC_PORT}
MF_AUTH_URL: authn:${MF_AUTHN_GRPC_PORT}
MF_THINGS_SECRET: ${MF_THINGS_SECRET}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_AUTHN_GRPC_URL: ${MF_AUTHN_GRPC_URL}
MF_AUTHN_GRPC_TIMEOUT: ${MF_AUTHN_GRPC_TIMEOUT}
ports:
- ${MF_THINGS_HTTP_PORT}:${MF_THINGS_HTTP_PORT}
- ${MF_THINGS_AUTH_HTTP_PORT}:${MF_THINGS_AUTH_HTTP_PORT}
@ -228,12 +230,13 @@ services:
MF_MQTT_ADAPTER_WS_PORT: ${MF_MQTT_ADAPTER_WS_PORT}
MF_MQTT_ADAPTER_ES_URL: es-redis:${MF_REDIS_TCP_PORT}
MF_NATS_URL: ${MF_NATS_URL}
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_MQTT_ADAPTER_MQTT_TARGET_HOST: vernemq
MF_MQTT_ADAPTER_MQTT_TARGET_PORT: ${MF_MQTT_BROKER_PORT}
MF_MQTT_ADAPTER_WS_TARGET_HOST: vernemq
MF_MQTT_ADAPTER_WS_TARGET_PORT: ${MF_MQTT_BROKER_WS_PORT}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
networks:
- mainflux-base-net
@ -249,8 +252,9 @@ services:
MF_WS_ADAPTER_LOG_LEVEL: ${MF_WS_ADAPTER_LOG_LEVEL}
MF_WS_ADAPTER_PORT: ${MF_WS_ADAPTER_PORT}
MF_NATS_URL: ${MF_NATS_URL}
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
ports:
- ${MF_WS_ADAPTER_PORT}:${MF_WS_ADAPTER_PORT}
networks:
@ -267,8 +271,9 @@ services:
MF_HTTP_ADAPTER_LOG_LEVEL: debug
MF_HTTP_ADAPTER_PORT: ${MF_HTTP_ADAPTER_PORT}
MF_NATS_URL: ${MF_NATS_URL}
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
ports:
- ${MF_HTTP_ADAPTER_PORT}:${MF_HTTP_ADAPTER_PORT}
networks:
@ -294,8 +299,9 @@ services:
MF_COAP_ADAPTER_LOG_LEVEL: ${MF_COAP_ADAPTER_LOG_LEVEL}
MF_COAP_ADAPTER_PORT: ${MF_COAP_ADAPTER_PORT}
MF_NATS_URL: ${MF_NATS_URL}
MF_THINGS_URL: things:${MF_THINGS_AUTH_GRPC_PORT}
MF_JAEGER_URL: ${MF_JAEGER_URL}
MF_THINGS_AUTH_GRPC_URL: ${MF_THINGS_AUTH_GRPC_URL}
MF_THINGS_AUTH_GRPC_TIMEOUT: ${MF_THINGS_AUTH_GRPC_TIMEOUT}
ports:
- ${MF_COAP_ADAPTER_PORT}:${MF_COAP_ADAPTER_PORT}/udp
- ${MF_COAP_ADAPTER_PORT}:${MF_COAP_ADAPTER_PORT}/tcp

1
docker/nginx/entrypoint.sh
View File

@ -12,7 +12,6 @@ fi
envsubst '
${MF_USERS_HTTP_PORT}
${MF_THINGS_HTTP_PORT}
${MF_THINGS_HTTP_PORT}
${MF_HTTP_ADAPTER_PORT}
${MF_WS_ADAPTER_PORT}' < /etc/nginx/nginx.conf.template > /etc/nginx/nginx.conf

7
env.go
View File

@ -5,13 +5,6 @@ package mainflux
import (
"os"
"github.com/nats-io/nats.go"
)
const (
// DefNatsURL default NATS message broker URL
DefNatsURL = nats.DefaultURL
)
// Env reads specified environment variable. If no value has been found,

2
go.sum
View File

@ -168,8 +168,6 @@ github.com/mainflux/mainflux v0.0.0-20200314190902-c91fe0d45353/go.mod h1:yijZGL
github.com/mainflux/mainflux v0.0.0-20200324100741-6ffa916ed229/go.mod h1:mde8cQhTPjLulu2pn/x8OgQ2S++lDufS+ODE93zuHjY=
github.com/mainflux/mproxy v0.1.3 h1:/JNnxgo/03wSpbwQH2+WE1AzgMWaSKogTVXblh18x5s=
github.com/mainflux/mproxy v0.1.3/go.mod h1:/BdaBfgye1GNCD+eat4ipFamy9IEVRH5nhZS0yEShVg=
github.com/mainflux/mproxy v0.1.4 h1:g7LhJgA+BXlgaZeyLj505aD5DCsrix79TEiLWuHJZd4=
github.com/mainflux/mproxy v0.1.4/go.mod h1:MBLtv/RvhT8QsmXz4g3GxkRaP8PqlVqBWeqvw9QmO8k=
github.com/mainflux/mproxy v0.1.5 h1:a0zKiUyuTDld2TwCuhrOFtUvotcvSfwJMuh/JcrqC6I=
github.com/mainflux/mproxy v0.1.5/go.mod h1:MBLtv/RvhT8QsmXz4g3GxkRaP8PqlVqBWeqvw9QmO8k=
github.com/mainflux/mproxy v0.1.6 h1:In0JkSO7/XU7KdyqCzFfDQW3OOvNZc1tsrq1/aWRkRE=

33
http/README.md
View File

@ -8,16 +8,16 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|--------------------------------|------------------------------------------------|-----------------------|
| MF_HTTP_ADAPTER_LOG_LEVEL | Log level for the HTTP Adapter | error |
| MF_HTTP_ADAPTER_PORT | Service HTTP port | 8180 |
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_THINGS_URL | Things service URL | localhost:8181 |
| MF_HTTP_ADAPTER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_HTTP_ADAPTER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_HTTP_ADAPTER_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| Variable | Description | Default |
|--------------------------------|-----------------------------------------------------|-----------------------|
| MF_HTTP_ADAPTER_LOG_LEVEL | Log level for the HTTP Adapter | error |
| MF_HTTP_ADAPTER_PORT | Service HTTP port | 8180 |
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_HTTP_ADAPTER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_HTTP_ADAPTER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_THINGS_AUTH_GRPC_URL | Things service Auth gRPC URL | localhost:8181 |
| MF_THINGS_AUTH_GRPC_TIMEOUT | Things service Auth gRPC request timeout in seconds | 1 |
## Deployment
@ -33,13 +33,13 @@ services:
ports:
- [host machine port]:8180
environment:
MF_THINGS_URL: [Things service URL]
MF_NATS_URL: [NATS instance URL]
MF_HTTP_ADAPTER_LOG_LEVEL: [HTTP Adapter Log Level]
MF_HTTP_ADAPTER_PORT: [Service HTTP port]
MF_HTTP_ADAPTER_CA_CERTS: [Path to trusted CAs in PEM format]
MF_JAEGER_URL: [Jaeger server URL]
MF_HTTP_ADAPTER_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_THINGS_AUTH_GRPC_URL: [Things service Auth gRPC URL]
MF_THINGS_AUTH_GRPC_TIMEOUT: [Things service Auth gRPC request timeout in seconds]
```
To start the service outside of the container, execute the following shell script:
@ -57,7 +57,14 @@ make http
make install
# set the environment variables and run the service
MF_THINGS_URL=[Things service URL] MF_NATS_URL=[NATS instance URL] MF_HTTP_ADAPTER_LOG_LEVEL=[HTTP Adapter Log Level] MF_HTTP_ADAPTER_PORT=[Service HTTP port] MF_HTTP_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] MF_JAEGER_URL=[Jaeger server URL] MF_HTTP_ADAPTER_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] $GOBIN/mainflux-http
MF_NATS_URL=[NATS instance URL] \
MF_HTTP_ADAPTER_LOG_LEVEL=[HTTP Adapter Log Level] \
MF_HTTP_ADAPTER_PORT=[Service HTTP port] \
MF_HTTP_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_THINGS_AUTH_GRPC_URL=[Things service Auth gRPC URL] \
MF_THINGS_AUTH_GRPC_TIMEOUT=[Things service Auth gRPC request timeout in seconds] \
$GOBIN/mainflux-http
```
Setting `MF_HTTP_ADAPTER_CA_CERTS` expects a file in PEM format of trusted CAs. This will enable TLS against the Things gRPC endpoint trusting only those CAs that are provided.

2
opcua/README.md
View File

@ -13,7 +13,7 @@ default values.
| Variable | Description | Default |
|----------------------------------|----------------------------------------|----------------------------|
| MF_OPCUA_ADAPTER_HTTP_PORT | Service HTTP port | 8188 |
| MF_OPCUA_ADAPTER_HTTP_PORT | Service HTTP port | 8180 |
| MF_OPCUA_ADAPTER_LOG_LEVEL | Service Log level | error |
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_OPCUA_ADAPTER_INTERVAL_MS | OPC-UA Server Interval in milliseconds | 1000 |

46
readers/cassandra/README.md
View File

@ -8,21 +8,21 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|------------------------------------|------------------------------------------------|----------------|
| MF_CASSANDRA_READER_PORT | Service HTTP port | 8180 |
| MF_CASSANDRA_READER_DB_CLUSTER | Cassandra cluster comma separated addresses | 127.0.0.1 |
| MF_CASSANDRA_READER_DB_KEYSPACE | Cassandra keyspace name | mainflux |
| MF_CASSANDRA_READER_DB_USERNAME | Cassandra DB username | |
| MF_CASSANDRA_READER_DB_PASSWORD | Cassandra DB password | |
| MF_CASSANDRA_READER_DB_PORT | Cassandra DB port | 9042 |
| MF_THINGS_URL | Things service URL | localhost:8181 |
| MF_CASSANDRA_READER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_CASSANDRA_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_CASSANDRA_READER_SERVER_CERT | Path to server certificate in pem format | |
| MF_CASSANDRA_READER_SERVER_KEY | Path to server key in pem format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_CASSANDRA_READER_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| Variable | Description | Default |
|---------------------------------|-----------------------------------------------------|----------------|
| MF_CASSANDRA_READER_PORT | Service HTTP port | 8180 |
| MF_CASSANDRA_READER_DB_CLUSTER | Cassandra cluster comma separated addresses | 127.0.0.1 |
| MF_CASSANDRA_READER_DB_USER | Cassandra DB username | |
| MF_CASSANDRA_READER_DB_PASS | Cassandra DB password | |
| MF_CASSANDRA_READER_DB_KEYSPACE | Cassandra keyspace name | messages |
| MF_CASSANDRA_READER_DB_PORT | Cassandra DB port | 9042 |
| MF_CASSANDRA_READER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_CASSANDRA_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_CASSANDRA_READER_SERVER_CERT | Path to server certificate in pem format | |
| MF_CASSANDRA_READER_SERVER_KEY | Path to server key in pem format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_THINGS_AUTH_GRPC_URL | Things service Auth gRPC URL | localhost:8181 |
| MF_THINGS_AUTH_GRPC_TIMEOUT | Things service Auth gRPC request timeout in seconds | 1 |
## Deployment
@ -36,19 +36,19 @@ default values.
- [Service HTTP port]
restart: on-failure
environment:
MF_THINGS_URL: [Things service URL]
MF_CASSANDRA_READER_PORT: [Service HTTP port]
MF_CASSANDRA_READER_DB_CLUSTER: [Cassandra cluster comma separated addresses]
MF_CASSANDRA_READER_DB_KEYSPACE: [Cassandra keyspace name]
MF_CASSANDRA_READER_DB_USERNAME: [Cassandra DB username]
MF_CASSANDRA_READER_DB_PASSWORD: [Cassandra DB password]
MF_CASSANDRA_READER_DB_USER: [Cassandra DB username]
MF_CASSANDRA_READER_DB_PASS: [Cassandra DB password]
MF_CASSANDRA_READER_DB_PORT: [Cassandra DB port]
MF_CASSANDRA_READER_CLIENT_TLS: [Flag that indicates if TLS should be turned on]
MF_CASSANDRA_READER_CA_CERTS: [Path to trusted CAs in PEM format]
MF_CASSANDRA_READER_SERVER_CERT: [String path to server cert in pem format]
MF_CASSANDRA_READER_SERVER_KEY: [String path to server key in pem format]
MF_JAEGER_URL: [Jaeger server URL]
MF_CASSANDRA_READER_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_THINGS_AUTH_GRPC_URL: [Things service Auth gRPC URL]
MF_THINGS_AUTH_GRPC_TIMEOUT: [Things service Auth gRPC request timeout in seconds]
ports:
- [host machine port]:[configured HTTP port]
```
@ -68,19 +68,19 @@ make cassandra-reader
make install
# Set the environment variables and run the service
MF_THINGS_URL=[Things service URL] \
MF_CASSANDRA_READER_PORT=[Service HTTP port] \
MF_CASSANDRA_READER_DB_CLUSTER=[Cassandra cluster comma separated addresses] \
MF_CASSANDRA_READER_DB_KEYSPACE=[Cassandra keyspace name] \
MF_CASSANDRA_READER_DB_USERNAME=[Cassandra DB username] \
MF_CASSANDRA_READER_DB_PASSWORD=[Cassandra DB password] \
MF_CASSANDRA_READER_DB_USER=[Cassandra DB username] \
MF_CASSANDRA_READER_DB_PASS=[Cassandra DB password] \
MF_CASSANDRA_READER_DB_PORT=[Cassandra DB port] \
MF_CASSANDRA_READER_CLIENT_TLS=[Flag that indicates if TLS should be turned on] \
MF_CASSANDRA_READER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_CASSANDRA_READER_SERVER_CERT=[Path to server pem certificate file] \
MF_CASSANDRA_READER_SERVER_KEY=[Path to server pem key file] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_CASSANDRA_READER_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] \
MF_THINGS_AUTH_GRPC_URL=[Things service Auth gRPC URL] \
MF_THINGS_AUTH_GRPC_TIMEOUT=[Things service Auth gRPC request timeout in seconds] \
$GOBIN/mainflux-cassandra-reader
```

8
readers/cassandra/init.go
View File

@ -11,8 +11,8 @@ import (
type DBConfig struct {
Hosts []string
Keyspace string
Username string
Password string
User string
Pass string
Port int
}
@ -22,8 +22,8 @@ func Connect(cfg DBConfig) (*gocql.Session, error) {
cluster.Keyspace = cfg.Keyspace
cluster.Consistency = gocql.Quorum
cluster.Authenticator = gocql.PasswordAuthenticator{
Username: cfg.Username,
Password: cfg.Password,
Username: cfg.User,
Password: cfg.Pass,
}
cluster.Port = cfg.Port

41
readers/influxdb/README.md
View File

@ -8,20 +8,21 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|---------------------------------|------------------------------------------------|----------------|
| MF_INFLUX_READER_PORT | Service HTTP port | 8180 |
| MF_INFLUX_READER_DB_NAME | InfluxDB database name | mainflux |
| MF_INFLUX_READER_DB_HOST | InfluxDB host | localhost |
| MF_INFLUX_READER_DB_PORT | Default port of InfluxDB database | 8086 |
| MF_INFLUX_READER_DB_USER | Default user of InfluxDB database | mainflux |
| MF_INFLUX_READER_DB_PASS | Default password of InfluxDB user | mainflux |
| MF_INFLUX_READER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_INFLUX_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_INFLUX_READER_SERVER_CERT | Path to server certificate in pem format | |
| MF_INFLUX_READER_SERVER_KEY | Path to server key in pem format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_INFLUX_READER_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| Variable | Description | Default |
|------------------------------|-----------------------------------------------------|----------------|
| MF_INFLUX_READER_PORT | Service HTTP port | 8180 |
| MF_INFLUX_READER_DB_HOST | InfluxDB host | localhost |
| MF_INFLUX_READER_DB_PORT | Default port of InfluxDB database | 8086 |
| MF_INFLUX_READER_DB_USER | Default user of InfluxDB database | mainflux |
| MF_INFLUX_READER_DB_PASS | Default password of InfluxDB user | mainflux |
| MF_INFLUX_READER_DB | InfluxDB database name | messages |
| MF_INFLUX_READER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_INFLUX_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_INFLUX_READER_SERVER_CERT | Path to server certificate in pem format | |
| MF_INFLUX_READER_SERVER_KEY | Path to server key in pem format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_THINGS_AUTH_GRPC_URL | Things service Auth gRPC URL | localhost:8181 |
| MF_THINGS_AUTH_GRPC_TIMEOUT | Things service Auth gRPC request timeout in seconds | 1 |
## Deployment
@ -32,9 +33,8 @@ default values.
container_name: [instance name]
restart: on-failure
environment:
MF_THINGS_URL: [Things service URL]
MF_INFLUX_READER_PORT: [Service HTTP port]
MF_INFLUX_READER_DB_NAME: [InfluxDB name]
MF_INFLUX_READER_DB: [InfluxDB name]
MF_INFLUX_READER_DB_HOST: [InfluxDB host]
MF_INFLUX_READER_DB_PORT: [InfluxDB port]
MF_INFLUX_READER_DB_USER: [InfluxDB admin user]
@ -44,7 +44,8 @@ default values.
MF_INFLUX_READER_SERVER_CERT: [String path to server cert in pem format]
MF_INFLUX_READER_SERVER_KEY: [String path to server key in pem format]
MF_JAEGER_URL: [Jaeger server URL]
MF_INFLUX_READER_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_THINGS_AUTH_GRPC_URL: [Things service Auth gRPC URL]
MF_THINGS_AUTH_GRPC_TIMEOUT: [Things service Auth gRPC request timeout in seconds]
ports:
- [host machine port]:[configured HTTP port]
```
@ -64,9 +65,8 @@ make influxdb-reader
make install
# Set the environment variables and run the service
MF_THINGS_URL=[Things service URL] \
MF_INFLUX_READER_PORT=[Service HTTP port] \
MF_INFLUX_READER_DB_NAME=[InfluxDB database name] \
MF_INFLUX_READER_DB=[InfluxDB database name] \
MF_INFLUX_READER_DB_HOST=[InfluxDB database host] \
MF_INFLUX_READER_DB_PORT=[InfluxDB database port] \
MF_INFLUX_READER_DB_USER=[InfluxDB admin user] \
@ -76,7 +76,8 @@ MF_INFLUX_READER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_INFLUX_READER_SERVER_CERT=[Path to server pem certificate file] \
MF_INFLUX_READER_SERVER_KEY=[Path to server pem key file] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_INFLUX_READER_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] \
MF_THINGS_AUTH_GRPC_URL=[Things service Auth gRPC URL] \
MF_THINGS_AURH_GRPC_TIMEOUT=[Things service Auth gRPC request timeout in seconds] \
$GOBIN/mainflux-influxdb
```

38
readers/mongodb/README.md
View File

@ -8,19 +8,19 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|--------------------------------|------------------------------------------------|----------------|
| MF_THINGS_URL | Things service URL | localhost:8181 |
| MF_MONGO_READER_PORT | Service HTTP port | 8180 |
| MF_MONGO_READER_DB_NAME | MongoDB database name | mainflux |
| MF_MONGO_READER_DB_HOST | MongoDB database host | localhost |
| MF_MONGO_READER_DB_PORT | MongoDB database port | 27017 |
| MF_MONGO_READER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_MONGO_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_MONGO_SERVER_CERT | Path to server certificate in pem format | |
| MF_MONGO_SERVER_KEY | Path to server key in pem format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_MONGO_READER_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| Variable | Description | Default |
|-----------------------------|-----------------------------------------------------|----------------|
| MF_MONGO_READER_PORT | Service HTTP port | 8180 |
| MF_MONGO_READER_DB | MongoDB database name | messages |
| MF_MONGO_READER_DB_HOST | MongoDB database host | localhost |
| MF_MONGO_READER_DB_PORT | MongoDB database port | 27017 |
| MF_MONGO_READER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_MONGO_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_MONGO_SERVER_CERT | Path to server certificate in pem format | |
| MF_MONGO_SERVER_KEY | Path to server key in pem format | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_THINGS_AUTH_GRPC_URL | Things service Auth gRPC URL | localhost:8181 |
| MF_THINGS_AUTH_GRPC_TIMEOUT | Things service Auth gRPC request timeout in seconds | 1 |
## Deployment
@ -33,9 +33,8 @@ default values.
- [Service HTTP port]
restart: on-failure
environment:
MF_THINGS_URL: [Things service URL]
MF_MONGO_READER_PORT: [Service HTTP port]
MF_MONGO_READER_DB_NAME: [MongoDB name]
MF_MONGO_READER_DB: [MongoDB name]
MF_MONGO_READER_DB_HOST: [MongoDB host]
MF_MONGO_READER_DB_PORT: [MongoDB port]
MF_MONGO_READER_CLIENT_TLS: [Flag that indicates if TLS should be turned on]
@ -43,7 +42,8 @@ default values.
MF_MONGO_READER_SERVER_CERT: [String path to server cert in pem format]
MF_MONGO_READER_SERVER_KEY: [String path to server key in pem format]
MF_JAEGER_URL: [Jaeger server URL]
MF_MONGO_READER_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_THINGS_AUTH_GRPC_URL: [Things service Auth gRPC URL]
MF_THINGS_AUTH_GRPC_TIMEOUT: [Things service Auth gRPC request timeout in seconds]
ports:
- [host machine port]:[configured HTTP port]
```
@ -63,9 +63,8 @@ make mongodb-reader
make install
# Set the environment variables and run the service
MF_THINGS_URL=[Things service URL] \
MF_MONGO_READER_PORT=[Service HTTP port] \
MF_MONGO_READER_DB_NAME=[MongoDB database name] \
MF_MONGO_READER_DB=[MongoDB database name] \
MF_MONGO_READER_DB_HOST=[MongoDB database host] \
MF_MONGO_READER_DB_PORT=[MongoDB database port] \
MF_MONGO_READER_CLIENT_TLS=[Flag that indicates if TLS should be turned on] \
@ -73,7 +72,8 @@ MF_MONGO_READER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_MONGO_READER_SERVER_CERT=[Path to server pem certificate file] \
MF_MONGO_READER_SERVER_KEY=[Path to server pem key file] \
MF_MONGO_READER_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] \
MF_THINGS_AUTH_GRPC_URL=[Things service Auth gRPC URL] \
MF_THINGS_AUTH_GRPC_TIMEOUT=[Things service Auth gRPC request timeout in seconds] \
$GOBIN/mainflux-mongodb-reader
```

61
readers/postgres/README.md
View File

@ -8,24 +8,24 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|-------------------------------------|----------------------------------------|----------------|
| MF_THINGS_URL | Things service URL | things:8183 |
| MF_POSTGRES_READER_LOG_LEVEL | Service log level | debug |
| MF_POSTGRES_READER_PORT | Service HTTP port | 9204 |
| MF_POSTGRES_READER_CLIENT_TLS | TLS mode flag | false |
| MF_POSTGRES_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_POSTGRES_READER_DB_HOST | Postgres DB host | postgres |
| MF_POSTGRES_READER_DB_PORT | Postgres DB port | 5432 |
| MF_POSTGRES_READER_DB_USER | Postgres user | mainflux |
| MF_POSTGRES_READER_DB_PASS | Postgres password | mainflux |
| MF_POSTGRES_READER_DB_NAME | Postgres database name | messages |
| MF_POSTGRES_READER_DB_SSL_MODE | Postgres SSL mode | disabled |
| MF_POSTGRES_READER_DB_SSL_CERT | Postgres SSL certificate path | "" |
| MF_POSTGRES_READER_DB_SSL_KEY | Postgres SSL key | "" |
| MF_POSTGRES_READER_DB_SSL_ROOT_CERT | Postgres SSL root certificate path | "" |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_POSTGRES_READER_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| Variable | Description | Default |
|-------------------------------------|---------------------------------------------|----------------|
| MF_POSTGRES_READER_LOG_LEVEL | Service log level | debug |
| MF_POSTGRES_READER_PORT | Service HTTP port | 8180 |
| MF_POSTGRES_READER_CLIENT_TLS | TLS mode flag | false |
| MF_POSTGRES_READER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_POSTGRES_READER_DB_HOST | Postgres DB host | postgres |
| MF_POSTGRES_READER_DB_PORT | Postgres DB port | 5432 |
| MF_POSTGRES_READER_DB_USER | Postgres user | mainflux |
| MF_POSTGRES_READER_DB_PASS | Postgres password | mainflux |
| MF_POSTGRES_READER_DB | Postgres database name | messages |
| MF_POSTGRES_READER_DB_SSL_MODE | Postgres SSL mode | disabled |
| MF_POSTGRES_READER_DB_SSL_CERT | Postgres SSL certificate path | "" |
| MF_POSTGRES_READER_DB_SSL_KEY | Postgres SSL key | "" |
| MF_POSTGRES_READER_DB_SSL_ROOT_CERT | Postgres SSL root certificate path | "" |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_THINGS_AUTH_GRPC_URL | Things service Auth gRPC URL | localhost:8181 |
| MF_THINGS_AUTH_GRPC_TIMEOUT | Things service Auth gRPC timeout in seconds | 1 |
## Deployment
@ -46,15 +46,16 @@ default values.
MF_POSTGRES_READER_DB_PORT: [Postgres port]
MF_POSTGRES_READER_DB_USER: [Postgres user]
MF_POSTGRES_READER_DB_PASS: [Postgres password]
MF_POSTGRES_READER_DB_NAME: [Postgres database name]
MF_POSTGRES_READER_DB: [Postgres database name]
MF_POSTGRES_READER_DB_SSL_MODE: [Postgres SSL mode]
MF_POSTGRES_READER_DB_SSL_CERT: [Postgres SSL cert]
MF_POSTGRES_READER_DB_SSL_KEY: [Postgres SSL key]
MF_POSTGRES_READER_DB_SSL_ROOT_CERT: [Postgres SSL Root cert]
MF_JAEGER_URL: [Jaeger server URL]
MF_POSTGRES_READER_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_THINGS_AUTH_GRPC_URL: [Things service Auth gRPC URL]
MF_THINGS_AUTH_GRPC_TIMEOUT: [Things service Auth gRPC request timeout in seconds]
ports:
- 8903:8903
- 8180:8180
networks:
- docker_mainflux-base-net
```
@ -74,7 +75,23 @@ make postgres-writer
make install
# Set the environment variables and run the service
MF_THINGS_URL=[Things service URL] MF_POSTGRES_READER_LOG_LEVEL=[Service log level] MF_POSTGRES_READER_PORT=[Service HTTP port] MF_POSTGRES_READER_CLIENT_TLS =[TLS mode flag] MF_POSTGRES_READER_CA_CERTS=[Path to trusted CAs in PEM format] MF_POSTGRES_READER_DB_HOST=[Postgres host] MF_POSTGRES_READER_DB_PORT=[Postgres port] MF_POSTGRES_READER_DB_USER=[Postgres user] MF_POSTGRES_READER_DB_PASS=[Postgres password] MF_POSTGRES_READER_DB_NAME=[Postgres database name] MF_POSTGRES_READER_DB_SSL_MODE=[Postgres SSL mode] MF_POSTGRES_READER_DB_SSL_CERT=[Postgres SSL cert] MF_POSTGRES_READER_DB_SSL_KEY=[Postgres SSL key] MF_POSTGRES_READER_DB_SSL_ROOT_CERT=[Postgres SSL Root cert] MF_JAEGER_URL=[Jaeger server URL] MF_POSTGRES_READER_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] $GOBIN/mainflux-postgres-reader
MF_POSTGRES_READER_LOG_LEVEL=[Service log level] \
MF_POSTGRES_READER_PORT=[Service HTTP port] \
MF_POSTGRES_READER_CLIENT_TLS =[TLS mode flag] \
MF_POSTGRES_READER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_POSTGRES_READER_DB_HOST=[Postgres host] \
MF_POSTGRES_READER_DB_PORT=[Postgres port] \
MF_POSTGRES_READER_DB_USER=[Postgres user] \
MF_POSTGRES_READER_DB_PASS=[Postgres password] \
MF_POSTGRES_READER_DB=[Postgres database name] \
MF_POSTGRES_READER_DB_SSL_MODE=[Postgres SSL mode] \
MF_POSTGRES_READER_DB_SSL_CERT=[Postgres SSL cert] \
MF_POSTGRES_READER_DB_SSL_KEY=[Postgres SSL key] \
MF_POSTGRES_READER_DB_SSL_ROOT_CERT=[Postgres SSL Root cert] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_THINGS_AUTH_GRPC_URL=[Things service Auth GRPC URL] \
MF_THINGS_AUTH_GRPC_TIMEOUT=[Things service Auth gRPC request timeout in seconds] \
$GOBIN/mainflux-postgres-reader
```
## Usage

8
scripts/run.sh
View File

@ -48,22 +48,22 @@ MF_THINGS_LOG_LEVEL=info MF_THINGS_HTTP_PORT=8182 MF_THINGS_AUTH_GRPC_PORT=8183
###
# HTTP
###
MF_HTTP_ADAPTER_LOG_LEVEL=info MF_HTTP_ADAPTER_PORT=8185 MF_THINGS_URL=localhost:8183 $BUILD_DIR/mainflux-http &
MF_HTTP_ADAPTER_LOG_LEVEL=info MF_HTTP_ADAPTER_PORT=8185 MF_THINGS_AUTH_GRPC_URL=localhost:8183 $BUILD_DIR/mainflux-http &
###
# WS
###
MF_WS_ADAPTER_LOG_LEVEL=info MF_WS_ADAPTER_PORT=8186 MF_THINGS_URL=localhost:8183 $BUILD_DIR/mainflux-ws &
MF_WS_ADAPTER_LOG_LEVEL=info MF_WS_ADAPTER_PORT=8186 MF_THINGS_AUTH_GRPC_URL=localhost:8183 $BUILD_DIR/mainflux-ws &
###
# MQTT
###
MF_MQTT_ADAPTER_LOG_LEVEL=info MF_THINGS_URL=localhost:8183 $BUILD_DIR/mainflux-mqtt &
MF_MQTT_ADAPTER_LOG_LEVEL=info MF_THINGS_AUTH_GRPC_URL=localhost:8183 $BUILD_DIR/mainflux-mqtt &
###
# CoAP
###
MF_COAP_ADAPTER_LOG_LEVEL=info MF_COAP_ADAPTER_PORT=5683 MF_THINGS_URL=localhost:8183 $BUILD_DIR/mainflux-coap &
MF_COAP_ADAPTER_LOG_LEVEL=info MF_COAP_ADAPTER_PORT=5683 MF_THINGS_AUTH_GRPC_URL=localhost:8183 $BUILD_DIR/mainflux-coap &
###
# AUTHN

49
things/README.md
View File

@ -36,16 +36,16 @@ default values.
| MF_THINGS_ES_URL | Event store URL | localhost:6379 |
| MF_THINGS_ES_PASS | Event store password | |
| MF_THINGS_ES_DB | Event store instance name | 0 |
| MF_THINGS_HTTP_PORT | Things service HTTP port | 8180 |
| MF_THINGS_AUTH_HTTP_PORT | Things service auth HTTP port | 8989 |
| MF_THINGS_AUTH_GRPC_PORT | Things service auth gRPC port | 8181 |
| MF_THINGS_HTTP_PORT | Things service HTTP port | 8182 |
| MF_THINGS_AUTH_HTTP_PORT | Things service Auth HTTP port | 8180 |
| MF_THINGS_AUTH_GRPC_PORT | Things service Auth gRPC port | 8181 |
| MF_THINGS_SERVER_CERT | Path to server certificate in pem format | |
| MF_THINGS_SERVER_KEY | Path to server key in pem format | |
| MF_USERS_URL | Users service URL | localhost:8181 |
| MF_THINGS_SINGLE_USER_EMAIL | User email for single user mode (no gRPC communication with users) | |
| MF_THINGS_SINGLE_USER_TOKEN | User token for single user mode that should be passed in auth header | |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_THINGS_USERS_TIMEOUT | Users gRPC request timeout in seconds | 1 |
| MF_AUTHN_GRPC_URL | AuthN service gRPC URL | localhost:8181 |
| MF_AUTHN_GRPC_TIMEOUT | AuthN service gRPC request timeout in seconds | 1 |
**Note** that if you want `things` service to have only one user locally, you should use `MF_THINGS_SINGLE_USER` env vars. By specifying these, you don't need `users` service in your deployment as it won't be used for authorization.
@ -81,17 +81,17 @@ services:
MF_THINGS_ES_URL: [Event store URL]
MF_THINGS_ES_PASS: [Event store password]
MF_THINGS_ES_DB: [Event store instance name]
MF_THINGS_HTTP_PORT: [Service HTTP port]
MF_THINGS_AUTH_HTTP_PORT: [Service auth HTTP port]
MF_THINGS_AUTH_GRPC_PORT: [Service auth gRPC port]
MF_THINGS_HTTP_PORT: [Things service HTTP port]
MF_THINGS_AUTH_HTTP_PORT: [Things service Auth HTTP port]
MF_THINGS_AUTH_GRPC_PORT: [Things service Auth gRPC port]
MF_THINGS_SERVER_CERT: [String path to server cert in pem format]
MF_THINGS_SERVER_KEY: [String path to server key in pem format]
MF_USERS_URL: [Users service URL]
MF_THINGS_SECRET: [String used for signing tokens]
MF_THINGS_SINGLE_USER_EMAIL: [User email for single user mode (no gRPC communication with users)]
MF_THINGS_SINGLE_USER_TOKEN: [User token for single user mode that should be passed in auth header]
MF_JAEGER_URL: [Jaeger server URL]
MF_THINGS_USERS_TIMEOUT: [Users gRPC request timeout in seconds]
MF_AUTHN_GRPC_URL: [AuthN service gRPC URL]
MF_AUTHN_GRPC_TIMEOUT: [AuthN service gRPC request timeout in seconds]
```
To start the service outside of the container, execute the following shell script:
@ -109,7 +109,34 @@ make things
make install
# set the environment variables and run the service
MF_THINGS_LOG_LEVEL=[Things log level] MF_THINGS_DB_HOST=[Database host address] MF_THINGS_DB_PORT=[Database host port] MF_THINGS_DB_USER=[Database user] MF_THINGS_DB_PASS=[Database password] MF_THINGS_DB=[Name of the database used by the service] MF_THINGS_DB_SSL_MODE=[SSL mode to connect to the database with] MF_THINGS_DB_SSL_CERT=[Path to the PEM encoded certificate file] MF_THINGS_DB_SSL_KEY=[Path to the PEM encoded key file] MF_THINGS_DB_SSL_ROOT_CERT=[Path to the PEM encoded root certificate file] MF_HTTP_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] MF_THINGS_CACHE_URL=[Cache database URL] MF_THINGS_CACHE_PASS=[Cache database password] MF_THINGS_CACHE_DB=[Cache instance name] MF_THINGS_ES_URL=[Event store URL] MF_THINGS_ES_PASS=[Event store password] MF_THINGS_ES_DB=[Event store instance name] MF_THINGS_HTTP_PORT=[Service HTTP port] MF_THINGS_AUTH_HTTP_PORT=[Service auth HTTP port] MF_THINGS_AUTH_GRPC_PORT=[Service auth gRPC port] MF_USERS_URL=[Users service URL] MF_THINGS_SERVER_CERT=[Path to server certificate] MF_THINGS_SERVER_KEY=[Path to server key] MF_THINGS_SINGLE_USER_EMAIL=[User email for single user mode (no gRPC communication with users)] MF_THINGS_SINGLE_USER_TOKEN=[User token for single user mode that should be passed in auth header] MF_JAEGER_URL=[Jaeger server URL] MF_THINGS_USERS_TIMEOUT=[Users gRPC request timeout in seconds] $GOBIN/mainflux-things
MF_THINGS_LOG_LEVEL=[Things log level] \
MF_THINGS_DB_HOST=[Database host address] \
MF_THINGS_DB_PORT=[Database host port] \
MF_THINGS_DB_USER=[Database user] \
MF_THINGS_DB_PASS=[Database password] \
MF_THINGS_DB=[Name of the database used by the service] \
MF_THINGS_DB_SSL_MODE=[SSL mode to connect to the database with] \
MF_THINGS_DB_SSL_CERT=[Path to the PEM encoded certificate file] \
MF_THINGS_DB_SSL_KEY=[Path to the PEM encoded key file] \
MF_THINGS_DB_SSL_ROOT_CERT=[Path to the PEM encoded root certificate file] \
MF_HTTP_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_THINGS_CACHE_URL=[Cache database URL] \
MF_THINGS_CACHE_PASS=[Cache database password] \
MF_THINGS_CACHE_DB=[Cache instance name] \
MF_THINGS_ES_URL=[Event store URL] \
MF_THINGS_ES_PASS=[Event store password] \
MF_THINGS_ES_DB=[Event store instance name] \
MF_THINGS_HTTP_PORT=[Things service HTTP port] \
MF_THINGS_AUTH_HTTP_PORT=[Things service Auth HTTP port] \
MF_THINGS_AUTH_GRPC_PORT=[Things service Auth gRPC port] \
MF_THINGS_SERVER_CERT=[Path to server certificate] \
MF_THINGS_SERVER_KEY=[Path to server key] \
MF_THINGS_SINGLE_USER_EMAIL=[User email for single user mode (no gRPC communication with users)] \
MF_THINGS_SINGLE_USER_TOKEN=[User token for single user mode that should be passed in auth header] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_AUTHN_GRPC_URL=[AuthN service gRPC URL] \
MF_AUTHN_GRPC_TIMEOUT=[AuthN service gRPC request timeout in seconds] \
$GOBIN/mainflux-things
```
Setting `MF_THINGS_CA_CERTS` expects a file in PEM format of trusted CAs. This will enable TLS against the Users gRPC endpoint trusting only those CAs that are provided.

36
twins/README.md
View File

@ -19,7 +19,7 @@ default values.
| MF_TWINS_SERVER_CERT | Path to server certificate in PEM format | |
| MF_TWINS_SERVER_KEY | Path to server key in PEM format | |
| MF_JAEGER_URL | Jaeger server URL | |
| MF_TWINS_DB_NAME | Database name | mainflux |
| MF_TWINS_DB | Database name | mainflux |
| MF_TWINS_DB_HOST | Database host address | localhost |
| MF_TWINS_DB_PORT | Database host port | 27017 |
| MF_TWINS_SINGLE_USER_EMAIL | User email for single user mode (no gRPC communication with users) | |
@ -30,10 +30,9 @@ default values.
| MF_TWINS_THING_ID | ID of thing representing twins service & mqtt user | |
| MF_TWINS_THING_KEY | Key of thing representing twins service & mqtt pass | |
| MF_TWINS_CHANNEL_ID | Mqtt notifications topic | |
| MF_NATS_URL | Mainflux NATS broker URL | nats://127.0.0.1:4222 |
| MF_AUTHN_GRPC_PORT | Authn service gRPC port | 8181 |
| MF_AUTHN_TIMEOUT | Authn gRPC request timeout in seconds | 1 |
| MF_AUTHN_URL | Authn service URL | localhost:8181 |
| MF_NATS_URL | Mainflux NATS broker URL | nats://localhost:4222 |
| MF_AUTHN_GRPC_URL | AuthN service gRPC URL | localhost:8181 |
| MF_AUTHN_GRPC_TIMEOUT | AuthN service gRPC request timeout in seconds | 1 |
## Deployment
@ -55,7 +54,7 @@ services:
MF_TWINS_SERVER_CERT: [String path to server cert in pem format]
MF_TWINS_SERVER_KEY: [String path to server key in pem format]
MF_JAEGER_URL: [Jaeger server URL]
MF_TWINS_DB_NAME: [Database name]
MF_TWINS_DB: [Database name]
MF_TWINS_DB_HOST: [Database host address]
MF_TWINS_DB_PORT: [Database host port]
MF_TWINS_SINGLE_USER_EMAIL: [User email for single user mode]
@ -67,9 +66,8 @@ services:
MF_TWINS_THING_KEY: [Key of thing representing twins service]
MF_TWINS_CHANNEL_ID: [Mqtt notifications topic]
MF_NATS_URL: [Mainflux NATS broker URL]
MF_AUTHN_GRPC_PORT: [Authn service gRPC port]
MF_AUTHN_TIMEOUT: [Authn gRPC request timeout in seconds]
MF_AUTHN_URL: [Authn service URL]
MF_AUTHN_GRPC_URL: [AuthN service gRPC URL]
MF_AUTHN_GRPC_TIMEOUT: [AuthN service gRPC request timeout in seconds]
```
To start the service outside of the container, execute the following shell script:
@ -87,7 +85,25 @@ make twins
make install
# set the environment variables and run the service
MF_TWINS_LOG_LEVEL: [Twins log level] MF_TWINS_HTTP_PORT: [Service HTTP port] MF_TWINS_SERVER_CERT: [String path to server cert in pem format] MF_TWINS_SERVER_KEY: [String path to server key in pem format] MF_JAEGER_URL: [Jaeger server URL] MF_TWINS_DB_NAME: [Database name] MF_TWINS_DB_HOST: [Database host address] MF_TWINS_DB_PORT: [Database host port] MF_TWINS_SINGLE_USER_EMAIL: [User email for single user mode] MF_TWINS_SINGLE_USER_TOKEN: [User token for single user mode] MF_TWINS_CLIENT_TLS: [Flag that indicates if TLS should be turned on] MF_TWINS_CA_CERTS: [Path to trusted CAs in PEM format] MF_TWINS_MQTT_URL: [Mqtt broker URL for twin CRUD and states] MF_TWINS_THING_ID: [ID of thing representing twins service] MF_TWINS_THING_KEY: [Key of thing representing twins service] MF_TWINS_CHANNEL_ID: [Mqtt notifications topic] MF_NATS_URL: [Mainflux NATS broker URL] MF_AUTHN_GRPC_PORT: [Authn service gRPC port] MF_AUTHN_TIMEOUT: [Authn gRPC request timeout in seconds] MF_AUTHN_URL: [Authn service URL] $GOBIN/mainflux-twins
MF_TWINS_LOG_LEVEL: [Twins log level] \
MF_TWINS_HTTP_PORT: [Service HTTP port] \
MF_TWINS_SERVER_CERT: [String path to server cert in pem format] \
MF_TWINS_SERVER_KEY: [String path to server key in pem format] \
MF_JAEGER_URL: [Jaeger server URL] MF_TWINS_DB: [Database name] \
MF_TWINS_DB_HOST: [Database host address] \
MF_TWINS_DB_PORT: [Database host port] \
MF_TWINS_SINGLE_USER_EMAIL: [User email for single user mode] \
MF_TWINS_SINGLE_USER_TOKEN: [User token for single user mode] \
MF_TWINS_CLIENT_TLS: [Flag that indicates if TLS should be turned on] \
MF_TWINS_CA_CERTS: [Path to trusted CAs in PEM format] \
MF_TWINS_MQTT_URL: [Mqtt broker URL for twin CRUD and states] \
MF_TWINS_THING_ID: [ID of thing representing twins service] \
MF_TWINS_THING_KEY: [Key of thing representing twins service] \
MF_TWINS_CHANNEL_ID: [Mqtt notifications topic] \
MF_NATS_URL: [Mainflux NATS broker URL] \
MF_AUTHN_GRPC_URL: [AuthN service gRPC URL] \
MF_AUTHN_GRPC_TIMEOUT: [AuthN service gRPC request timeout in seconds] \
$GOBIN/mainflux-twins
```
## Usage

19
writers/cassandra/README.md
View File

@ -15,8 +15,8 @@ default values.
| MF_CASSANDRA_WRITER_PORT | Service HTTP port | 8180 |
| MF_CASSANDRA_WRITER_DB_CLUSTER | Cassandra cluster comma separated addresses | 127.0.0.1 |
| MF_CASSANDRA_WRITER_DB_KEYSPACE | Cassandra keyspace name | mainflux |
| MF_CASSANDRA_WRITER_DB_USERNAME | Cassandra DB username | |
| MF_CASSANDRA_WRITER_DB_PASSWORD | Cassandra DB password | |
| MF_CASSANDRA_WRITER_DB_USER | Cassandra DB username | |
| MF_CASSANDRA_WRITER_DB_PASS | Cassandra DB password | |
| MF_CASSANDRA_WRITER_DB_PORT | Cassandra DB port | 9042 |
| MF_CASSANDRA_WRITER_SUBJECTS_CONFIG | Configuration file path with subjects list | /config/subjects.toml |
## Deployment
@ -35,8 +35,8 @@ default values.
MF_CASSANDRA_WRITER_PORT: [Service HTTP port]
MF_CASSANDRA_WRITER_DB_CLUSTER: [Cassandra cluster comma separated addresses]
MF_CASSANDRA_WRITER_DB_KEYSPACE: [Cassandra keyspace name]
MF_CASSANDRA_WRITER_DB_USERNAME: [Cassandra DB username]
MF_CASSANDRA_WRITER_DB_PASSWORD: [Cassandra DB password]
MF_CASSANDRA_WRITER_DB_USER: [Cassandra DB username]
MF_CASSANDRA_WRITER_DB_PASS: [Cassandra DB password]
MF_CASSANDRA_WRITER_DB_PORT: [Cassandra DB port]
MF_CASSANDRA_WRITER_SUBJECTS_CONFIG: [Configuration file path with subjects list]
ports:
@ -60,7 +60,16 @@ make cassandra-writer
make install
# Set the environment variables and run the service
MF_NATS_URL=[NATS instance URL] MF_CASSANDRA_WRITER_LOG_LEVEL=[Cassandra writer log level] MF_CASSANDRA_WRITER_PORT=[Service HTTP port] MF_CASSANDRA_WRITER_DB_CLUSTER=[Cassandra cluster comma separated addresses] MF_CASSANDRA_WRITER_DB_KEYSPACE=[Cassandra keyspace name] MF_CASSANDRA_READER_DB_USERNAME=[Cassandra DB username] MF_CASSANDRA_READER_DB_PASSWORD=[Cassandra DB password] MF_CASSANDRA_READER_DB_PORT=[Cassandra DB port] MF_CASSANDRA_WRITER_SUBJECTS_CONFIG=[Configuration file path with subjects list] $GOBIN/mainflux-cassandra-writer
MF_NATS_URL=[NATS instance URL] \
MF_CASSANDRA_WRITER_LOG_LEVEL=[Cassandra writer log level] \
MF_CASSANDRA_WRITER_PORT=[Service HTTP port] \
MF_CASSANDRA_WRITER_DB_CLUSTER=[Cassandra cluster comma separated addresses] \
MF_CASSANDRA_WRITER_DB_KEYSPACE=[Cassandra keyspace name] \
MF_CASSANDRA_READER_DB_USER=[Cassandra DB username] \
MF_CASSANDRA_READER_DB_PASS=[Cassandra DB password] \
MF_CASSANDRA_READER_DB_PORT=[Cassandra DB port] \
MF_CASSANDRA_WRITER_SUBJECTS_CONFIG=[Configuration file path with subjects list] \
$GOBIN/mainflux-cassandra-writer
```
### Using docker-compose

8
writers/cassandra/init.go
View File

@ -27,8 +27,8 @@ const table = `CREATE TABLE IF NOT EXISTS messages (
type DBConfig struct {
Hosts []string
Keyspace string
Username string
Password string
User string
Pass string
Port int
}
@ -38,8 +38,8 @@ func Connect(cfg DBConfig) (*gocql.Session, error) {
cluster.Keyspace = cfg.Keyspace
cluster.Consistency = gocql.Quorum
cluster.Authenticator = gocql.PasswordAuthenticator{
Username: cfg.Username,
Password: cfg.Password,
Username: cfg.User,
Password: cfg.Pass,
}
cluster.Port = cfg.Port

26
writers/influxdb/README.md
View File

@ -8,17 +8,17 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|-----------------------------------|-----------------------------------------------------------|------------------------|
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_INFLUX_WRITER_LOG_LEVEL | Log level for InfluxDB writer (debug, info, warn, error) | error |
| MF_INFLUX_WRITER_PORT | Service HTTP port | 8180 |
| MF_INFLUX_WRITER_DB_NAME | InfluxDB database name | mainflux |
| MF_INFLUX_WRITER_DB_HOST | InfluxDB host | localhost |
| MF_INFLUX_WRITER_DB_PORT | Default port of InfluxDB database | 8086 |
| MF_INFLUX_WRITER_DB_USER | Default user of InfluxDB database | mainflux |
| MF_INFLUX_WRITER_DB_PASS | Default password of InfluxDB user | mainflux |
| MF_INFLUX_WRITER_SUBJECTS_CONFIG | Configuration file path with subjects list | /config/subjects.toml |
| Variable | Description | Default |
|----------------------------------|----------------------------------------------------------|------------------------|
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_INFLUX_WRITER_LOG_LEVEL | Log level for InfluxDB writer (debug, info, warn, error) | error |
| MF_INFLUX_WRITER_PORT | Service HTTP port | 8180 |
| MF_INFLUX_WRITER_DB_HOST | InfluxDB host | localhost |
| MF_INFLUX_WRITER_DB_PORT | Default port of InfluxDB database | 8086 |
| MF_INFLUX_WRITER_DB_USER | Default user of InfluxDB database | mainflux |
| MF_INFLUX_WRITER_DB_PASS | Default password of InfluxDB user | mainflux |
| MF_INFLUX_WRITER_DB | InfluxDB database name | messages |
| MF_INFLUX_WRITER_SUBJECTS_CONFIG | Configuration file path with subjects list | /config/subjects.toml |
## Deployment
@ -34,7 +34,7 @@ default values.
MF_NATS_URL: [NATS instance URL]
MF_INFLUX_WRITER_LOG_LEVEL: [Influx writer log level]
MF_INFLUX_WRITER_PORT: [Service HTTP port]
MF_INFLUX_WRITER_DB_NAME: [InfluxDB name]
MF_INFLUX_WRITER_DB: [InfluxDB name]
MF_INFLUX_WRITER_DB_HOST: [InfluxDB host]
MF_INFLUX_WRITER_DB_PORT: [InfluxDB port]
MF_INFLUX_WRITER_DB_USER: [InfluxDB admin user]
@ -61,7 +61,7 @@ make influxdb
make install
# Set the environment variables and run the service
MF_NATS_URL=[NATS instance URL] MF_INFLUX_WRITER_LOG_LEVEL=[Influx writer log level] MF_INFLUX_WRITER_PORT=[Service HTTP port] MF_INFLUX_WRITER_DB_NAME=[InfluxDB database name] MF_INFLUX_WRITER_DB_HOST=[InfluxDB database host] MF_INFLUX_WRITER_DB_PORT=[InfluxDB database port] MF_INFLUX_WRITER_DB_USER=[InfluxDB admin user] MF_INFLUX_WRITER_DB_PASS=[InfluxDB admin password] MF_INFLUX_WRITER_SUBJECTS_CONFIG=[Configuration file path with subjects list] $GOBIN/mainflux-influxdb
MF_NATS_URL=[NATS instance URL] MF_INFLUX_WRITER_LOG_LEVEL=[Influx writer log level] MF_INFLUX_WRITER_PORT=[Service HTTP port] MF_INFLUX_WRITER_DB=[InfluxDB database name] MF_INFLUX_WRITER_DB_HOST=[InfluxDB database host] MF_INFLUX_WRITER_DB_PORT=[InfluxDB database port] MF_INFLUX_WRITER_DB_USER=[InfluxDB admin user] MF_INFLUX_WRITER_DB_PASS=[InfluxDB admin password] MF_INFLUX_WRITER_SUBJECTS_CONFIG=[Configuration file path with subjects list] $GOBIN/mainflux-influxdb
```
### Using docker-compose

22
writers/mongodb/README.md
View File

@ -8,15 +8,15 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|----------------------------------|---------------------------------------------|------------------------|
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_MONGO_WRITER_LOG_LEVEL | Log level for MongoDB writer | error |
| MF_MONGO_WRITER_PORT | Service HTTP port | 8180 |
| MF_MONGO_WRITER_DB_NAME | Default MongoDB database name | mainflux |
| MF_MONGO_WRITER_DB_HOST | Default MongoDB database host | localhost |
| MF_MONGO_WRITER_DB_PORT | Default MongoDB database port | 27017 |
| MF_MONGO_WRITER_SUBJECTS_CONFIG | Configuration file path with subjects list | /config/subjects.toml |
| Variable | Description | Default |
|---------------------------------|--------------------------------------------|------------------------|
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_MONGO_WRITER_LOG_LEVEL | Log level for MongoDB writer | error |
| MF_MONGO_WRITER_PORT | Service HTTP port | 8180 |
| MF_MONGO_WRITER_DB | Default MongoDB database name | messages |
| MF_MONGO_WRITER_DB_HOST | Default MongoDB database host | localhost |
| MF_MONGO_WRITER_DB_PORT | Default MongoDB database port | 27017 |
| MF_MONGO_WRITER_SUBJECTS_CONFIG | Configuration file path with subjects list | /config/subjects.toml |
## Deployment
@ -35,7 +35,7 @@ default values.
MF_NATS_URL: [NATS instance URL]
MF_MONGO_WRITER_LOG_LEVEL: [MongoDB writer log level]
MF_MONGO_WRITER_PORT: [Service HTTP port]
MF_MONGO_WRITER_DB_NAME: [MongoDB name]
MF_MONGO_WRITER_DB: [MongoDB name]
MF_MONGO_WRITER_DB_HOST: [MongoDB host]
MF_MONGO_WRITER_DB_PORT: [MongoDB port]
MF_MONGO_WRITER_SUBJETCS_CONFIG: [Configuration file path with subjects list]
@ -60,7 +60,7 @@ make mongodb-writer
make install
# Set the environment variables and run the service
MF_NATS_URL=[NATS instance URL] MF_MONGO_WRITER_LOG_LEVEL=[MongoDB writer log level] MF_MONGO_WRITER_PORT=[Service HTTP port] MF_MONGO_WRITER_DB_NAME=[MongoDB database name] MF_MONGO_WRITER_DB_HOST=[MongoDB database host] MF_MONGO_WRITER_DB_PORT=[MongoDB database port] MF_MONGO_WRITER_SUBJETCS_CONFIG=[Configuration file path with subjetcs list] $GOBIN/mainflux-mongodb-writer
MF_NATS_URL=[NATS instance URL] MF_MONGO_WRITER_LOG_LEVEL=[MongoDB writer log level] MF_MONGO_WRITER_PORT=[Service HTTP port] MF_MONGO_WRITER_DB=[MongoDB database name] MF_MONGO_WRITER_DB_HOST=[MongoDB database host] MF_MONGO_WRITER_DB_PORT=[MongoDB database port] MF_MONGO_WRITER_SUBJETCS_CONFIG=[Configuration file path with subjetcs list] $GOBIN/mainflux-mongodb-writer
```
## Usage

47
writers/postgres/README.md
View File

@ -8,21 +8,21 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|--------------------------------------|---------------------------------------------|------------------------|
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_POSTGRES_WRITER_LOG_LEVEL | Service log level | error |
| MF_POSTGRES_WRITER_PORT | Service HTTP port | 9104 |
| MF_POSTGRES_WRITER_DB_HOST | Postgres DB host | postgres |
| MF_POSTGRES_WRITER_DB_PORT | Postgres DB port | 5432 |
| MF_POSTGRES_WRITER_DB_USER | Postgres user | mainflux |
| MF_POSTGRES_WRITER_DB_PASS | Postgres password | mainflux |
| MF_POSTGRES_WRITER_DB_NAME | Postgres database name | messages |
| MF_POSTGRES_WRITER_DB_SSL_MODE | Postgres SSL mode | disabled |
| MF_POSTGRES_WRITER_DB_SSL_CERT | Postgres SSL certificate path | "" |
| MF_POSTGRES_WRITER_DB_SSL_KEY | Postgres SSL key | "" |
| MF_POSTGRES_WRITER_DB_SSL_ROOT_CERT | Postgres SSL root certificate path | "" |
| MF_POSTGRES_WRITER_SUBJECTS_CONFIG | Configuration file path with subjects list | /config/subjects.toml |
| Variable | Description | Default |
|-------------------------------------|---------------------------------------------|------------------------|
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_POSTGRES_WRITER_LOG_LEVEL | Service log level | error |
| MF_POSTGRES_WRITER_PORT | Service HTTP port | 9104 |
| MF_POSTGRES_WRITER_DB_HOST | Postgres DB host | postgres |
| MF_POSTGRES_WRITER_DB_PORT | Postgres DB port | 5432 |
| MF_POSTGRES_WRITER_DB_USER | Postgres user | mainflux |
| MF_POSTGRES_WRITER_DB_PASS | Postgres password | mainflux |
| MF_POSTGRES_WRITER_DB | Postgres database name | messages |
| MF_POSTGRES_WRITER_DB_SSL_MODE | Postgres SSL mode | disabled |
| MF_POSTGRES_WRITER_DB_SSL_CERT | Postgres SSL certificate path | "" |
| MF_POSTGRES_WRITER_DB_SSL_KEY | Postgres SSL key | "" |
| MF_POSTGRES_WRITER_DB_SSL_ROOT_CERT | Postgres SSL root certificate path | "" |
| MF_POSTGRES_WRITER_SUBJECTS_CONFIG | Configuration file path with subjects list | /config/subjects.toml |
## Deployment
@ -43,7 +43,7 @@ default values.
MF_POSTGRES_WRITER_DB_PORT: [Postgres port]
MF_POSTGRES_WRITER_DB_USER: [Postgres user]
MF_POSTGRES_WRITER_DB_PASS: [Postgres password]
MF_POSTGRES_WRITER_DB_NAME: [Postgres database name]
MF_POSTGRES_WRITER_DB: [Postgres database name]
MF_POSTGRES_WRITER_DB_SSL_MODE: [Postgres SSL mode]
MF_POSTGRES_WRITER_DB_SSL_CERT: [Postgres SSL cert]
MF_POSTGRES_WRITER_DB_SSL_KEY: [Postgres SSL key]
@ -72,7 +72,20 @@ make postgres-writer
make install
# Set the environment variables and run the service
MF_NATS_URL=[NATS instance URL] MF_POSTGRES_WRITER_LOG_LEVEL=[Service log level] MF_POSTGRES_WRITER_PORT=[Service HTTP port] MF_POSTGRES_WRITER_DB_HOST=[Postgres host] MF_POSTGRES_WRITER_DB_PORT=[Postgres port] MF_POSTGRES_WRITER_DB_USER=[Postgres user] MF_POSTGRES_WRITER_DB_PASS=[Postgres password] MF_POSTGRES_WRITER_DB_NAME=[Postgres database name] MF_POSTGRES_WRITER_DB_SSL_MODE=[Postgres SSL mode] MF_POSTGRES_WRITER_DB_SSL_CERT=[Postgres SSL cert] MF_POSTGRES_WRITER_DB_SSL_KEY=[Postgres SSL key] MF_POSTGRES_WRITER_DB_SSL_ROOT_CERT=[Postgres SSL Root cert] MF_POSTGRES_WRITER_SUBJECTS_CONFIG=[Configuration file path with subjects list] $GOBIN/mainflux-postgres-writer
MF_NATS_URL=[NATS instance URL] \
MF_POSTGRES_WRITER_LOG_LEVEL=[Service log level] \
MF_POSTGRES_WRITER_PORT=[Service HTTP port] \
MF_POSTGRES_WRITER_DB_HOST=[Postgres host] \
MF_POSTGRES_WRITER_DB_PORT=[Postgres port] \
MF_POSTGRES_WRITER_DB_USER=[Postgres user] \
MF_POSTGRES_WRITER_DB_PASS=[Postgres password] \
MF_POSTGRES_WRITER_DB=[Postgres database name] \
MF_POSTGRES_WRITER_DB_SSL_MODE=[Postgres SSL mode] \
MF_POSTGRES_WRITER_DB_SSL_CERT=[Postgres SSL cert] \
MF_POSTGRES_WRITER_DB_SSL_KEY=[Postgres SSL key] \
MF_POSTGRES_WRITER_DB_SSL_ROOT_CERT=[Postgres SSL Root cert] \
MF_POSTGRES_WRITER_SUBJECTS_CONFIG=[Configuration file path with subjects list] \
$GOBIN/mainflux-postgres-writer
```
## Usage

34
ws/README.md
View File

@ -8,16 +8,16 @@ The service is configured using the environment variables presented in the
following table. Note that any unset variables will be replaced with their
default values.
| Variable | Description | Default |
|------------------------------|------------------------------------------------|-----------------------|
| MF_WS_ADAPTER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_WS_ADAPTER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_WS_ADAPTER_LOG_LEVEL | Log level for the WS Adapter | error |
| MF_WS_ADAPTER_PORT | Service WS port | 8180 |
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_THINGS_URL | Things service URL | localhost:8181 |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_WS_ADAPTER_THINGS_TIMEOUT | Things gRPC request timeout in seconds | 1 |
| Variable | Description | Default |
|------------------------------|-----------------------------------------------------|-----------------------|
| MF_WS_ADAPTER_CLIENT_TLS | Flag that indicates if TLS should be turned on | false |
| MF_WS_ADAPTER_CA_CERTS | Path to trusted CAs in PEM format | |
| MF_WS_ADAPTER_LOG_LEVEL | Log level for the WS Adapter | error |
| MF_WS_ADAPTER_PORT | Service WS port | 8180 |
| MF_NATS_URL | NATS instance URL | nats://localhost:4222 |
| MF_JAEGER_URL | Jaeger server URL | localhost:6831 |
| MF_THINGS_AUTH_GRPC_URL | Things service Auth gRPC URL | localhost:8181 |
| MF_THINGS_AUTH_GRPC_TIMEOUT | Things service Auth gRPC request timeout in seconds | 1 |
## Deployment
@ -33,14 +33,14 @@ services:
ports:
- [host machine port]:[configured port]
environment:
MF_THINGS_URL: [Things service URL]
MF_NATS_URL: [NATS instance URL]
MF_WS_ADAPTER_PORT: [Service WS port]
MF_WS_ADAPTER_LOG_LEVEL: [WS adapter log level]
MF_WS_ADAPTER_CLIENT_TLS: [Flag that indicates if TLS should be turned on]
MF_WS_ADAPTER_CA_CERTS: [Path to trusted CAs in PEM format]
MF_JAEGER_URL: [Jaeger server URL]
MF_WS_ADAPTER_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
MF_THINGS_AUTH_GRPC_URL: [Things service Auth gRPC URL]
MF_THINGS_AUTH_GRPC_TIMEOUT: [Things service Auth gRPC request timeout in seconds]
```
To start the service outside of the container, execute the following shell script:
@ -58,7 +58,15 @@ make ws
make install
# set the environment variables and run the service
MF_THINGS_URL=[Things service URL] MF_NATS_URL=[NATS instance URL] MF_WS_ADAPTER_PORT=[Service WS port] MF_WS_ADAPTER_LOG_LEVEL=[WS adapter log level] MF_WS_ADAPTER_CLIENT_TLS=[Flag that indicates if TLS should be turned on] MF_WS_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] MF_JAEGER_URL=[Jaeger server URL] MF_WS_ADAPTER_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] $GOBIN/mainflux-ws
MF_NATS_URL=[NATS instance URL] \
MF_WS_ADAPTER_PORT=[Service WS port] \
MF_WS_ADAPTER_LOG_LEVEL=[WS adapter log level] \
MF_WS_ADAPTER_CLIENT_TLS=[Flag that indicates if TLS should be turned on] \
MF_WS_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_THINGS_AUTH_GRPC_URL=[Things service Auth gRPC URL] \
MF_THINGS_AUTH_GRPC_TIMEOUT=[Things service Auth gRPC request timeout in seconds] \
$GOBIN/mainflux-ws
```
## Usage