fix: add missing ThingsURL back (#440)

Signed-off-by: hykuan <hykuan1126@gmail.com>

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+Pull request title should be `MF-XXX - description` or `NOISSUE - description` where XXX is ID of issue that this PR relate to.
+Please review the [CONTRIBUTING.md](./CONTRIBUTING.md) file for detailed contributing guidelines.
+
+### What does this do?
+
+### Which issue(s) does this PR fix/relate to?
+Put here `Resolves #XXX` to auto-close the issue that your PR fixes (if such)
+
+### List any changes that modify/break current functionality
+
+### Have you included tests for your changes?
+
+### Did you document any new/modified functionality?
+
+### Notes

.gitignore

@@ -1,4 +1,4 @@
 build
-*.pb.go
 
 site/
+

Gopkg.lock

@@ -3,80 +3,137 @@
 
 [[projects]]
   branch = "master"
+  digest = "1:6da51e5ec493ad2b44cb04129e2d0a068c8fb9bd6cb5739d199573558696bb94"
   name = "github.com/Azure/go-ansiterm"
   packages = [
     ".",
-    "winterm"
+    "winterm",
   ]
+  pruneopts = "UT"
   revision = "d6e3b3328b783f23731bc4d058875b0371ff8109"
 
 [[projects]]
+  digest = "1:bf42be3cb1519bf8018dfd99720b1005ee028d947124cab3ccf965da59381df6"
   name = "github.com/Microsoft/go-winio"
   packages = ["."]
+  pruneopts = "UT"
   revision = "7da180ee92d8bd8bb8c37fc560e673e6557c392f"
   version = "v0.4.7"
 
 [[projects]]
   branch = "master"
+  digest = "1:3721a10686511b80c052323423f0de17a8c06d417dbdd3b392b1578432a33aae"
   name = "github.com/Nvveen/Gotty"
   packages = ["."]
+  pruneopts = "UT"
   revision = "cd527374f1e5bff4938207604a14f2e38a9cf512"
 
 [[projects]]
+  digest = "1:320e7ead93de9fd2b0e59b50fd92a4d50c1f8ab455d96bc2eb083267453a9709"
   name = "github.com/asaskevich/govalidator"
   packages = ["."]
+  pruneopts = "UT"
   revision = "ccb8e960c48f04d6935e72476ae4a51028f9e22f"
   version = "v9"
 
 [[projects]]
   branch = "master"
+  digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d"
   name = "github.com/beorn7/perks"
   packages = ["quantile"]
+  pruneopts = "UT"
   revision = "3a771d992973f24aa725d07868b467d1ddfceafb"
 
 [[projects]]
+  branch = "master"
+  digest = "1:35ac403a135b8a138870950720be1f0399e0a48387d4b5cca841b0ed8cf7a40b"
+  name = "github.com/buger/jsonparser"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2cac668e8456b4284edb0715e17e2af02d3ec993"
+
+[[projects]]
+  digest = "1:2209584c0f7c9b68c23374e659357ab546e1b70eec2761f03280f69a8fd23d77"
   name = "github.com/cenkalti/backoff"
   packages = ["."]
+  pruneopts = "UT"
   revision = "2ea60e5f094469f9e65adb9cd103795b73ae743e"
   version = "v2.0.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:24310b2d7f85873dde28d21687a40f7eba239970827c6a5d68cb529c9803de3a"
   name = "github.com/cisco/senml"
   packages = ["."]
+  pruneopts = "UT"
   revision = "448c9510575e1dd6f780cb10addbad998cf80418"
 
 [[projects]]
   branch = "master"
+  digest = "1:fc8dbcc2a5de7c093e167828ebbdf551641761d2ad75431d3a167d467a264115"
   name = "github.com/containerd/continuity"
   packages = ["pathdriver"]
+  pruneopts = "UT"
   revision = "c6cef34830231743494fe2969284df7b82cc0ad0"
 
 [[projects]]
+  digest = "1:a2c1d0e43bd3baaa071d1b9ed72c27d78169b2b269f71c105ac4ba34b1be4a39"
   name = "github.com/davecgh/go-spew"
   packages = ["spew"]
+  pruneopts = "UT"
   revision = "346938d642f2ec3594ed81d874461961cd0faa76"
   version = "v1.1.0"
 
 [[projects]]
+  branch = "master"
+  digest = "1:ca71cdedcb487a361fe2588afeb3d373c0dfe21feaac229270fd6de234bd3c5e"
+  name = "github.com/dereulenspiegel/coap-mux"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e137e310a99955be01d60b2237da89153ea40987"
+
+[[projects]]
+  digest = "1:76dc72490af7174349349838f2fe118996381b31ea83243812a97e5a0fd5ed55"
   name = "github.com/dgrijalva/jwt-go"
   packages = ["."]
+  pruneopts = "UT"
   revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e"
   version = "v3.2.0"
 
 [[projects]]
+  digest = "1:87dcb59127512b84097086504c16595cf8fef35b9e0bfca565dfc06e198158d7"
   name = "github.com/docker/go-connections"
   packages = ["nat"]
+  pruneopts = "UT"
   revision = "3ede32e2033de7505e6500d6c868c2b9ed9f169d"
   version = "v0.3.0"
 
 [[projects]]
+  digest = "1:6f82cacd0af5921e99bf3f46748705239b36489464f4529a1589bc895764fb18"
   name = "github.com/docker/go-units"
   packages = ["."]
+  pruneopts = "UT"
   revision = "47565b4f722fb6ceae66b95f853feed578a4a51c"
   version = "v0.3.3"
 
 [[projects]]
+  branch = "master"
+  digest = "1:f77ee3cd73cbf60434b4f72ec46a66773c555d46764399735b5f9a28505f3ece"
+  name = "github.com/dustin/go-coap"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ddcc80675fa42611359d91a6dfa5aa57fb90e72b"
+
+[[projects]]
+  digest = "1:865079840386857c809b72ce300be7580cb50d3d3129ce11bf9aa6ca2bc1934a"
+  name = "github.com/fatih/color"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
+  version = "v1.7.0"
+
+[[projects]]
+  digest = "1:3fd00c9248f27f544a9bff7254adf110e1c791d067522025fcaac7528b55087a"
   name = "github.com/go-kit/kit"
   packages = [
     "endpoint",
@@ -85,85 +142,184 @@
     "metrics/internal/lv",
     "metrics/prometheus",
     "transport/grpc",
-    "transport/http"
+    "transport/http",
   ]
+  pruneopts = "UT"
   revision = "4dc7be5d2d12881735283bcab7352178e190fc71"
   version = "v0.6.0"
 
 [[projects]]
+  digest = "1:31a18dae27a29aa074515e43a443abfd2ba6deb6d69309d8d7ce789c45f34659"
   name = "github.com/go-logfmt/logfmt"
   packages = ["."]
+  pruneopts = "UT"
   revision = "390ab7935ee28ec6b286364bba9b4dd6410cb3d5"
   version = "v0.3.0"
 
 [[projects]]
+  digest = "1:7c2fd446293ff7799cc496d3446e674ee67902d119f244de645caf95dff1bb98"
+  name = "github.com/go-redis/redis"
+  packages = [
+    ".",
+    "internal",
+    "internal/consistenthash",
+    "internal/hashtag",
+    "internal/pool",
+    "internal/proto",
+    "internal/singleflight",
+    "internal/util",
+  ]
+  pruneopts = "UT"
+  revision = "f3bba01df2026fc865f7782948845db9cf44cf23"
+  version = "v6.14.1"
+
+[[projects]]
+  digest = "1:c4a2528ccbcabf90f9f3c464a5fc9e302d592861bbfd0b7135a7de8a943d0406"
   name = "github.com/go-stack/stack"
   packages = ["."]
+  pruneopts = "UT"
   revision = "259ab82a6cad3992b4e21ff5cac294ccb06474bc"
   version = "v1.7.0"
 
 [[projects]]
+  digest = "1:8dfa0b1b7c4b7398d46340aef0f2a58aad5a75959eeeb79e023ab826f0c7f7f0"
   name = "github.com/go-zoo/bone"
   packages = ["."]
+  pruneopts = "UT"
   revision = "fd0aebc74e908868b09ac140fb5a53cb363884c1"
   version = "1.2"
 
 [[projects]]
+  branch = "master"
+  digest = "1:cf497f8273ddb581939f686791154c7d349322f01a8cade02f21504c036abc5f"
+  name = "github.com/gocql/gocql"
+  packages = [
+    ".",
+    "internal/lru",
+    "internal/murmur",
+    "internal/streams",
+  ]
+  pruneopts = "UT"
+  revision = "651d6b1f343c6e168e45d119dcfe8f71e5bafb32"
+
+[[projects]]
+  digest = "1:9a688317f3231e0175b3429033f44411906c0ce119361b7b5019d01375f8cff7"
   name = "github.com/gogo/protobuf"
   packages = ["proto"]
+  pruneopts = "UT"
   revision = "1adfc126b41513cc696b209667c8656ea7aac67c"
   version = "v1.0.0"
 
 [[projects]]
+  digest = "1:17fe264ee908afc795734e8c4e63db2accabaf57326dbf21763a7d6b86096260"
   name = "github.com/golang/protobuf"
   packages = [
     "proto",
     "ptypes",
     "ptypes/any",
     "ptypes/duration",
-    "ptypes/timestamp"
+    "ptypes/timestamp",
   ]
+  pruneopts = "UT"
   revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265"
   version = "v1.1.0"
 
 [[projects]]
+  branch = "master"
+  digest = "1:4a0c6bb4805508a6287675fac876be2ac1182539ca8a32468d8128882e9d5009"
+  name = "github.com/golang/snappy"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2e65f85255dbc3072edf28d6b5b8efc472979f5a"
+
+[[projects]]
+  digest = "1:43dd08a10854b2056e615d1b1d22ac94559d822e1f8b6fcc92c1a1057e85188e"
   name = "github.com/gorilla/websocket"
   packages = ["."]
+  pruneopts = "UT"
   revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
   version = "v1.2.0"
 
 [[projects]]
+  digest = "1:364b908b9b27b97ab838f2f6f1b1f46281fa29b978a037d72a9b1d4f6d940190"
+  name = "github.com/hailocab/go-hostpool"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e80d13ce29ede4452c43dea11e79b9bc8a15b478"
+
+[[projects]]
+  branch = "master"
+  digest = "1:51a6dbf048dc420793ec106b7c8d151d1ffb119285ce044cc41d2dbb7e23732e"
+  name = "github.com/hokaccha/go-prettyjson"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e6b9231a2b1cc5798b336fdbf99c16cd8ad1e0c9"
+
+[[projects]]
+  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
+  name = "github.com/inconshreveable/mousetrap"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+  version = "v1.0"
+
+[[projects]]
+  digest = "1:ce530152667dc8ba823a586c1c81175aff2c4e15500520883a2727d0ed17c6f1"
   name = "github.com/influxdata/influxdb"
   packages = [
     "client/v2",
     "models",
-    "pkg/escape"
+    "pkg/escape",
   ]
+  pruneopts = "UT"
   revision = "02d7d4f043b34ecb4e9b2dbec298c6f9450c2a32"
   version = "v1.5.2"
 
 [[projects]]
   branch = "master"
+  digest = "1:a64e323dc06b73892e5bb5d040ced475c4645d456038333883f58934abbf6f72"
   name = "github.com/kr/logfmt"
   packages = ["."]
+  pruneopts = "UT"
   revision = "b84e30acd515aadc4b783ad4ff83aff3299bdfe0"
 
 [[projects]]
   branch = "master"
+  digest = "1:1e537dfb7b4d543e25efa2c812084dd65736f8010979c1b7e167a5b876563199"
   name = "github.com/lib/pq"
   packages = [
     ".",
-    "oid"
+    "oid",
   ]
+  pruneopts = "UT"
   revision = "d34b9ff171c21ad295489235aec8b6626023cd04"
 
 [[projects]]
+  digest = "1:c658e84ad3916da105a761660dcaeb01e63416c8ec7bc62256a9b411a05fcd67"
+  name = "github.com/mattn/go-colorable"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
+  version = "v0.0.9"
+
+[[projects]]
+  digest = "1:d4d17353dbd05cb52a2a52b7fe1771883b682806f68db442b436294926bbfafb"
+  name = "github.com/mattn/go-isatty"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
+  version = "v0.0.3"
+
+[[projects]]
+  digest = "1:5985ef4caf91ece5d54817c11ea25f182697534f8ae6521eadcd628c142ac4b6"
   name = "github.com/matttproud/golang_protobuf_extensions"
   packages = ["pbutil"]
+  pruneopts = "UT"
   revision = "3247c84500bff8d9fb6d579d800f20b3e091582c"
   version = "v1.0.0"
 
 [[projects]]
+  digest = "1:e274a8817ced03e0eaab6615aee825e4bd374a31180a3f5c2c640403840cc9dc"
   name = "github.com/mongodb/mongo-go-driver"
   packages = [
     "bson",
@@ -171,70 +327,106 @@
     "bson/decimal",
     "bson/elements",
     "bson/objectid",
-    "core/addr",
+    "bson/parser",
+    "bson/parser/ast",
+    "core/address",
     "core/auth",
     "core/auth/internal/gssapi",
     "core/command",
+    "core/compressor",
     "core/connection",
     "core/connstring",
     "core/description",
     "core/dispatch",
-    "core/options",
+    "core/event",
+    "core/option",
     "core/readconcern",
     "core/readpref",
     "core/result",
+    "core/session",
     "core/tag",
     "core/topology",
+    "core/uuid",
     "core/version",
     "core/wiremessage",
     "core/writeconcern",
     "internal",
-    "mongo"
+    "mongo",
+    "mongo/aggregateopt",
+    "mongo/changestreamopt",
+    "mongo/clientopt",
+    "mongo/collectionopt",
+    "mongo/countopt",
+    "mongo/dbopt",
+    "mongo/deleteopt",
+    "mongo/distinctopt",
+    "mongo/dropcollopt",
+    "mongo/findopt",
+    "mongo/indexopt",
+    "mongo/insertopt",
+    "mongo/listcollectionopt",
+    "mongo/listdbopt",
+    "mongo/mongoopt",
+    "mongo/replaceopt",
+    "mongo/runcmdopt",
+    "mongo/updateopt",
   ]
-  revision = "29a4d7d5b648e5b0b60e03e3bd71c11703f0c203"
-  version = "v0.0.5"
+  pruneopts = "UT"
+  revision = "8df56f107cdd485351eb2523992c3364114b4b2e"
+  version = "v0.0.10"
 
 [[projects]]
+  digest = "1:6ec5ca70ff99467ff3b134ca05ae1d247e42a0377a7c27a756ba932f4dfc3a88"
   name = "github.com/nats-io/go-nats"
   packages = [
     ".",
     "encoders/builtin",
-    "util"
+    "util",
   ]
+  pruneopts = "UT"
   revision = "062418ea1c2181f52dc0f954f6204370519a868b"
   version = "v1.5.0"
 
 [[projects]]
+  digest = "1:c3cd663f2f30b92536b9f290ac85c6310dae36a14cb8961553ae9ccf0d85ae41"
   name = "github.com/nats-io/nuid"
   packages = ["."]
+  pruneopts = "UT"
   revision = "289cccf02c178dc782430d534e3c1f5b72af807f"
   version = "v1.0.0"
 
 [[projects]]
+  digest = "1:ee4d4af67d93cc7644157882329023ce9a7bcfce956a079069a9405521c7cc8d"
   name = "github.com/opencontainers/go-digest"
   packages = ["."]
+  pruneopts = "UT"
   revision = "279bed98673dd5bef374d3b6e4b09e2af76183bf"
   version = "v1.0.0-rc1"
 
 [[projects]]
+  digest = "1:11db38d694c130c800d0aefb502fb02519e514dc53d9804ce51d1ad25ec27db6"
   name = "github.com/opencontainers/image-spec"
   packages = [
     "specs-go",
-    "specs-go/v1"
+    "specs-go/v1",
   ]
+  pruneopts = "UT"
   revision = "d60099175f88c47cd379c4738d158884749ed235"
   version = "v1.0.1"
 
 [[projects]]
+  digest = "1:1869683e323ebff2bdf8adcb560f82bf6f8d94019d35099e3403f7df12e9c07e"
   name = "github.com/opencontainers/runc"
   packages = [
     "libcontainer/system",
-    "libcontainer/user"
+    "libcontainer/user",
   ]
+  pruneopts = "UT"
   revision = "baf6536d6259209c3edfa2b22237af82942d3dfa"
   version = "v0.1.1"
 
 [[projects]]
+  digest = "1:3b830e06971be8448e7c9e57c9cc15ce53ab7e8846e7b7c39110a177c7fae466"
   name = "github.com/ory/dockertest"
   packages = [
     "docker",
@@ -260,111 +452,158 @@
     "docker/types/network",
     "docker/types/registry",
     "docker/types/strslice",
-    "docker/types/versions"
+    "docker/types/versions",
   ]
+  pruneopts = "UT"
   revision = "2e92e7784b6fb199fd168aa46269a2f1b34f299e"
   version = "v3.3.0"
 
 [[projects]]
+  digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747"
   name = "github.com/pkg/errors"
   packages = ["."]
+  pruneopts = "UT"
   revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
   version = "v0.8.0"
 
 [[projects]]
+  digest = "1:0028cb19b2e4c3112225cd871870f2d9cf49b9b4276531f03438a88e94be86fe"
   name = "github.com/pmezard/go-difflib"
   packages = ["difflib"]
+  pruneopts = "UT"
   revision = "792786c7400a136282c1664665ae0a8db921c6c2"
   version = "v1.0.0"
 
 [[projects]]
+  digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb"
   name = "github.com/prometheus/client_golang"
   packages = [
     "prometheus",
-    "prometheus/promhttp"
+    "prometheus/promhttp",
   ]
+  pruneopts = "UT"
   revision = "c5b7fccd204277076155f10851dad72b76a49317"
   version = "v0.8.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:32d10bdfa8f09ecf13598324dba86ab891f11db3c538b6a34d1c3b5b99d7c36b"
   name = "github.com/prometheus/client_model"
   packages = ["go"]
+  pruneopts = "UT"
   revision = "99fa1f4be8e564e8a6b613da7fa6f46c9edafc6c"
 
 [[projects]]
   branch = "master"
+  digest = "1:e469cd65badf7694aeb44874518606d93c1d59e7735d3754ad442782437d3cc3"
   name = "github.com/prometheus/common"
   packages = [
     "expfmt",
     "internal/bitbucket.org/ww/goautoneg",
-    "model"
+    "model",
   ]
+  pruneopts = "UT"
   revision = "d811d2e9bf898806ecfb6ef6296774b13ffc314c"
 
 [[projects]]
   branch = "master"
+  digest = "1:570784e0ddbf67f14087c6d8cfb7b999b9c55e75518a755e88cb202566ea8a17"
   name = "github.com/prometheus/procfs"
   packages = [
     ".",
     "internal/util",
     "nfs",
-    "xfs"
+    "xfs",
   ]
+  pruneopts = "UT"
   revision = "8b1c2da0d56deffdbb9e48d4414b4e674bd8083e"
 
 [[projects]]
   branch = "master"
+  digest = "1:c9f218adb858f881ce84d0c3d6ad9f65b40d7f31c705c8f00b04106294cb006e"
   name = "github.com/rubenv/sql-migrate"
   packages = [
     ".",
-    "sqlparse"
+    "sqlparse",
   ]
+  pruneopts = "UT"
   revision = "081fe17d19ff4e2dd9f5a0c1158e6bcf74da6906"
 
 [[projects]]
+  digest = "1:274f67cb6fed9588ea2521ecdac05a6d62a8c51c074c1fccc6a49a40ba80e925"
   name = "github.com/satori/go.uuid"
   packages = ["."]
+  pruneopts = "UT"
   revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3"
   version = "v1.2.0"
 
 [[projects]]
+  digest = "1:9e9193aa51197513b3abcb108970d831fbcf40ef96aa845c4f03276e1fa316d2"
   name = "github.com/sirupsen/logrus"
   packages = ["."]
+  pruneopts = "UT"
   revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
   version = "v1.0.5"
 
 [[projects]]
+  digest = "1:f7805d1cc7776d00da2aa3dbacf85927e58e6dad630ba9f3ea5b92d719f96269"
   name = "github.com/sony/gobreaker"
   packages = ["."]
+  pruneopts = "UT"
   revision = "e9556a45379ef1da12e54847edb2fb3d7d566f36"
   version = "0.3.0"
 
 [[projects]]
+  digest = "1:645cabccbb4fa8aab25a956cbcbdf6a6845ca736b2c64e197ca7cbb9d210b939"
+  name = "github.com/spf13/cobra"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
+  version = "v0.0.3"
+
+[[projects]]
+  digest = "1:9424f440bba8f7508b69414634aef3b2b3a877e522d8a4624692412805407bb7"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "583c0c0531f06d5278b7d917446061adc344b5cd"
+  version = "v1.0.1"
+
+[[projects]]
+  digest = "1:7e8d267900c7fa7f35129a2a37596e38ed0f11ca746d6d9ba727980ee138f9f6"
   name = "github.com/stretchr/testify"
-  packages = ["assert"]
+  packages = [
+    "assert",
+    "require",
+  ]
+  pruneopts = "UT"
   revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
   version = "v1.2.1"
 
 [[projects]]
+  digest = "1:03aa6e485e528acb119fb32901cf99582c380225fc7d5a02758e08b180cb56c3"
   name = "github.com/ugorji/go"
   packages = ["codec"]
+  pruneopts = "UT"
   revision = "b4c50a2b199d93b13dc15e78929cfb23bfdf21ab"
   version = "v1.1.1"
 
 [[projects]]
   branch = "master"
+  digest = "1:7310f5459b88177d24e26c5ec7deb100b78ec03c0437d7a7aaec3c7eac333a55"
   name = "golang.org/x/crypto"
   packages = [
     "bcrypt",
     "blowfish",
     "pbkdf2",
-    "ssh/terminal"
+    "ssh/terminal",
   ]
+  pruneopts = "UT"
   revision = "2d027ae1dddd4694d54f7a8b6cbe78dca8720226"
 
 [[projects]]
   branch = "master"
+  digest = "1:49131f79ef90ca701638024267ba6e3b5cd0ce387e0b3ec79961a42430873db9"
   name = "golang.org/x/net"
   packages = [
     "context",
@@ -373,26 +612,32 @@
     "http2/hpack",
     "idna",
     "internal/timeseries",
-    "trace"
+    "trace",
   ]
+  pruneopts = "UT"
   revision = "f73e4c9ed3b7ebdd5f699a16a880c2b1994e50dd"
 
 [[projects]]
   branch = "master"
+  digest = "1:e0140c0c868c6e0f01c0380865194592c011fe521d6e12d78bfd33e756fe018a"
   name = "golang.org/x/sync"
   packages = ["semaphore"]
+  pruneopts = "UT"
   revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
 
 [[projects]]
   branch = "master"
+  digest = "1:66e34aa65b83061616603ba83517a4523c7261e18afd01c769dd215614bf7d70"
   name = "golang.org/x/sys"
   packages = [
     "unix",
-    "windows"
+    "windows",
   ]
+  pruneopts = "UT"
   revision = "7dfd1290c7917b7ba22824b9d24954ab3002fe24"
 
 [[projects]]
+  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
   name = "golang.org/x/text"
   packages = [
     "collate",
@@ -408,18 +653,22 @@
     "unicode/bidi",
     "unicode/cldr",
     "unicode/norm",
-    "unicode/rangetable"
+    "unicode/rangetable",
   ]
+  pruneopts = "UT"
   revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
   version = "v0.3.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:cd018653a358d4b743a9d3bee89e825521f2ab2f2ec0770164bf7632d8d73ab7"
   name = "google.golang.org/genproto"
   packages = ["googleapis/rpc/status"]
+  pruneopts = "UT"
   revision = "86e600f69ee4704c6efbf6a2a40a5c10700e76c2"
 
 [[projects]]
+  digest = "1:bb5ad466f9c22e1d7f34537a408ca215ee192e759979723b2b5e3f26dc80fd1f"
   name = "google.golang.org/grpc"
   packages = [
     ".",
@@ -445,26 +694,79 @@
     "stats",
     "status",
     "tap",
-    "transport"
+    "transport",
   ]
+  pruneopts = "UT"
   revision = "41344da2231b913fa3d983840a57a6b1b7b631a1"
   version = "v1.12.0"
 
 [[projects]]
+  digest = "1:fa9a7c0ef59217bd22f32eb7cc027894d73f340a5633258cc079dec025db6a7f"
   name = "gopkg.in/gorp.v1"
   packages = ["."]
+  pruneopts = "UT"
   revision = "c87af80f3cc5036b55b83d77171e156791085e2e"
   version = "v1.7.1"
 
 [[projects]]
+  digest = "1:2d1fbdc6777e5408cabeb02bf336305e724b925ff4546ded0fa8715a7267922a"
+  name = "gopkg.in/inf.v0"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "d2d2541c53f18d2a059457998ce2876cc8e67cbf"
+  version = "v0.9.1"
+
+[[projects]]
+  digest = "1:784e96fed7cbc35a3fdefb802ed2f841c16dbc3cf6c02f6422cc94ff45d011fc"
   name = "gopkg.in/ory-am/dockertest.v3"
   packages = ["."]
+  pruneopts = "UT"
   revision = "2e92e7784b6fb199fd168aa46269a2f1b34f299e"
   version = "v3.3.0"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "6010ae4c4f91c30b3a63789cc280466ce56d50f387c1e4d11c49df1302f083da"
+  input-imports = [
+    "github.com/asaskevich/govalidator",
+    "github.com/cisco/senml",
+    "github.com/dereulenspiegel/coap-mux",
+    "github.com/dgrijalva/jwt-go",
+    "github.com/dustin/go-coap",
+    "github.com/fatih/color",
+    "github.com/go-kit/kit/endpoint",
+    "github.com/go-kit/kit/log",
+    "github.com/go-kit/kit/metrics",
+    "github.com/go-kit/kit/metrics/prometheus",
+    "github.com/go-kit/kit/transport/grpc",
+    "github.com/go-kit/kit/transport/http",
+    "github.com/go-redis/redis",
+    "github.com/go-zoo/bone",
+    "github.com/gocql/gocql",
+    "github.com/gogo/protobuf/proto",
+    "github.com/golang/protobuf/proto",
+    "github.com/gorilla/websocket",
+    "github.com/hokaccha/go-prettyjson",
+    "github.com/influxdata/influxdb/client/v2",
+    "github.com/lib/pq",
+    "github.com/mongodb/mongo-go-driver/bson",
+    "github.com/mongodb/mongo-go-driver/mongo",
+    "github.com/mongodb/mongo-go-driver/mongo/findopt",
+    "github.com/nats-io/go-nats",
+    "github.com/prometheus/client_golang/prometheus",
+    "github.com/prometheus/client_golang/prometheus/promhttp",
+    "github.com/rubenv/sql-migrate",
+    "github.com/satori/go.uuid",
+    "github.com/sony/gobreaker",
+    "github.com/spf13/cobra",
+    "github.com/stretchr/testify/assert",
+    "github.com/stretchr/testify/require",
+    "golang.org/x/crypto/bcrypt",
+    "golang.org/x/net/context",
+    "google.golang.org/grpc",
+    "google.golang.org/grpc/codes",
+    "google.golang.org/grpc/status",
+    "gopkg.in/ory-am/dockertest.v3",
+  ]
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -10,6 +10,10 @@
   name = "github.com/dgrijalva/jwt-go"
   version = "3.2.0"
 
+[[constraint]]
+  name = "github.com/fatih/color"
+  version = "1.7.0"
+
 [[constraint]]
   name = "github.com/go-kit/kit"
   version = "0.6.0"
@@ -22,6 +26,10 @@
   name = "github.com/golang/protobuf"
   version = "1.1.0"
 
+[[constraint]]
+  branch = "master"
+  name = "github.com/hokaccha/go-prettyjson"
+
 [[constraint]]
   branch = "master"
   name = "github.com/lib/pq"
@@ -42,6 +50,10 @@
   name = "github.com/sony/gobreaker"
   version = "0.3.0"
 
+[[constraint]]
+  name = "github.com/spf13/cobra"
+  version = "0.0.3"
+
 [[constraint]]
   name = "github.com/stretchr/testify"
   version = "1.2.1"
@@ -70,6 +82,18 @@
   name = "github.com/mongodb/mongo-go-driver"
   version = "0.0.5"
 
+[[constraint]]
+  branch = "master"
+  name = "github.com/gocql/gocql"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/dereulenspiegel/coap-mux"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/dustin/go-coap"
+
 [prune]
   go-tests = true
   unused-packages = true

MAINTAINERS

@@ -7,7 +7,7 @@
 	
 	[[drasko]]
 	Name	= "Drasko DRASKOVIC"
-	Email	= "drasko.draskovic@mainflux.com"
+	Email	= "drasko@mainflux.com"
 	GitHub	= "drasko"
 
 # However, this role serves only in dead-lock events, or in a special and very rare cases
@@ -24,22 +24,23 @@
 
 [maintainers]
 
+	[[aleksandar]]
+	Name	= "Aleksandar NOVAKOVIC"
+	Email	= "aleksandar@mainflux.com"
+	GitHub	= "anovakovic01"
+ 
+ 	[[dusan]]
+	Name	= "Dusan BOROVCANIN"
+	Email	= "dusan@mainflux.com"
+	GitHub	= "dusanb94"
+
 	[[manuel]]
 	Name	= "Manuel IMPERIALE"
-	Email	= "manuel.imperiale@gmail.com"
+	Email	= "manuel@mainflux.com"
 	GitHub	= "manuIO"
 
-	[[janko]]
-	Name	= "Janko ISIDOROVIC"
-	Email	= "janko.isidorovic@mainflux.com"
-	GitHub	= "janko-isidorovic"
-
 	[[nikola]]
 	Name	= "Nikola MARCETIC"
-	Email	= "nikola.marcetic@mainflux.com"
+	Email	= "nikola@mainflux.com"
 	GitHub	= "nmarcetic"
-	
-	[[dejan]]
-	Name	= "Dejan MIJIC"
-	Email	= "dejan.mijic@mainflux.com"
-	GitHub	= "mijicd"
+

Makefile

@@ -1,6 +1,7 @@
 BUILD_DIR = build
-SERVICES = users things http normalizer ws influxdb mongodb
+SERVICES = users things http normalizer ws coap influxdb-writer influxdb-reader mongodb-writer mongodb-reader cassandra-writer cassandra-reader cli
 DOCKERS = $(addprefix docker_,$(SERVICES))
+DOCKERS_DEV = $(addprefix docker_dev_,$(SERVICES))
 CGO_ENABLED ?= 0
 GOOS ?= linux
 
@@ -9,23 +10,31 @@ define compile_service
 endef
 
 define make_docker
-	docker build --build-arg SVC_NAME=$(subst docker_,,$(1)) --tag=mainflux/$(subst docker_,,$(1)) -f docker/Dockerfile .
+	docker build --no-cache --build-arg SVC_NAME=$(subst docker_,,$(1)) --tag=mainflux/$(subst docker_,,$(1)) -f docker/Dockerfile .
 endef
 
-all: $(SERVICES)
+define make_docker_dev
+	docker build --build-arg SVC_NAME=$(subst docker_dev_,,$(1)) --tag=mainflux/$(subst docker_dev_,,$(1)) -f docker/Dockerfile.dev ./build
+endef
 
-.PHONY: all $(SERVICES) dockers latest release
+all: $(SERVICES) mqtt
+
+.PHONY: all $(SERVICES) dockers dockers_dev latest release mqtt
 
 clean:
 	rm -rf ${BUILD_DIR}
+	rm -rf mqtt/node_modules
 
 install:
 	cp ${BUILD_DIR}/* $(GOBIN)
 
+test:
+	GOCACHE=off go test -v -race -tags test $(shell go list ./... | grep -v 'vendor\|cmd')
+
 proto:
 	protoc --go_out=plugins=grpc:. *.proto
 
-$(SERVICES): proto
+$(SERVICES):
 	$(call compile_service,$(@))
 
 $(DOCKERS):
@@ -35,12 +44,24 @@ dockers: $(DOCKERS)
 	docker build --tag=mainflux/dashflux -f dashflux/docker/Dockerfile dashflux
 	docker build --tag=mainflux/mqtt -f mqtt/Dockerfile .
 
-latest: dockers
+$(DOCKERS_DEV):
+	$(call make_docker_dev,$(@))
+
+dockers_dev: $(DOCKERS_DEV)
+
+mqtt:
+	cd mqtt && npm install
+
+define docker_push
 	for svc in $(SERVICES); do \
-		docker push mainflux/$$svc; \
+		docker push mainflux/$$svc:$(1); \
 	done
-	docker push mainflux/dashflux
-	docker push mainflux/mqtt
+	docker push mainflux/dashflux:$(1)
+	docker push mainflux/mqtt:$(1)
+endef
+
+latest: dockers
+	$(call docker_push,latest)
 
 release:
 	$(eval version = $(shell git describe --abbrev=0 --tags))
@@ -48,9 +69,13 @@ release:
 	$(MAKE) dockers
 	for svc in $(SERVICES); do \
 		docker tag mainflux/$$svc mainflux/$$svc:$(version); \
-		docker push mainflux/$$svc:$(version); \
 	done
 	docker tag mainflux/dashflux mainflux/dashflux:$(version)
-	docker push mainflux/dashflux:$(version)
 	docker tag mainflux/mqtt mainflux/mqtt:$(version)
-	docker push mainflux/mqtt:$(version)
+	$(call docker_push,$(version))
+
+rundev:
+	cd scripts && ./run.sh
+
+run:
+	docker-compose -f docker/docker-compose.yml up

api.go

@@ -1,3 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package mainflux
 
 // Response contains HTTP response specific methods.

cli/README.md

@@ -0,0 +1,87 @@
+# Mainflux CLI
+## Build
+From the project root:
+```
+make cli
+```
+
+## Usage
+### Service
+#### Get the service verison
+```
+mainflux-cli version
+```
+
+### User management
+#### Create User
+```
+mainflux-cli users create john.doe@email.com password
+```
+
+#### Login User
+```
+mainflux-cli users token john.doe@email.com password
+```
+
+### System Provisioning
+#### Provision Device
+```
+mainflux-cli things create '{"type":"device", "name":"nyDevice"}' <user_auth_token>
+```
+
+#### Provision Application
+```
+mainflux-cli things create '{"type":"app", "name":"nyDevice"}' <user_auth_token>
+```
+
+#### Retrieve All Things
+```
+mainflux-cli things get all --offset=1 --limit=5 <user_auth_token>
+```
+
+#### Retrieve Thing By ID
+```
+mainflux-cli things get <thing_id> --offset=1 --limit=5 <user_auth_token>
+```
+
+#### Remove Thing
+```
+mainflux-cli things delete <thing_id> <user_auth_token>
+```
+
+#### Provision Channel
+```
+mainflux-cli channels create '{"name":"nyChannel"}' <user_auth_token>
+```
+
+#### Retrieve All Channels
+```
+mainflux-cli channels get all --offset=1 --limit=5 <user_auth_token>
+```
+
+#### Retrievie Channel By ID
+```
+mainflux-cli channels get <channel_id> --offset=1 --limit=5 <user_auth_token>
+```
+
+#### Remove Channel
+```
+mainflux-cli channels delete <channel_id> <user_auth_token>
+```
+
+### Access control
+#### Connect Thing to a Channel
+```
+mainflux-cli things connect <thing_id> <channel_id> <user_auth_token>
+```
+
+#### Disconnect Things from a Channel
+```
+mainflux-cli things disconnect <thing_id> <channel_id> <user_auth_token>
+```
+
+### Messaging
+#### Send a message over HTTP
+```
+mainflux-cli msg send <channel_id> '[{"bn":"some-base-name:","bt":1.276020076001e+09, "bu":"A","bver":5, "n":"voltage","u":"V","v":120.1}, {"n":"current","t":-5,"v":1.2}, {"n":"current","t":-4,"v":1.3}]' <thing_auth_token>
+```

cli/channels.go

@@ -0,0 +1,133 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import (
+	"encoding/json"
+
+	mfxsdk "github.com/mainflux/mainflux/sdk/go"
+	"github.com/spf13/cobra"
+)
+
+var cmdChannels = []cobra.Command{
+	cobra.Command{
+		Use:   "create",
+		Short: "create <JSON_channel> <user_auth_token>",
+		Long:  `Creates new channel and generates it's UUID`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			var channel mfxsdk.Channel
+			if err := json.Unmarshal([]byte(args[0]), &channel); err != nil {
+				logError(err)
+				return
+			}
+
+			id, err := sdk.CreateChannel(channel, args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			flush(id)
+		},
+	},
+	cobra.Command{
+		Use:   "get",
+		Short: "get all/<channel_id> <user_auth_token>",
+		Long:  `Gets list of all channels or gets channel by id`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			if args[0] == "all" {
+				l, err := sdk.Channels(args[1], uint64(Offset), uint64(Limit))
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				flush(l)
+				return
+			}
+
+			c, err := sdk.Channel(args[0], args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			flush(c)
+		},
+	},
+	cobra.Command{
+		Use:   "update",
+		Short: "update <JSON_string> <user_auth_token>",
+		Long:  `Updates channel record`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 3 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			var channel mfxsdk.Channel
+			if err := json.Unmarshal([]byte(args[0]), &channel); err != nil {
+				logError(err)
+				return
+			}
+
+			if err := sdk.UpdateChannel(channel, args[1]); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+	cobra.Command{
+		Use:   "delete",
+		Short: "delete <channel_id> <user_auth_token>",
+		Long:  `Delete channel by ID`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			if err := sdk.DeleteChannel(args[0], args[1]); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+}
+
+// NewChannelsCmd returns channels command.
+func NewChannelsCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "channels",
+		Short: "Manipulation with channels",
+		Long:  `Manipulation with channels: create, delete or update channels`,
+		Run: func(cmd *cobra.Command, args []string) {
+			logUsage(cmd.Short)
+		},
+	}
+
+	for i := range cmdChannels {
+		cmd.AddCommand(&cmdChannels[i])
+	}
+
+	return &cmd
+}

cli/message.go

@@ -0,0 +1,48 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import "github.com/spf13/cobra"
+
+const contentTypeSenml = "application/senml+json"
+
+var cmdMessages = []cobra.Command{
+	cobra.Command{
+		Use:   "send",
+		Short: "send <channel_id> <JSON_string> <thing_token>",
+		Long:  `Sends message on the channel`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 3 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			if err := sdk.SendMessage(args[0], args[1], args[2]); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+}
+
+// NewMessagesCmd returns messages command.
+func NewMessagesCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "msg",
+		Short: "Send or retrieve messages",
+		Long:  `Send or retrieve messages: control message flow on the channel`,
+	}
+
+	for i := range cmdMessages {
+		cmd.AddCommand(&cmdMessages[i])
+	}
+
+	return &cmd
+}

cli/sdk.go

@@ -0,0 +1,18 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import mfxsdk "github.com/mainflux/mainflux/sdk/go"
+
+// Keep SDK handle in global var
+var sdk mfxsdk.SDK
+
+// SetSDK sets mainflux SDK instance.
+func SetSDK(s mfxsdk.SDK) {
+	sdk = s
+}

cli/things.go

@@ -0,0 +1,170 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import (
+	"encoding/json"
+
+	mfxsdk "github.com/mainflux/mainflux/sdk/go"
+	"github.com/spf13/cobra"
+)
+
+const thingsEP = "things"
+
+var cmdThings = []cobra.Command{
+	cobra.Command{
+		Use:   "create",
+		Short: "create <JSON_thing> <user_auth_token>",
+		Long:  `Create new thing, generate his UUID and store it`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			var thing mfxsdk.Thing
+			if err := json.Unmarshal([]byte(args[0]), &thing); err != nil {
+				logError(err)
+				return
+			}
+
+			id, err := sdk.CreateThing(thing, args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			flush(id)
+		},
+	},
+	cobra.Command{
+		Use:   "get",
+		Short: "get all/<thing_id> <user_auth_token>",
+		Long:  `Get all things or thing by id`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			if args[0] == "all" {
+				l, err := sdk.Things(args[1], uint64(Offset), uint64(Limit))
+				if err != nil {
+					logError(err)
+					return
+				}
+				flush(l)
+				return
+			}
+
+			t, err := sdk.Thing(args[0], args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			flush(t)
+		},
+	},
+	cobra.Command{
+		Use:   "delete",
+		Short: "delete <thing_id> <user_auth_token>",
+		Long:  `Removes thing from database`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			if err := sdk.DeleteThing(args[0], args[1]); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+	cobra.Command{
+		Use:   "update",
+		Short: "update <JSON_string> <user_auth_token>",
+		Long:  `Update thing record`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 3 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			var thing mfxsdk.Thing
+			if err := json.Unmarshal([]byte(args[0]), &thing); err != nil {
+				logError(err)
+				return
+			}
+
+			if err := sdk.UpdateThing(thing, args[1]); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+	cobra.Command{
+		Use:   "connect",
+		Short: "connect <thing_id> <channel_id> <user_auth_token>",
+		Long:  `Connect thing to the channel`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 3 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			if err := sdk.ConnectThing(args[0], args[1], args[2]); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+	cobra.Command{
+		Use:   "disconnect",
+		Short: "disconnect <thing_id> <channel_id> <user_auth_token>",
+		Long:  `Disconnect thing to the channel`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 3 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			if err := sdk.DisconnectThing(args[0], args[1], args[2]); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+}
+
+// NewThingsCmd returns things command.
+func NewThingsCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "things",
+		Short: "things <options>",
+		Long:  `Things handling: create, delete or update things`,
+		Run: func(cmd *cobra.Command, args []string) {
+			logUsage(cmd.Short)
+		},
+	}
+
+	for i := range cmdThings {
+		cmd.AddCommand(&cmdThings[i])
+	}
+
+	return &cmd
+}

cli/users.go

@@ -0,0 +1,79 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import (
+	mfxsdk "github.com/mainflux/mainflux/sdk/go"
+	"github.com/spf13/cobra"
+)
+
+var cmdUsers = []cobra.Command{
+	cobra.Command{
+		Use:   "create",
+		Short: "create <username> <password>",
+		Long:  `Creates new user`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			user := mfxsdk.User{
+				Email:    args[0],
+				Password: args[1],
+			}
+			if err := sdk.CreateUser(user); err != nil {
+				logError(err)
+				return
+			}
+
+			logOK()
+		},
+	},
+	cobra.Command{
+		Use:   "token",
+		Short: "token <username> <password>",
+		Long:  `Creates new token`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			user := mfxsdk.User{
+				Email:    args[0],
+				Password: args[1],
+			}
+			token, err := sdk.CreateToken(user)
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			flush(token)
+		},
+	},
+}
+
+// NewUsersCmd returns users command.
+func NewUsersCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "users",
+		Short: "users create/token <email> <password>",
+		Long:  `Manages users in the system (create account or token)`,
+		Run: func(cmd *cobra.Command, args []string) {
+			logUsage(cmd.Short)
+		},
+	}
+
+	for i := range cmdUsers {
+		cmd.AddCommand(&cmdUsers[i])
+	}
+
+	return &cmd
+}

cli/utils.go

@@ -0,0 +1,38 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import (
+	"fmt"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/fatih/color"
+)
+
+var (
+	// Limit query parameter
+	Limit uint = 10
+	// Offset query parameter
+	Offset uint
+)
+
+func flush(i interface{}) {
+	fmt.Printf("%s", color.BlueString(spew.Sdump(i)))
+}
+
+func logUsage(u string) {
+	fmt.Printf(color.YellowString("Usage:  %s\n"), u)
+}
+
+func logError(err error) {
+	fmt.Printf("%s\n", color.RedString(err.Error()))
+}
+
+func logOK() {
+	fmt.Printf("%s\n", color.GreenString("OK"))
+}

cli/version.go

@@ -0,0 +1,28 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import "github.com/spf13/cobra"
+
+// NewVersionCmd returns version command.
+func NewVersionCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "Get version of Mainflux Things Service",
+		Long:  `Mainflux server health check`,
+		Run: func(cmd *cobra.Command, args []string) {
+			v, err := sdk.Version()
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			flush(v)
+		},
+	}
+}

cmd/cassandra-reader/main.go

@@ -0,0 +1,142 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/gocql/gocql"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/readers"
+	"github.com/mainflux/mainflux/readers/api"
+	"github.com/mainflux/mainflux/readers/cassandra"
+	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
+)
+
+const (
+	sep = ","
+
+	defLogLevel  = "error"
+	defPort      = "8180"
+	defCluster   = "127.0.0.1"
+	defKeyspace  = "mainflux"
+	defThingsURL = "localhost:8181"
+
+	envLogLevel  = "MF_CASSANDRA_READER_LOG_LEVEL"
+	envPort      = "MF_CASSANDRA_READER_PORT"
+	envCluster   = "MF_CASSANDRA_READER_DB_CLUSTER"
+	envKeyspace  = "MF_CASSANDRA_READER_DB_KEYSPACE"
+	envThingsURL = "MF_THINGS_URL"
+)
+
+type config struct {
+	logLevel  string
+	port      string
+	cluster   string
+	keyspace  string
+	thingsURL string
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	session := connectToCassandra(cfg.cluster, cfg.keyspace, logger)
+	defer session.Close()
+
+	conn := connectToThings(cfg.thingsURL, logger)
+	defer conn.Close()
+
+	tc := thingsapi.NewClient(conn)
+	repo := newService(session, logger)
+
+	errs := make(chan error, 2)
+
+	go startHTTPServer(repo, tc, cfg.port, errs, logger)
+
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("Cassandra reader service terminated: %s", err))
+}
+
+func loadConfig() config {
+	return config{
+		logLevel:  mainflux.Env(envLogLevel, defLogLevel),
+		port:      mainflux.Env(envPort, defPort),
+		cluster:   mainflux.Env(envCluster, defCluster),
+		keyspace:  mainflux.Env(envKeyspace, defKeyspace),
+		thingsURL: mainflux.Env(envThingsURL, defThingsURL),
+	}
+}
+
+func connectToCassandra(cluster, keyspace string, logger logger.Logger) *gocql.Session {
+	session, err := cassandra.Connect(strings.Split(cluster, sep), keyspace)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to Cassandra cluster: %s", err))
+		os.Exit(1)
+	}
+
+	return session
+}
+
+func connectToThings(url string, logger logger.Logger) *grpc.ClientConn {
+	conn, err := grpc.Dial(url, grpc.WithInsecure())
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
+		os.Exit(1)
+	}
+
+	return conn
+}
+
+func newService(session *gocql.Session, logger logger.Logger) readers.MessageRepository {
+	repo := cassandra.New(session)
+	repo = api.LoggingMiddleware(repo, logger)
+	repo = api.MetricsMiddleware(
+		repo,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "cassandra",
+			Subsystem: "message_reader",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "cassandra",
+			Subsystem: "message_reader",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+
+	return repo
+}
+
+func startHTTPServer(repo readers.MessageRepository, tc mainflux.ThingsServiceClient, port string, errs chan error, logger logger.Logger) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("Cassandra reader service started, exposed port %s", port))
+	errs <- http.ListenAndServe(p, api.MakeHandler(repo, tc, "cassandra-reader"))
+}

cmd/cassandra-writer/main.go

@@ -0,0 +1,143 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/gocql/gocql"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/writers"
+	"github.com/mainflux/mainflux/writers/cassandra"
+	"github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	queue = "cassandra-writer"
+	sep   = ","
+
+	defNatsURL  = nats.DefaultURL
+	defLogLevel = "error"
+	defPort     = "8180"
+	defCluster  = "127.0.0.1"
+	defKeyspace = "mainflux"
+
+	envNatsURL  = "MF_NATS_URL"
+	envLogLevel = "MF_CASSANDRA_WRITER_LOG_LEVEL"
+	envPort     = "MF_CASSANDRA_WRITER_PORT"
+	envCluster  = "MF_CASSANDRA_WRITER_DB_CLUSTER"
+	envKeyspace = "MF_CASSANDRA_WRITER_DB_KEYSPACE"
+)
+
+type config struct {
+	natsURL  string
+	logLevel string
+	port     string
+	cluster  string
+	keyspace string
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	nc := connectToNATS(cfg.natsURL, logger)
+	defer nc.Close()
+
+	session := connectToCassandra(cfg.cluster, cfg.keyspace, logger)
+	defer session.Close()
+
+	repo := newService(session, logger)
+	if err := writers.Start(nc, repo, queue, logger); err != nil {
+		logger.Error(fmt.Sprintf("Failed to create Cassandra writer: %s", err))
+	}
+
+	errs := make(chan error, 2)
+
+	go startHTTPServer(cfg.port, errs, logger)
+
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("Cassandra writer service terminated: %s", err))
+}
+
+func loadConfig() config {
+	return config{
+		natsURL:  mainflux.Env(envNatsURL, defNatsURL),
+		logLevel: mainflux.Env(envLogLevel, defLogLevel),
+		port:     mainflux.Env(envPort, defPort),
+		cluster:  mainflux.Env(envCluster, defCluster),
+		keyspace: mainflux.Env(envKeyspace, defKeyspace),
+	}
+}
+
+func connectToNATS(url string, logger logger.Logger) *nats.Conn {
+	nc, err := nats.Connect(url)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
+		os.Exit(1)
+	}
+
+	return nc
+}
+
+func connectToCassandra(cluster, keyspace string, logger logger.Logger) *gocql.Session {
+	session, err := cassandra.Connect(strings.Split(cluster, sep), keyspace)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to Cassandra cluster: %s", err))
+		os.Exit(1)
+	}
+
+	return session
+}
+
+func newService(session *gocql.Session, logger logger.Logger) writers.MessageRepository {
+	repo := cassandra.New(session)
+	repo = writers.LoggingMiddleware(repo, logger)
+	repo = writers.MetricsMiddleware(
+		repo,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "cassandra",
+			Subsystem: "message_writer",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "cassandra",
+			Subsystem: "message_writer",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+
+	return repo
+}
+
+func startHTTPServer(port string, errs chan error, logger logger.Logger) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("Cassandra writer service started, exposed port %s", port))
+	errs <- http.ListenAndServe(p, cassandra.MakeHandler())
+}

cmd/cli/main.go

@@ -0,0 +1,122 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"log"
+
+	"github.com/mainflux/mainflux/cli"
+	"github.com/mainflux/mainflux/sdk/go"
+	"github.com/spf13/cobra"
+)
+
+func main() {
+	msgContentType := string(sdk.CTJSONSenML)
+	sdkConf := sdk.Config{
+		BaseURL:           "http://localhost",
+		UsersPrefix:       "",
+		ThingsPrefix:      "",
+		HTTPAdapterPrefix: "http",
+		MsgContentType:    sdk.ContentType(msgContentType),
+		TLSVerification:   false,
+	}
+
+	// Root
+	var rootCmd = &cobra.Command{
+		Use: "mainflux-cli",
+		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+			sdkConf.MsgContentType = sdk.ContentType(msgContentType)
+			s := sdk.NewSDK(sdkConf)
+			cli.SetSDK(s)
+		},
+	}
+
+	// API commands
+	versionCmd := cli.NewVersionCmd()
+	usersCmd := cli.NewUsersCmd()
+	thingsCmd := cli.NewThingsCmd()
+	channelsCmd := cli.NewChannelsCmd()
+	messagesCmd := cli.NewMessagesCmd()
+
+	// Root Commands
+	rootCmd.AddCommand(versionCmd)
+	rootCmd.AddCommand(usersCmd)
+	rootCmd.AddCommand(thingsCmd)
+	rootCmd.AddCommand(channelsCmd)
+	rootCmd.AddCommand(messagesCmd)
+
+	// Root Flags
+	rootCmd.PersistentFlags().StringVarP(
+		&sdkConf.BaseURL,
+		"mainflux-url",
+		"m",
+		sdkConf.BaseURL,
+		"Mainflux host URL",
+	)
+
+	rootCmd.PersistentFlags().StringVarP(
+		&sdkConf.UsersPrefix,
+		"users-prefix",
+		"u",
+		sdkConf.UsersPrefix,
+		"Mainflux users service prefix",
+	)
+
+	rootCmd.PersistentFlags().StringVarP(
+		&sdkConf.ThingsPrefix,
+		"things-prefix",
+		"t",
+		sdkConf.ThingsPrefix,
+		"Mainflux things service prefix",
+	)
+
+	rootCmd.PersistentFlags().StringVarP(
+		&sdkConf.HTTPAdapterPrefix,
+		"http-prefix",
+		"a",
+		sdkConf.HTTPAdapterPrefix,
+		"Mainflux http adapter prefix",
+	)
+
+	rootCmd.PersistentFlags().StringVarP(
+		&msgContentType,
+		"content-type",
+		"c",
+		msgContentType,
+		"Mainflux message content type",
+	)
+
+	rootCmd.PersistentFlags().BoolVarP(
+		&sdkConf.TLSVerification,
+		"insecure",
+		"i",
+		sdkConf.TLSVerification,
+		"Do not check for TLS cert",
+	)
+
+	// Client and Channels Flags
+	rootCmd.PersistentFlags().UintVarP(
+		&cli.Limit,
+		"limit",
+		"l",
+		100,
+		"limit query parameter",
+	)
+
+	rootCmd.PersistentFlags().UintVarP(
+		&cli.Offset,
+		"offset",
+		"o",
+		0,
+		"offset query parameter",
+	)
+
+	if err := rootCmd.Execute(); err != nil {
+		log.Fatal(err)
+	}
+}

cmd/coap/main.go

@@ -0,0 +1,129 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	gocoap "github.com/dustin/go-coap"
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/coap"
+	"github.com/mainflux/mainflux/coap/api"
+	"github.com/mainflux/mainflux/coap/nats"
+	logger "github.com/mainflux/mainflux/logger"
+	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
+
+	broker "github.com/nats-io/go-nats"
+)
+
+const (
+	defPort      = "5683"
+	defNatsURL   = broker.DefaultURL
+	defThingsURL = "localhost:8181"
+	defLogLevel  = "error"
+
+	envPort      = "MF_COAP_ADAPTER_PORT"
+	envNatsURL   = "MF_NATS_URL"
+	envThingsURL = "MF_THINGS_URL"
+	envLogLevel  = "MF_COAP_ADAPTER_LOG_LEVEL"
+)
+
+type config struct {
+	port      string
+	natsURL   string
+	thingsURL string
+	logLevel  string
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	nc, err := broker.Connect(cfg.natsURL)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
+		os.Exit(1)
+	}
+	defer nc.Close()
+
+	conn, err := grpc.Dial(cfg.thingsURL, grpc.WithInsecure())
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
+		os.Exit(1)
+	}
+	defer conn.Close()
+
+	cc := thingsapi.NewClient(conn)
+	respChan := make(chan string, 10000)
+	pubsub := nats.New(nc)
+	svc := coap.New(pubsub, respChan)
+	svc = api.LoggingMiddleware(svc, logger)
+
+	svc = api.MetricsMiddleware(
+		svc,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "coap_adapter",
+			Subsystem: "api",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "coap_adapter",
+			Subsystem: "api",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+
+	errs := make(chan error, 2)
+
+	go startHTTPServer(cfg.port, logger, errs)
+	go startCOAPServer(cfg.port, svc, cc, respChan, logger, errs)
+
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("CoAP adapter terminated: %s", err))
+}
+
+func loadConfig() config {
+	return config{
+		thingsURL: mainflux.Env(envThingsURL, defThingsURL),
+		natsURL:   mainflux.Env(envNatsURL, defNatsURL),
+		port:      mainflux.Env(envPort, defPort),
+		logLevel:  mainflux.Env(envLogLevel, defLogLevel),
+	}
+}
+
+func startHTTPServer(port string, logger logger.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("CoAP service started, exposed port %s", port))
+	errs <- http.ListenAndServe(p, api.MakeHTTPHandler())
+}
+
+func startCOAPServer(port string, svc coap.Service, auth mainflux.ThingsServiceClient, respChan chan<- string, l logger.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	l.Info(fmt.Sprintf("CoAP adapter service started, exposed port %s", port))
+	errs <- gocoap.ListenAndServe("udp", p, api.MakeCOAPHandler(svc, auth, l, respChan))
+}

cmd/http/main.go

@@ -1,7 +1,15 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 	"os"
 	"os/signal"
@@ -12,7 +20,7 @@ import (
 	adapter "github.com/mainflux/mainflux/http"
 	"github.com/mainflux/mainflux/http/api"
 	"github.com/mainflux/mainflux/http/nats"
-	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/logger"
 	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
 	broker "github.com/nats-io/go-nats"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
@@ -21,9 +29,11 @@ import (
 
 const (
 	defPort      string = "8180"
+	defLogLevel  string = "error"
 	defNatsURL   string = broker.DefaultURL
 	defThingsURL string = "localhost:8181"
 	envPort      string = "MF_HTTP_ADAPTER_PORT"
+	envLogLevel  string = "MF_HTTP_ADAPTER_LOG_LEVEL"
 	envNatsURL   string = "MF_NATS_URL"
 	envThingsURL string = "MF_THINGS_URL"
 )
@@ -31,17 +41,18 @@ const (
 type config struct {
 	ThingsURL string
 	NatsURL   string
+	LogLevel  string
 	Port      string
 }
 
 func main() {
-	cfg := config{
-		ThingsURL: mainflux.Env(envThingsURL, defThingsURL),
-		NatsURL:   mainflux.Env(envNatsURL, defNatsURL),
-		Port:      mainflux.Env(envPort, defPort),
-	}
 
-	logger := log.New(os.Stdout)
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
 
 	nc, err := broker.Connect(cfg.NatsURL)
 	if err != nil {
@@ -52,7 +63,7 @@ func main() {
 
 	conn, err := grpc.Dial(cfg.ThingsURL, grpc.WithInsecure())
 	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
 		os.Exit(1)
 	}
 	defer conn.Close()
@@ -95,3 +106,13 @@ func main() {
 	err = <-errs
 	logger.Error(fmt.Sprintf("HTTP adapter terminated: %s", err))
 }
+
+func loadConfig() config {
+	return config{
+		ThingsURL: mainflux.Env(envThingsURL, defThingsURL),
+		NatsURL:   mainflux.Env(envNatsURL, defNatsURL),
+		LogLevel:  mainflux.Env(envLogLevel, defLogLevel),
+		Port:      mainflux.Env(envPort, defPort),
+	}
+
+}

cmd/influxdb-reader/main.go

@@ -0,0 +1,148 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	influxdata "github.com/influxdata/influxdb/client/v2"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/readers"
+	"github.com/mainflux/mainflux/readers/api"
+	"github.com/mainflux/mainflux/readers/influxdb"
+	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
+)
+
+const (
+	defThingsURL = "localhost:8181"
+	defLogLevel  = "error"
+	defPort      = "8180"
+	defDBName    = "mainflux"
+	defDBHost    = "localhost"
+	defDBPort    = "8086"
+	defDBUser    = "mainflux"
+	defDBPass    = "mainflux"
+
+	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"
+)
+
+type config struct {
+	ThingsURL string
+	LogLevel  string
+	Port      string
+	DBName    string
+	DBHost    string
+	DBPort    string
+	DBUser    string
+	DBPass    string
+}
+
+func main() {
+	cfg, clientCfg := loadConfigs()
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+	conn := connectToThings(cfg.ThingsURL, logger)
+	defer conn.Close()
+
+	tc := thingsapi.NewClient(conn)
+
+	client, err := influxdata.NewHTTPClient(clientCfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to create InfluxDB client: %s", err))
+		os.Exit(1)
+	}
+	defer client.Close()
+
+	repo, err := influxdb.New(client, cfg.DBName)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to create InfluxDB writer: %s", err))
+		os.Exit(1)
+	}
+
+	errs := make(chan error, 2)
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	go startHTTPServer(repo, tc, cfg.Port, logger, errs)
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("InfluxDB writer service terminated: %s", err))
+}
+
+func loadConfigs() (config, influxdata.HTTPConfig) {
+	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),
+	}
+
+	clientCfg := influxdata.HTTPConfig{
+		Addr:     fmt.Sprintf("http://%s:%s", cfg.DBHost, cfg.DBPort),
+		Username: cfg.DBUser,
+		Password: cfg.DBPass,
+	}
+
+	return cfg, clientCfg
+}
+
+func connectToThings(url string, logger logger.Logger) *grpc.ClientConn {
+	conn, err := grpc.Dial(url, grpc.WithInsecure())
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
+		os.Exit(1)
+	}
+
+	return conn
+}
+
+func newService(client influxdata.Client, logger logger.Logger) readers.MessageRepository {
+	repo, _ := influxdb.New(client, "mainflux")
+	repo = api.LoggingMiddleware(repo, logger)
+	repo = api.MetricsMiddleware(
+		repo,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "influxdb",
+			Subsystem: "message_reader",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "influxdb",
+			Subsystem: "message_reader",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+
+	return repo
+}
+
+func startHTTPServer(repo readers.MessageRepository, tc mainflux.ThingsServiceClient, port string, logger logger.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("InfluxDB reader service started, exposed port %s", port))
+	errs <- http.ListenAndServe(p, api.MakeHandler(repo, tc, "influxdb-reader"))
+}

cmd/influxdb-writer/main.go

@@ -0,0 +1,174 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	influxdata "github.com/influxdata/influxdb/client/v2"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/writers"
+	"github.com/mainflux/mainflux/writers/influxdb"
+	"github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	queue = "influxdb-writer"
+
+	defNatsURL      = nats.DefaultURL
+	defLogLevel     = "error"
+	defPort         = "8180"
+	defBatchSize    = "5000"
+	defBatchTimeout = "5"
+	defDBName       = "mainflux"
+	defDBHost       = "localhost"
+	defDBPort       = "8086"
+	defDBUser       = "mainflux"
+	defDBPass       = "mainflux"
+
+	envNatsURL      = "MF_NATS_URL"
+	envLogLevel     = "MF_INFLUX_WRITER_LOG_LEVEL"
+	envPort         = "MF_INFLUX_WRITER_PORT"
+	envBatchSize    = "MF_INFLUX_WRITER_BATCH_SIZE"
+	envBatchTimeout = "MF_INFLUX_WRITER_BATCH_TIMEOUT"
+	envDBName       = "MF_INFLUX_WRITER_DB_NAME"
+	envDBHost       = "MF_INFLUX_WRITER_DB_HOST"
+	envDBPort       = "MF_INFLUX_WRITER_DB_PORT"
+	envDBUser       = "MF_INFLUX_WRITER_DB_USER"
+	envDBPass       = "MF_INFLUX_WRITER_DB_PASS"
+)
+
+type config struct {
+	NatsURL      string
+	LogLevel     string
+	Port         string
+	BatchSize    string
+	BatchTimeout string
+	DBName       string
+	DBHost       string
+	DBPort       string
+	DBUser       string
+	DBPass       string
+}
+
+func main() {
+	cfg, clientCfg := loadConfigs()
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+	nc, err := nats.Connect(cfg.NatsURL)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
+		os.Exit(1)
+	}
+	defer nc.Close()
+
+	client, err := influxdata.NewHTTPClient(clientCfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to create InfluxDB client: %s", err))
+		os.Exit(1)
+	}
+	defer client.Close()
+
+	batchTimeout, err := strconv.Atoi(cfg.BatchTimeout)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Invalid value for batch timeout: %s", err))
+		os.Exit(1)
+	}
+
+	batchSize, err := strconv.Atoi(cfg.BatchSize)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Invalid value of batch size: %s", err))
+		os.Exit(1)
+	}
+
+	timeout := time.Duration(batchTimeout) * time.Second
+	repo, err := influxdb.New(client, cfg.DBName, batchSize, timeout)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to create InfluxDB writer: %s", err))
+		os.Exit(1)
+	}
+
+	counter, latency := makeMetrics()
+	repo = writers.LoggingMiddleware(repo, logger)
+	repo = writers.MetricsMiddleware(repo, counter, latency)
+	if err := writers.Start(nc, repo, queue, logger); err != nil {
+		logger.Error(fmt.Sprintf("Failed to start message writer: %s", err))
+		os.Exit(1)
+	}
+
+	errs := make(chan error, 2)
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	go startHTTPService(cfg.Port, logger, errs)
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("InfluxDB writer service terminated: %s", err))
+}
+
+func loadConfigs() (config, influxdata.HTTPConfig) {
+	cfg := config{
+		NatsURL:      mainflux.Env(envNatsURL, defNatsURL),
+		LogLevel:     mainflux.Env(envLogLevel, defLogLevel),
+		Port:         mainflux.Env(envPort, defPort),
+		BatchSize:    mainflux.Env(envBatchSize, defBatchSize),
+		BatchTimeout: mainflux.Env(envBatchTimeout, defBatchTimeout),
+		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),
+	}
+
+	clientCfg := influxdata.HTTPConfig{
+		Addr:     fmt.Sprintf("http://%s:%s", cfg.DBHost, cfg.DBPort),
+		Username: cfg.DBUser,
+		Password: cfg.DBPass,
+	}
+
+	return cfg, clientCfg
+}
+
+func makeMetrics() (*kitprometheus.Counter, *kitprometheus.Summary) {
+	counter := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+		Namespace: "influxdb",
+		Subsystem: "message_writer",
+		Name:      "request_count",
+		Help:      "Number of database inserts.",
+	}, []string{"method"})
+
+	latency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+		Namespace: "influxdb",
+		Subsystem: "message_writer",
+		Name:      "request_latency_microseconds",
+		Help:      "Total duration of inserts in microseconds.",
+	}, []string{"method"})
+
+	return counter, latency
+}
+
+func startHTTPService(port string, logger logger.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("InfluxDB writer service started, exposed port %s", p))
+	errs <- http.ListenAndServe(p, influxdb.MakeHandler())
+}

cmd/influxdb/main.go

@@ -1,139 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-
-	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
-	influxdata "github.com/influxdata/influxdb/client/v2"
-	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mainflux/writers"
-	"github.com/mainflux/mainflux/writers/influxdb"
-	nats "github.com/nats-io/go-nats"
-	stdprometheus "github.com/prometheus/client_golang/prometheus"
-)
-
-const (
-	name         = "influxdb-writer"
-	senML        = "out.senml"
-	prefix       = "http://"
-	defNatsURL   = nats.DefaultURL
-	defPort      = "8180"
-	defPointName = "messages"
-	defDBName    = "mainflux"
-	defDBHost    = "localhost"
-	defDBPort    = "8086"
-	defDBUser    = "mainflux"
-	defDBPass    = "mainflux"
-
-	envNatsURL = "MF_NATS_URL"
-	envPort    = "MF_INFLUX_WRITER_PORT"
-	envDBName  = "MF_INFLUX_WRITER_DB_NAME"
-	envDBHost  = "MF_INFLUX_WRITER_DB_HOST"
-	envDBPort  = "MF_INFLUX_WRITER_DB_PORT"
-	envDBUser  = "MF_INFLUX_WRITER_DB_USER"
-	envDBPass  = "MF_INFLUX_WRITER_DB_PASS"
-)
-
-type config struct {
-	NatsURL string
-	Port    string
-	DBName  string
-	DBHost  string
-	DBPort  string
-	DBUser  string
-	DBPass  string
-}
-
-func main() {
-	cfg, clientCfg := loadConfigs()
-	logger := log.New(os.Stdout)
-
-	nc, err := nats.Connect(cfg.NatsURL)
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
-		os.Exit(1)
-	}
-	defer nc.Close()
-
-	client, err := influxdata.NewHTTPClient(clientCfg)
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to create InfluxDB client: %s", err))
-		os.Exit(1)
-	}
-	defer client.Close()
-
-	repo, err := influxdb.New(client, cfg.DBName)
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to create InfluxDB writer: %s", err))
-		os.Exit(1)
-	}
-
-	counter, latency := makeMetrics()
-	repo = writers.LoggingMiddleware(repo, logger)
-	repo = writers.MetricsMiddleware(repo, counter, latency)
-	if err := writers.Start(name, nc, logger, repo); err != nil {
-		logger.Error(fmt.Sprintf("Failed to start message writer: %s", err))
-		os.Exit(1)
-	}
-
-	errs := make(chan error, 2)
-	go func() {
-		c := make(chan os.Signal)
-		signal.Notify(c, syscall.SIGINT)
-		errs <- fmt.Errorf("%s", <-c)
-	}()
-
-	go startHTTPService(cfg.Port, logger, errs)
-
-	err = <-errs
-	logger.Error(fmt.Sprintf("InfluxDB writer service terminated: %s", err))
-}
-
-func loadConfigs() (config, influxdata.HTTPConfig) {
-	cfg := config{
-		NatsURL: mainflux.Env(envNatsURL, defNatsURL),
-		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),
-	}
-
-	clientCfg := influxdata.HTTPConfig{
-		Addr:     fmt.Sprintf("%s%s:%s", prefix, cfg.DBHost, cfg.DBPort),
-		Username: cfg.DBUser,
-		Password: cfg.DBPass,
-	}
-
-	return cfg, clientCfg
-}
-
-func makeMetrics() (*kitprometheus.Counter, *kitprometheus.Summary) {
-	counter := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
-		Namespace: "influxdb",
-		Subsystem: "message_writer",
-		Name:      "request_count",
-		Help:      "Number of database inserts.",
-	}, []string{"method"})
-
-	latency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
-		Namespace: "influxdb",
-		Subsystem: "message_writer",
-		Name:      "request_latency_microseconds",
-		Help:      "Total duration of inserts in microseconds.",
-	}, []string{"method"})
-
-	return counter, latency
-}
-
-func startHTTPService(port string, logger log.Logger, errs chan error) {
-	p := fmt.Sprintf(":%s", port)
-	logger.Info(fmt.Sprintf("Influxdb writer service started, exposed port %s", p))
-	errs <- http.ListenAndServe(p, influxdb.MakeHandler())
-}

cmd/mongodb-reader/main.go

@@ -0,0 +1,141 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/readers"
+	"github.com/mainflux/mainflux/readers/api"
+	"github.com/mainflux/mainflux/readers/mongodb"
+	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
+	"github.com/mongodb/mongo-go-driver/mongo"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
+)
+
+const (
+	defThingsURL = "localhost:8181"
+	defLogLevel  = "error"
+	defPort      = "8180"
+	defDBName    = "mainflux"
+	defDBHost    = "localhost"
+	defDBPort    = "27017"
+
+	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"
+)
+
+type config struct {
+	thingsURL string
+	logLevel  string
+	port      string
+	dbName    string
+	dbHost    string
+	dbPort    string
+}
+
+func main() {
+	cfg := loadConfigs()
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+	conn := connectToThings(cfg.thingsURL, logger)
+	defer conn.Close()
+
+	tc := thingsapi.NewClient(conn)
+
+	db := connectToMongoDB(cfg.dbHost, cfg.dbPort, cfg.dbName, logger)
+
+	repo := newService(db, logger)
+
+	errs := make(chan error, 2)
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	go startHTTPServer(repo, tc, cfg.port, logger, errs)
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("MongoDB reader service terminated: %s", err))
+}
+
+func loadConfigs() config {
+	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),
+	}
+}
+
+func connectToMongoDB(host, port, name string, logger logger.Logger) *mongo.Database {
+	client, err := mongo.Connect(context.Background(), fmt.Sprintf("mongodb://%s:%s", host, port), nil)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to database: %s", err))
+		os.Exit(1)
+	}
+
+	return client.Database(name)
+}
+
+func connectToThings(url string, logger logger.Logger) *grpc.ClientConn {
+	conn, err := grpc.Dial(url, grpc.WithInsecure())
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
+		os.Exit(1)
+	}
+
+	return conn
+}
+
+func newService(db *mongo.Database, logger logger.Logger) readers.MessageRepository {
+	repo := mongodb.New(db)
+	repo = api.LoggingMiddleware(repo, logger)
+	repo = api.MetricsMiddleware(
+		repo,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "mongodb",
+			Subsystem: "message_reader",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "mongodb",
+			Subsystem: "message_reader",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+
+	return repo
+}
+
+func startHTTPServer(repo readers.MessageRepository, tc mainflux.ThingsServiceClient, port string, logger logger.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("Mongo reader service started, exposed port %s", port))
+	errs <- http.ListenAndServe(p, api.MakeHandler(repo, tc, "cassandra-reader"))
+}

cmd/mongodb-writer/main.go

@@ -1,8 +1,16 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"context"
 	"fmt"
+	"log"
 	"net/http"
 	"os"
 	"os/signal"
@@ -10,41 +18,47 @@ import (
 
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/logger"
 	"github.com/mainflux/mainflux/writers"
-	mongodb "github.com/mainflux/mainflux/writers/mongodb"
+	"github.com/mainflux/mainflux/writers/mongodb"
 	"github.com/mongodb/mongo-go-driver/mongo"
-	nats "github.com/nats-io/go-nats"
+	"github.com/nats-io/go-nats"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
 )
 
 const (
-	name       = "mongodb-writer"
-	defNatsURL = nats.DefaultURL
-	defPort    = "8180"
-	defDBName  = "mainflux"
-	defDBHost  = "localhost"
-	defDBPort  = "27017"
+	queue = "mongodb-writer"
 
-	envNatsURL = "MF_NATS_URL"
-	envPort    = "MF_MONGO_WRITER_PORT"
-	envDBName  = "MF_MONGO_WRITER_DB_NAME"
-	envDBHost  = "MF_MONGO_WRITER_DB_HOST"
-	envDBPort  = "MF_MONGO_WRITER_DB_PORT"
+	defNatsURL  = nats.DefaultURL
+	defLogLevel = "error"
+	defPort     = "8180"
+	defDBName   = "mainflux"
+	defDBHost   = "localhost"
+	defDBPort   = "27017"
+
+	envNatsURL  = "MF_NATS_URL"
+	envLogLevel = "MF_MONGO_WRITER_LOG_LEVEL"
+	envPort     = "MF_MONGO_WRITER_PORT"
+	envDBName   = "MF_MONGO_WRITER_DB_NAME"
+	envDBHost   = "MF_MONGO_WRITER_DB_HOST"
+	envDBPort   = "MF_MONGO_WRITER_DB_PORT"
 )
 
 type config struct {
-	NatsURL string
-	Port    string
-	DBName  string
-	DBHost  string
-	DBPort  string
+	NatsURL  string
+	LogLevel string
+	Port     string
+	DBName   string
+	DBHost   string
+	DBPort   string
 }
 
 func main() {
 	cfg := loadConfigs()
-	logger := log.New(os.Stdout)
-
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
 	nc, err := nats.Connect(cfg.NatsURL)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
@@ -59,16 +73,12 @@ func main() {
 	}
 
 	db := client.Database(cfg.DBName)
-	repo, err := mongodb.New(db)
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to create MongoDB writer: %s", err))
-		os.Exit(1)
-	}
+	repo := mongodb.New(db)
 
 	counter, latency := makeMetrics()
 	repo = writers.LoggingMiddleware(repo, logger)
 	repo = writers.MetricsMiddleware(repo, counter, latency)
-	if err := writers.Start(name, nc, logger, repo); err != nil {
+	if err := writers.Start(nc, repo, queue, logger); err != nil {
 		logger.Error(fmt.Sprintf("Failed to start message writer: %s", err))
 		os.Exit(1)
 	}
@@ -88,11 +98,12 @@ func main() {
 
 func loadConfigs() config {
 	return config{
-		NatsURL: mainflux.Env(envNatsURL, defNatsURL),
-		Port:    mainflux.Env(envPort, defPort),
-		DBName:  mainflux.Env(envDBName, defDBName),
-		DBHost:  mainflux.Env(envDBHost, defDBHost),
-		DBPort:  mainflux.Env(envDBPort, defDBPort),
+		NatsURL:  mainflux.Env(envNatsURL, defNatsURL),
+		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),
 	}
 }
 
@@ -114,7 +125,7 @@ func makeMetrics() (*kitprometheus.Counter, *kitprometheus.Summary) {
 	return counter, latency
 }
 
-func startHTTPService(port string, logger log.Logger, errs chan error) {
+func startHTTPService(port string, logger logger.Logger, errs chan error) {
 	p := fmt.Sprintf(":%s", port)
 	logger.Info(fmt.Sprintf("Mongodb writer service started, exposed port %s", p))
 	errs <- http.ListenAndServe(p, mongodb.MakeHandler())

cmd/normalizer/main.go

@@ -1,54 +1,84 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 	"os"
 	"os/signal"
 	"syscall"
 
 	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/logger"
 	"github.com/mainflux/mainflux/normalizer"
-	nats "github.com/nats-io/go-nats"
+	"github.com/mainflux/mainflux/normalizer/api"
+	"github.com/mainflux/mainflux/normalizer/nats"
+	broker "github.com/nats-io/go-nats"
 
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
 )
 
 const (
-	defNatsURL string = nats.DefaultURL
-	defPort    string = "8180"
-	envNatsURL string = "MF_NATS_URL"
-	envPort    string = "MF_NORMALIZER_PORT"
+	defNatsURL  string = broker.DefaultURL
+	defLogLevel string = "error"
+	defPort     string = "8180"
+	envNatsURL  string = "MF_NATS_URL"
+	envLogLevel string = "MF_NORMALIZER_LOG_LEVEL"
+	envPort     string = "MF_NORMALIZER_PORT"
 )
 
 type config struct {
-	NatsURL string
-	Port    string
+	NatsURL  string
+	LogLevel string
+	Port     string
 }
 
 func main() {
-	cfg := config{
-		NatsURL: mainflux.Env(envNatsURL, defNatsURL),
-		Port:    mainflux.Env(envPort, defPort),
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
 	}
-
-	logger := log.New(os.Stdout)
-
-	nc, err := nats.Connect(cfg.NatsURL)
+	nc, err := broker.Connect(cfg.NatsURL)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
 		os.Exit(1)
 	}
 	defer nc.Close()
 
+	svc := normalizer.New()
+	svc = api.LoggingMiddleware(svc, logger)
+	svc = api.MetricsMiddleware(
+		svc,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "normalizer",
+			Subsystem: "api",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "normalizer",
+			Subsystem: "api",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+
 	errs := make(chan error, 2)
 
 	go func() {
 		p := fmt.Sprintf(":%s", cfg.Port)
 		logger.Info(fmt.Sprintf("Normalizer service started, exposed port %s", cfg.Port))
-		errs <- http.ListenAndServe(p, normalizer.MakeHandler())
+		errs <- http.ListenAndServe(p, api.MakeHandler())
 	}()
 
 	go func() {
@@ -57,22 +87,16 @@ func main() {
 		errs <- fmt.Errorf("%s", <-c)
 	}()
 
-	counter := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
-		Namespace: "normalizer",
-		Subsystem: "api",
-		Name:      "request_count",
-		Help:      "Number of requests received.",
-	}, []string{"method"})
-
-	latency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
-		Namespace: "normalizer",
-		Subsystem: "api",
-		Name:      "request_latency_microseconds",
-		Help:      "Total duration of requests in microseconds.",
-	}, []string{"method"})
-
-	normalizer.Subscribe(nc, logger, counter, latency)
+	nats.Subscribe(svc, nc, logger)
 
 	err = <-errs
 	logger.Error(fmt.Sprintf("Normalizer service terminated: %s", err))
 }
+
+func loadConfig() config {
+	return config{
+		NatsURL:  mainflux.Env(envNatsURL, defNatsURL),
+		LogLevel: mainflux.Env(envLogLevel, defLogLevel),
+		Port:     mainflux.Env(envPort, defPort),
+	}
+}

cmd/things/main.go

@@ -1,22 +1,33 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"database/sql"
 	"fmt"
+	"log"
 	"net"
 	"net/http"
 	"os"
 	"os/signal"
+	"strconv"
 	"syscall"
 
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/go-redis/redis"
 	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/logger"
 	"github.com/mainflux/mainflux/things"
 	"github.com/mainflux/mainflux/things/api"
 	grpcapi "github.com/mainflux/mainflux/things/api/grpc"
 	httpapi "github.com/mainflux/mainflux/things/api/http"
 	"github.com/mainflux/mainflux/things/postgres"
+	rediscache "github.com/mainflux/mainflux/things/redis"
 	"github.com/mainflux/mainflux/things/uuid"
 	usersapi "github.com/mainflux/mainflux/users/api/grpc"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
@@ -24,39 +35,55 @@ import (
 )
 
 const (
-	defDBHost   = "localhost"
-	defDBPort   = "5432"
-	defDBUser   = "mainflux"
-	defDBPass   = "mainflux"
-	defDBName   = "things"
-	defHTTPPort = "8180"
-	defGRPCPort = "8181"
-	defUsersURL = "localhost:8181"
-	envDBHost   = "MF_THINGS_DB_HOST"
-	envDBPort   = "MF_THINGS_DB_PORT"
-	envDBUser   = "MF_THINGS_DB_USER"
-	envDBPass   = "MF_THINGS_DB_PASS"
-	envDBName   = "MF_THINGS_DB"
-	envHTTPPort = "MF_THINGS_HTTP_PORT"
-	envGRPCPort = "MF_THINGS_GRPC_PORT"
-	envUsersURL = "MF_USERS_URL"
+	defLogLevel  = "error"
+	defDBHost    = "localhost"
+	defDBPort    = "5432"
+	defDBUser    = "mainflux"
+	defDBPass    = "mainflux"
+	defDBName    = "things"
+	defCacheURL  = "localhost:6379"
+	defCachePass = ""
+	defCacheDB   = "0"
+	defHTTPPort  = "8180"
+	defGRPCPort  = "8181"
+	defUsersURL  = "localhost:8181"
+	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"
+	envCacheURL  = "MF_THINGS_CACHE_URL"
+	envCachePass = "MF_THINGS_CACHE_PASS"
+	envCacheDB   = "MF_THINGS_CACHE_DB"
+	envHTTPPort  = "MF_THINGS_HTTP_PORT"
+	envGRPCPort  = "MF_THINGS_GRPC_PORT"
+	envUsersURL  = "MF_USERS_URL"
 )
 
 type config struct {
-	DBHost   string
-	DBPort   string
-	DBUser   string
-	DBPass   string
-	DBName   string
-	HTTPPort string
-	GRPCPort string
-	UsersURL string
+	LogLevel  string
+	DBHost    string
+	DBPort    string
+	DBUser    string
+	DBPass    string
+	DBName    string
+	CacheURL  string
+	CachePass string
+	CacheDB   string
+	HTTPPort  string
+	GRPCPort  string
+	UsersURL  string
 }
 
 func main() {
 	cfg := loadConfig()
 
-	logger := log.New(os.Stdout)
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+	cache := connectToCache(cfg.CacheURL, cfg.CachePass, cfg.CacheDB, logger)
 
 	db := connectToDB(cfg, logger)
 	defer db.Close()
@@ -64,7 +91,7 @@ func main() {
 	conn := connectToUsersService(cfg.UsersURL, logger)
 	defer conn.Close()
 
-	svc := newService(conn, db, logger)
+	svc := newService(conn, db, cache, logger)
 	errs := make(chan error, 2)
 
 	go startHTTPServer(svc, cfg.HTTPPort, logger, errs)
@@ -76,24 +103,43 @@ func main() {
 		errs <- fmt.Errorf("%s", <-c)
 	}()
 
-	err := <-errs
+	err = <-errs
 	logger.Error(fmt.Sprintf("Things service terminated: %s", err))
 }
 
 func loadConfig() config {
 	return config{
-		DBHost:   mainflux.Env(envDBHost, defDBHost),
-		DBPort:   mainflux.Env(envDBPort, defDBPort),
-		DBUser:   mainflux.Env(envDBUser, defDBUser),
-		DBPass:   mainflux.Env(envDBPass, defDBPass),
-		DBName:   mainflux.Env(envDBName, defDBName),
-		HTTPPort: mainflux.Env(envHTTPPort, defHTTPPort),
-		GRPCPort: mainflux.Env(envGRPCPort, defGRPCPort),
-		UsersURL: mainflux.Env(envUsersURL, defUsersURL),
+		LogLevel:  mainflux.Env(envLogLevel, defLogLevel),
+		DBHost:    mainflux.Env(envDBHost, defDBHost),
+		DBPort:    mainflux.Env(envDBPort, defDBPort),
+		DBUser:    mainflux.Env(envDBUser, defDBUser),
+		DBPass:    mainflux.Env(envDBPass, defDBPass),
+		DBName:    mainflux.Env(envDBName, defDBName),
+		CacheURL:  mainflux.Env(envCacheURL, defCacheURL),
+		CachePass: mainflux.Env(envCachePass, defCachePass),
+		CacheDB:   mainflux.Env(envCacheDB, defCacheDB),
+		HTTPPort:  mainflux.Env(envHTTPPort, defHTTPPort),
+		GRPCPort:  mainflux.Env(envGRPCPort, defGRPCPort),
+		UsersURL:  mainflux.Env(envUsersURL, defUsersURL),
 	}
 }
 
-func connectToDB(cfg config, logger log.Logger) *sql.DB {
+func connectToCache(cacheURL, cachePass string, cacheDB string, logger logger.Logger) *redis.Client {
+
+	db, err := strconv.Atoi(cacheDB)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to cache: %s", err))
+		os.Exit(1)
+	}
+
+	return redis.NewClient(&redis.Options{
+		Addr:     cacheURL,
+		Password: cachePass,
+		DB:       db,
+	})
+}
+
+func connectToDB(cfg config, logger logger.Logger) *sql.DB {
 	db, err := postgres.Connect(cfg.DBHost, cfg.DBPort, cfg.DBName, cfg.DBUser, cfg.DBPass)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to connect to postgres: %s", err))
@@ -102,7 +148,7 @@ func connectToDB(cfg config, logger log.Logger) *sql.DB {
 	return db
 }
 
-func connectToUsersService(usersAddr string, logger log.Logger) *grpc.ClientConn {
+func connectToUsersService(usersAddr string, logger logger.Logger) *grpc.ClientConn {
 	conn, err := grpc.Dial(usersAddr, grpc.WithInsecure())
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
@@ -111,13 +157,15 @@ func connectToUsersService(usersAddr string, logger log.Logger) *grpc.ClientConn
 	return conn
 }
 
-func newService(conn *grpc.ClientConn, db *sql.DB, logger log.Logger) things.Service {
+func newService(conn *grpc.ClientConn, db *sql.DB, client *redis.Client, logger logger.Logger) things.Service {
 	users := usersapi.NewClient(conn)
 	thingsRepo := postgres.NewThingRepository(db, logger)
 	channelsRepo := postgres.NewChannelRepository(db, logger)
+	chanCache := rediscache.NewChannelCache(client)
+	thingCache := rediscache.NewThingCache(client)
 	idp := uuid.New()
 
-	svc := things.New(users, thingsRepo, channelsRepo, idp)
+	svc := things.New(users, thingsRepo, channelsRepo, chanCache, thingCache, idp)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(
 		svc,
@@ -137,13 +185,13 @@ func newService(conn *grpc.ClientConn, db *sql.DB, logger log.Logger) things.Ser
 	return svc
 }
 
-func startHTTPServer(svc things.Service, port string, logger log.Logger, errs chan error) {
+func startHTTPServer(svc things.Service, port string, logger logger.Logger, errs chan error) {
 	p := fmt.Sprintf(":%s", port)
 	logger.Info(fmt.Sprintf("Things service started, exposed port %s", port))
 	errs <- http.ListenAndServe(p, httpapi.MakeHandler(svc))
 }
 
-func startGRPCServer(svc things.Service, port string, logger log.Logger, errs chan error) {
+func startGRPCServer(svc things.Service, port string, logger logger.Logger, errs chan error) {
 	p := fmt.Sprintf(":%s", port)
 	listener, err := net.Listen("tcp", p)
 	if err != nil {

cmd/users/main.go

@@ -1,8 +1,16 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"database/sql"
 	"fmt"
+	"log"
 	"net"
 	"net/http"
 	"os"
@@ -11,7 +19,7 @@ import (
 
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/logger"
 	"github.com/mainflux/mainflux/users"
 	"github.com/mainflux/mainflux/users/api"
 	grpcapi "github.com/mainflux/mainflux/users/api/grpc"
@@ -24,6 +32,7 @@ import (
 )
 
 const (
+	defLogLevel = "error"
 	defDBHost   = "localhost"
 	defDBPort   = "5432"
 	defDBUser   = "mainflux"
@@ -32,6 +41,7 @@ const (
 	defHTTPPort = "8180"
 	defGRPCPort = "8181"
 	defSecret   = "users"
+	envLogLevel = "MF_USERS_LOG_LEVEL"
 	envDBHost   = "MF_USERS_DB_HOST"
 	envDBPort   = "MF_USERS_DB_PORT"
 	envDBUser   = "MF_USERS_DB_USER"
@@ -43,6 +53,7 @@ const (
 )
 
 type config struct {
+	LogLevel string
 	DBHost   string
 	DBPort   string
 	DBUser   string
@@ -56,8 +67,10 @@ type config struct {
 func main() {
 	cfg := loadConfig()
 
-	logger := log.New(os.Stdout)
-
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
 	db := connectToDB(cfg, logger)
 	defer db.Close()
 
@@ -73,12 +86,13 @@ func main() {
 		errs <- fmt.Errorf("%s", <-c)
 	}()
 
-	err := <-errs
+	err = <-errs
 	logger.Error(fmt.Sprintf("Users service terminated: %s", err))
 }
 
 func loadConfig() config {
 	return config{
+		LogLevel: mainflux.Env(envLogLevel, defLogLevel),
 		DBHost:   mainflux.Env(envDBHost, defDBHost),
 		DBPort:   mainflux.Env(envDBPort, defDBPort),
 		DBUser:   mainflux.Env(envDBUser, defDBUser),
@@ -90,7 +104,7 @@ func loadConfig() config {
 	}
 }
 
-func connectToDB(cfg config, logger log.Logger) *sql.DB {
+func connectToDB(cfg config, logger logger.Logger) *sql.DB {
 	db, err := postgres.Connect(cfg.DBHost, cfg.DBPort, cfg.DBName, cfg.DBUser, cfg.DBPass)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to connect to postgres: %s", err))
@@ -99,7 +113,7 @@ func connectToDB(cfg config, logger log.Logger) *sql.DB {
 	return db
 }
 
-func newService(db *sql.DB, secret string, logger log.Logger) users.Service {
+func newService(db *sql.DB, secret string, logger logger.Logger) users.Service {
 	repo := postgres.New(db)
 	hasher := bcrypt.New()
 	idp := jwt.New(secret)
@@ -124,13 +138,13 @@ func newService(db *sql.DB, secret string, logger log.Logger) users.Service {
 	return svc
 }
 
-func startHTTPServer(svc users.Service, port string, logger log.Logger, errs chan error) {
+func startHTTPServer(svc users.Service, port string, logger logger.Logger, errs chan error) {
 	p := fmt.Sprintf(":%s", port)
 	logger.Info(fmt.Sprintf("Users HTTP service started, exposed port %s", port))
 	errs <- http.ListenAndServe(p, httpapi.MakeHandler(svc, logger))
 }
 
-func startGRPCServer(svc users.Service, port string, logger log.Logger, errs chan error) {
+func startGRPCServer(svc users.Service, port string, logger logger.Logger, errs chan error) {
 	p := fmt.Sprintf(":%s", port)
 	listener, err := net.Listen("tcp", p)
 	if err != nil {

cmd/ws/main.go

@@ -1,7 +1,15 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 	"os"
 	"os/signal"
@@ -9,7 +17,7 @@ import (
 
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/logger"
 	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
 	adapter "github.com/mainflux/mainflux/ws"
 	"github.com/mainflux/mainflux/ws/api"
@@ -21,9 +29,11 @@ import (
 
 const (
 	defPort      = "8180"
+	defLogLevel  = "error"
 	defNatsURL   = broker.DefaultURL
 	defThingsURL = "localhost:8181"
 	envPort      = "MF_WS_ADAPTER_PORT"
+	envLogLevel  = "MF_WS_ADAPTER_LOG_LEVEL"
 	envNatsURL   = "MF_NATS_URL"
 	envThingsURL = "MF_THINGS_URL"
 )
@@ -31,18 +41,17 @@ const (
 type config struct {
 	ThingsURL string
 	NatsURL   string
+	LogLevel  string
 	Port      string
 }
 
 func main() {
-	cfg := config{
-		ThingsURL: mainflux.Env(envThingsURL, defThingsURL),
-		NatsURL:   mainflux.Env(envNatsURL, defNatsURL),
-		Port:      mainflux.Env(envPort, defPort),
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
 	}
-
-	logger := log.New(os.Stdout)
-
 	nc, err := broker.Connect(cfg.NatsURL)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
@@ -94,3 +103,12 @@ func main() {
 	err = <-errs
 	logger.Error(fmt.Sprintf("WebSocket adapter terminated: %s", err))
 }
+
+func loadConfig() config {
+	return config{
+		ThingsURL: mainflux.Env(envThingsURL, defThingsURL),
+		NatsURL:   mainflux.Env(envNatsURL, defNatsURL),
+		LogLevel:  mainflux.Env(envLogLevel, defLogLevel),
+		Port:      mainflux.Env(envPort, defPort),
+	}
+}

coap/README.md

@@ -0,0 +1,61 @@
+# Mainflux CoAP Adapter
+
+Mainflux CoAP adapter provides an [CoAP](http://coap.technology/) API for sending messages through the
+platform.
+
+## Configuration
+
+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_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                 |
+
+## Deployment
+
+The service is distributed as Docker container. The following snippet provides
+a compose file template that can be used to deploy the service container locally:
+
+```yaml
+version: "2"
+services:
+  adapter:
+    image: mainflux/coap:[version]
+    container_name: [instance name]
+    ports:
+      - [host machine port]:[configured port]
+    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]
+```
+
+Running this service outside of container requires working instance of the NATS service.
+To start the service outside of the container, execute the following shell script:
+
+```bash
+# download the latest version of the service
+go get github.com/mainflux/mainflux
+
+cd $GOPATH/src/github.com/mainflux/mainflux
+
+# compile the http
+make coap
+
+# copy binary to bin
+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] $GOBIN/mainflux-coap
+```
+
+## Usage
+
+Since CoAP protocol does not support `Authorization` header (option), in order to send CoAP messages,
+client valid `authorization` value must be present in `Uri-Query` option.

coap/adapter.go

@@ -0,0 +1,150 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// Package coap contains the domain concept definitions needed to support
+// Mainflux coap adapter service functionality. All constant values are taken
+// from RFC, and could be adjusted based on specific use case.
+package coap
+
+import (
+	"errors"
+	"sync"
+	"time"
+
+	"github.com/mainflux/mainflux"
+	broker "github.com/nats-io/go-nats"
+)
+
+const (
+	chanID    = "id"
+	keyHeader = "key"
+
+	// AckRandomFactor is default ACK coefficient.
+	AckRandomFactor = 1.5
+	// AckTimeout is the amount of time to wait for a response.
+	AckTimeout = 2000 * time.Millisecond
+	// MaxRetransmit is the maximum number of times a message will be retransmitted.
+	MaxRetransmit = 4
+)
+
+var (
+	errBadOption = errors.New("bad option")
+	// ErrFailedMessagePublish indicates that message publishing failed.
+	ErrFailedMessagePublish = errors.New("failed to publish message")
+
+	// ErrFailedSubscription indicates that client couldn't subscribe to specified channel.
+	ErrFailedSubscription = errors.New("failed to subscribe to a channel")
+
+	// ErrFailedConnection indicates that service couldn't connect to message broker.
+	ErrFailedConnection = errors.New("failed to connect to message broker")
+)
+
+// Broker represents NATS broker instance.
+type Broker interface {
+	mainflux.MessagePublisher
+
+	// Subscribes to channel with specified id and adds subscription to
+	// service map of subscriptions under given ID.
+	Subscribe(uint64, string, *Observer) error
+}
+
+// Service specifies coap service API.
+type Service interface {
+	Broker
+	// Unsubscribe method is used to stop observing resource.
+	Unsubscribe(string)
+}
+
+var _ Service = (*adapterService)(nil)
+
+type adapterService struct {
+	pubsub  Broker
+	obs     map[string]*Observer
+	obsLock sync.Mutex
+}
+
+// New instantiates the CoAP adapter implementation.
+func New(pubsub Broker, responses <-chan string) Service {
+	as := &adapterService{
+		pubsub:  pubsub,
+		obs:     make(map[string]*Observer),
+		obsLock: sync.Mutex{},
+	}
+
+	go as.listenResponses(responses)
+	return as
+}
+
+func (svc *adapterService) get(obsID string) (*Observer, bool) {
+	svc.obsLock.Lock()
+	defer svc.obsLock.Unlock()
+
+	val, ok := svc.obs[obsID]
+	return val, ok
+}
+
+func (svc *adapterService) put(obsID string, o *Observer) {
+	svc.obsLock.Lock()
+	defer svc.obsLock.Unlock()
+
+	val, ok := svc.obs[obsID]
+	if ok {
+		close(val.Cancel)
+	}
+
+	svc.obs[obsID] = o
+}
+
+func (svc *adapterService) remove(obsID string) {
+	svc.obsLock.Lock()
+	defer svc.obsLock.Unlock()
+
+	val, ok := svc.obs[obsID]
+	if ok {
+		close(val.Cancel)
+		delete(svc.obs, obsID)
+	}
+}
+
+// ListenResponses method handles ACK messages received from client.
+func (svc *adapterService) listenResponses(responses <-chan string) {
+	for {
+		id := <-responses
+
+		val, ok := svc.get(id)
+		if ok {
+			val.StoreExpired(false)
+		}
+	}
+}
+
+func (svc *adapterService) Publish(msg mainflux.RawMessage) error {
+	if err := svc.pubsub.Publish(msg); err != nil {
+		switch err {
+		case broker.ErrConnectionClosed, broker.ErrInvalidConnection:
+			return ErrFailedConnection
+		default:
+			return ErrFailedMessagePublish
+		}
+	}
+
+	return nil
+}
+
+func (svc *adapterService) Subscribe(chanID uint64, obsID string, o *Observer) error {
+	if err := svc.pubsub.Subscribe(chanID, obsID, o); err != nil {
+		return ErrFailedSubscription
+	}
+
+	// Put method removes Observer if already exists.
+	svc.put(obsID, o)
+	return nil
+}
+
+func (svc *adapterService) Unsubscribe(obsID string) {
+	svc.remove(obsID)
+}

coap/api/doc.go

@@ -0,0 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// Package api contains API-related concerns: endpoint definitions, middlewares
+// and all resource representations.
+package api

coap/api/logging.go

@@ -0,0 +1,66 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// +build !test
+
+package api
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/coap"
+	log "github.com/mainflux/mainflux/logger"
+)
+
+var _ coap.Service = (*loggingMiddleware)(nil)
+
+type loggingMiddleware struct {
+	logger log.Logger
+	svc    coap.Service
+}
+
+// LoggingMiddleware adds logging facilities to the adapter.
+func LoggingMiddleware(svc coap.Service, logger log.Logger) coap.Service {
+	return &loggingMiddleware{logger, svc}
+}
+
+func (lm *loggingMiddleware) Publish(msg mainflux.RawMessage) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method publish to channel %d took %s to complete", msg.Channel, time.Since(begin))
+		if err != nil {
+			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
+			return
+		}
+		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
+	}(time.Now())
+
+	return lm.svc.Publish(msg)
+}
+
+func (lm *loggingMiddleware) Subscribe(chanID uint64, obsID string, o *coap.Observer) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method subscribe to channel %d for client %s took %s to complete", chanID, obsID, time.Since(begin))
+		if err != nil {
+			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
+			return
+		}
+		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
+	}(time.Now())
+
+	return lm.svc.Subscribe(chanID, obsID, o)
+}
+
+func (lm *loggingMiddleware) Unsubscribe(obsID string) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method unsubscribe for the client %s took %s to complete without errors.", obsID, time.Since(begin))
+		lm.logger.Info(fmt.Sprintf(message))
+	}(time.Now())
+
+	lm.svc.Unsubscribe(obsID)
+}

coap/api/metrics.go

@@ -0,0 +1,62 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// +build !test
+
+package api
+
+import (
+	"time"
+
+	"github.com/go-kit/kit/metrics"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/coap"
+)
+
+var _ coap.Service = (*metricsMiddleware)(nil)
+
+type metricsMiddleware struct {
+	counter metrics.Counter
+	latency metrics.Histogram
+	svc     coap.Service
+}
+
+// MetricsMiddleware instruments adapter by tracking request count and latency.
+func MetricsMiddleware(svc coap.Service, counter metrics.Counter, latency metrics.Histogram) coap.Service {
+	return &metricsMiddleware{
+		counter: counter,
+		latency: latency,
+		svc:     svc,
+	}
+}
+
+func (mm *metricsMiddleware) Publish(msg mainflux.RawMessage) error {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "publish").Add(1)
+		mm.latency.With("method", "publish").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.Publish(msg)
+}
+
+func (mm *metricsMiddleware) Subscribe(chanID uint64, clientID string, o *coap.Observer) error {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "subscribe").Add(1)
+		mm.latency.With("method", "subscribe").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.Subscribe(chanID, clientID, o)
+}
+
+func (mm *metricsMiddleware) Unsubscribe(clientID string) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "unsubscribe").Add(1)
+		mm.latency.With("method", "unsubscribe").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	mm.svc.Unsubscribe(clientID)
+}

coap/api/transport.go

@@ -0,0 +1,296 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/go-zoo/bone"
+	"github.com/mainflux/mainflux/coap"
+	log "github.com/mainflux/mainflux/logger"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	mux "github.com/dereulenspiegel/coap-mux"
+	gocoap "github.com/dustin/go-coap"
+	"github.com/mainflux/mainflux"
+)
+
+const protocol = "coap"
+
+var (
+	errBadRequest = errors.New("bad request")
+	errBadOption  = errors.New("bad option")
+	auth          mainflux.ThingsServiceClient
+	logger        log.Logger
+)
+
+type handler func(conn *net.UDPConn, addr *net.UDPAddr, msg *gocoap.Message) *gocoap.Message
+
+func notFoundHandler(l *net.UDPConn, a *net.UDPAddr, m *gocoap.Message) *gocoap.Message {
+	if m.IsConfirmable() {
+		return &gocoap.Message{
+			Type: gocoap.Acknowledgement,
+			Code: gocoap.NotFound,
+		}
+	}
+	return nil
+}
+
+//MakeHTTPHandler creates handler for version endpoint.
+func MakeHTTPHandler() http.Handler {
+	b := bone.New()
+	b.GetFunc("/version", mainflux.Version(protocol))
+	b.Handle("/metrics", promhttp.Handler())
+
+	return b
+}
+
+// MakeCOAPHandler creates handler for CoAP messages.
+func MakeCOAPHandler(svc coap.Service, tc mainflux.ThingsServiceClient, l log.Logger, responses chan<- string) gocoap.Handler {
+	auth = tc
+	logger = l
+
+	r := mux.NewRouter()
+	r.Handle("/channels/{id}/messages", gocoap.FuncHandler(receive(svc))).Methods(gocoap.POST)
+	r.Handle("/channels/{id}/messages", gocoap.FuncHandler(observe(svc, responses)))
+	r.NotFoundHandler = gocoap.FuncHandler(notFoundHandler)
+
+	return r
+}
+
+func authorize(msg *gocoap.Message, res *gocoap.Message, cid uint64) (uint64, error) {
+	// Device Key is passed as Uri-Query parameter, which option ID is 15 (0xf).
+	key, err := authKey(msg.Option(gocoap.URIQuery))
+	if err != nil {
+		switch err {
+		case errBadOption:
+			res.Code = gocoap.BadOption
+		case errBadRequest:
+			res.Code = gocoap.BadRequest
+		}
+
+		return 0, err
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+
+	id, err := auth.CanAccess(ctx, &mainflux.AccessReq{Token: key, ChanID: cid})
+
+	if err != nil {
+		e, ok := status.FromError(err)
+		if ok {
+			switch e.Code() {
+			case codes.PermissionDenied:
+				res.Code = gocoap.Forbidden
+			default:
+				res.Code = gocoap.ServiceUnavailable
+			}
+			return 0, err
+		}
+		res.Code = gocoap.InternalServerError
+	}
+	return id.GetValue(), nil
+}
+
+func receive(svc coap.Service) handler {
+	return func(conn *net.UDPConn, addr *net.UDPAddr, msg *gocoap.Message) *gocoap.Message {
+		// By default message is NonConfirmable, so
+		// NonConfirmable response is sent back.
+		res := &gocoap.Message{
+			Type: gocoap.NonConfirmable,
+			// According to https://tools.ietf.org/html/rfc7252#page-47: If the POST
+			// succeeds but does not result in a new resource being created on the
+			// server, the response SHOULD have a 2.04 (Changed) Response Code.
+			Code:      gocoap.Changed,
+			MessageID: msg.MessageID,
+			Token:     msg.Token,
+			Payload:   []byte{},
+		}
+
+		if msg.IsConfirmable() {
+			res.Type = gocoap.Acknowledgement
+			res.SetOption(gocoap.ContentFormat, gocoap.AppJSON)
+			if len(msg.Payload) == 0 {
+				res.Code = gocoap.BadRequest
+				return res
+			}
+		}
+
+		channelID := mux.Var(msg, "id")
+
+		cid, err := strconv.ParseUint(channelID, 10, 64)
+		if err != nil {
+			res.Code = gocoap.NotFound
+			return res
+		}
+
+		publisher, err := authorize(msg, res, cid)
+		if err != nil {
+			res.Code = gocoap.Forbidden
+			return res
+		}
+
+		rawMsg := mainflux.RawMessage{
+			Channel:   cid,
+			Publisher: publisher,
+			Protocol:  protocol,
+			Payload:   msg.Payload,
+		}
+
+		if err := svc.Publish(rawMsg); err != nil {
+			res.Code = gocoap.InternalServerError
+		}
+
+		return res
+	}
+}
+
+func observe(svc coap.Service, responses chan<- string) handler {
+	return func(conn *net.UDPConn, addr *net.UDPAddr, msg *gocoap.Message) *gocoap.Message {
+		res := &gocoap.Message{
+			Type:      gocoap.Acknowledgement,
+			Code:      gocoap.Content,
+			MessageID: msg.MessageID,
+			Token:     msg.Token,
+			Payload:   []byte{},
+		}
+		res.SetOption(gocoap.ContentFormat, gocoap.AppJSON)
+
+		id := mux.Var(msg, "id")
+		chanID, err := strconv.ParseUint(id, 10, 64)
+		if err != nil {
+			res.Code = gocoap.NotFound
+			return res
+		}
+
+		publisher, err := authorize(msg, res, chanID)
+		if err != nil {
+			res.Code = gocoap.Forbidden
+			logger.Warn(fmt.Sprintf("Failed to authorize: %s", err))
+			return res
+		}
+
+		obsID := fmt.Sprintf("%x-%d-%d", msg.Token, publisher, chanID)
+
+		if msg.Type == gocoap.Acknowledgement {
+			responses <- obsID
+			return nil
+		}
+
+		if value, ok := msg.Option(gocoap.Observe).(uint32); (ok && value == 1) || msg.Type == gocoap.Reset {
+			svc.Unsubscribe(obsID)
+		}
+
+		if value, ok := msg.Option(gocoap.Observe).(uint32); ok && value == 0 {
+			res.AddOption(gocoap.Observe, 1)
+			o := coap.NewObserver()
+			if err := svc.Subscribe(chanID, obsID, o); err != nil {
+				logger.Warn(fmt.Sprintf("Failed to subscribe to NATS subject: %s", err))
+				res.Code = gocoap.InternalServerError
+				return res
+			}
+
+			go handleMessage(conn, addr, o, msg)
+			go ping(svc, obsID, conn, addr, o, msg)
+			go cancel(o)
+		}
+
+		return res
+	}
+}
+
+func cancel(observer *coap.Observer) {
+	<-observer.Cancel
+	close(observer.Messages)
+	observer.StoreExpired(true)
+}
+
+func handleMessage(conn *net.UDPConn, addr *net.UDPAddr, o *coap.Observer, msg *gocoap.Message) {
+	notifyMsg := *msg
+	notifyMsg.Type = gocoap.NonConfirmable
+	notifyMsg.Code = gocoap.Content
+	notifyMsg.RemoveOption(gocoap.URIQuery)
+	for {
+		msg, ok := <-o.Messages
+		if !ok {
+			return
+		}
+		payload, err := json.Marshal(msg)
+		if err != nil {
+			logger.Warn(fmt.Sprintf("Failed to parse received message: %s", err))
+			continue
+		}
+
+		notifyMsg.Payload = payload
+		notifyMsg.MessageID = o.LoadMessageID()
+		buff := new(bytes.Buffer)
+		observe := uint64(notifyMsg.MessageID)
+		if err := binary.Write(buff, binary.BigEndian, observe); err != nil {
+			logger.Warn(fmt.Sprintf("Failed to generate Observe option value: %s", err))
+			continue
+		}
+
+		observeVal := buff.Bytes()
+		notifyMsg.SetOption(gocoap.Observe, observeVal[len(observeVal)-3:])
+
+		if err := gocoap.Transmit(conn, addr, notifyMsg); err != nil {
+			logger.Warn(fmt.Sprintf("Failed to send message to observer: %s", err))
+		}
+	}
+}
+
+func ping(svc coap.Service, obsID string, conn *net.UDPConn, addr *net.UDPAddr, o *coap.Observer, msg *gocoap.Message) {
+	pingMsg := *msg
+	pingMsg.Payload = []byte{}
+	pingMsg.Type = gocoap.Confirmable
+	pingMsg.RemoveOption(gocoap.URIQuery)
+	// According to RFC (https://tools.ietf.org/html/rfc7641#page-18), CON message must be sent at least every
+	// 24 hours. Since 24 hours is too long for our purposes, we use 12.
+	t := time.NewTicker(12 * time.Hour)
+	defer t.Stop()
+	for {
+		select {
+		case _, ok := <-t.C:
+			if !ok || o.LoadExpired() {
+				return
+			}
+
+			o.StoreExpired(true)
+			timeout := float64(coap.AckTimeout)
+			logger.Info(fmt.Sprintf("Ping client %s.", obsID))
+			for i := 0; i < coap.MaxRetransmit; i++ {
+				pingMsg.MessageID = o.LoadMessageID()
+				gocoap.Transmit(conn, addr, pingMsg)
+				time.Sleep(time.Duration(timeout * coap.AckRandomFactor))
+				if !o.LoadExpired() {
+					break
+				}
+				timeout = 2 * timeout
+			}
+
+			if o.LoadExpired() {
+				svc.Unsubscribe(obsID)
+				return
+			}
+		case <-o.Cancel:
+			return
+		}
+	}
+}

coap/api/util.go

@@ -0,0 +1,24 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package api
+
+import "strings"
+
+func authKey(opt interface{}) (string, error) {
+	val, ok := opt.(string)
+	if !ok {
+		return "", errBadRequest
+	}
+
+	arr := strings.Split(val, "=")
+	if len(arr) != 2 || strings.ToLower(arr[0]) != "authorization" {
+		return "", errBadOption
+	}
+
+	return arr[1], nil
+}

coap/nats/publisher.go

@@ -0,0 +1,64 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// Package ats contains NATS message publisher implementation.
+package nats
+
+import (
+	"fmt"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/coap"
+	broker "github.com/nats-io/go-nats"
+)
+
+const prefix = "channel"
+
+var _ mainflux.MessagePublisher = (*natsPublisher)(nil)
+
+type natsPublisher struct {
+	nc *broker.Conn
+}
+
+// New instantiates NATS message publisher.
+func New(nc *broker.Conn) coap.Broker {
+	return &natsPublisher{nc}
+}
+
+func (pubsub *natsPublisher) Publish(msg mainflux.RawMessage) error {
+	data, err := proto.Marshal(&msg)
+	if err != nil {
+		return err
+	}
+
+	subject := fmt.Sprintf("%s.%d", prefix, msg.Channel)
+	return pubsub.nc.Publish(subject, data)
+}
+
+func (pubsub *natsPublisher) Subscribe(chanID uint64, obsID string, observer *coap.Observer) error {
+	sub, err := pubsub.nc.Subscribe(fmt.Sprintf("%s.%d", prefix, chanID), func(msg *broker.Msg) {
+		if msg == nil {
+			return
+		}
+		var rawMsg mainflux.RawMessage
+		if err := proto.Unmarshal(msg.Data, &rawMsg); err != nil {
+			return
+		}
+		observer.Messages <- rawMsg
+	})
+	if err != nil {
+		return err
+	}
+
+	go func() {
+		<-observer.Cancel
+		sub.Unsubscribe()
+	}()
+
+	return nil
+}

coap/observer.go

@@ -0,0 +1,72 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package coap
+
+import (
+	"sync"
+
+	"github.com/mainflux/mainflux"
+)
+
+// Observer is used to handle CoAP subscription.
+type Observer struct {
+	// Expired flag is used to mark that ticker sent a
+	// CON message, but response is not received yet.
+	// The flag changes its value once ACK message is
+	// received from the client. If Expired is true
+	// when ticker is triggered, Observer should be canceled
+	// and removed from the Service map.
+	expired bool
+
+	// Message ID for notification messages.
+	msgID uint16
+
+	expiredLock, msgIDLock sync.Mutex
+
+	// Messages is used to receive messages from NATS.
+	Messages chan mainflux.RawMessage
+
+	// Cancel channel is used to cancel observing resource.
+	// Cancel channel should not be used to send or receive any
+	// data, it's purpose is to be closed once Observer canceled.
+	Cancel chan bool
+}
+
+// NewObserver instantiates a new Observer.
+func NewObserver() *Observer {
+	return &Observer{
+		Messages: make(chan mainflux.RawMessage),
+		Cancel:   make(chan bool),
+	}
+}
+
+// LoadExpired reads Expired flag in thread-safe way.
+func (o *Observer) LoadExpired() bool {
+	o.expiredLock.Lock()
+	defer o.expiredLock.Unlock()
+
+	return o.expired
+}
+
+// StoreExpired stores Expired flag in thread-safe way.
+func (o *Observer) StoreExpired(val bool) {
+	o.expiredLock.Lock()
+	defer o.expiredLock.Unlock()
+
+	o.expired = val
+}
+
+// LoadMessageID reads MessageID and increments
+// its value in thread-safe way.
+func (o *Observer) LoadMessageID() uint16 {
+	o.msgIDLock.Lock()
+	defer o.msgIDLock.Unlock()
+
+	o.msgID++
+	return o.msgID
+}

dashflux/.angular-cli.json

@@ -9,7 +9,7 @@
       "outDir": "dist",
       "assets": [
         "assets",
-        "favicon.ico"
+        "favicon.png"
       ],
       "index": "index.html",
       "main": "main.ts",

dashflux/src/app/app-routing.module.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import { CommonModule } from '@angular/common';
 import { NgModule } from '@angular/core';
 import { Route, RouterModule } from '@angular/router';

dashflux/src/app/app.component.html

@@ -1,3 +1,10 @@
+<!--
+ Copyright (c) 2018
+ Mainflux
+
+ SPDX-License-Identifier: Apache-2.0
+-->
+
 <div *mobxAutorun>
     <div class="loading" *ngIf="uiStore.loading" fxLayoutAlign="center center">
         <mat-progress-spinner [mode]="'indeterminate'"></mat-progress-spinner>

dashflux/src/app/app.component.scss

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 .loading {
     position: absolute;
     width: 100%;

dashflux/src/app/app.component.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import { HttpClientModule } from '@angular/common/http';
 import { async, TestBed } from '@angular/core/testing';
 import { RouterTestingModule } from '@angular/router/testing';

dashflux/src/app/app.component.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import { Component, OnInit } from '@angular/core';
 import { MatSnackBar } from '@angular/material';
 import { reaction } from 'mobx';

dashflux/src/app/app.module.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import './rxjs-extensions.ts';
 import 'hammerjs';
 

dashflux/src/app/components/auth/login/login.component.html

@@ -1,3 +1,10 @@
+<!--
+ Copyright (c) 2018
+ Mainflux
+
+ SPDX-License-Identifier: Apache-2.0
+-->
+
 <div class="container" style="height: 80vh" fxLayoutAlign="center center">
   <form fxLayout="column" [formGroup]="loginForm" (ngSubmit)="login()" fxFlex="30%" fxFlex.sm="70%" fxFlex.xs="90%">
     <mat-card>

dashflux/src/app/components/auth/login/login.component.scss

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 ::ng-deep mat-card-content.loginCard {
     height: 200px;
 }

dashflux/src/app/components/auth/login/login.component.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { HttpClientModule } from '@angular/common/http';
 import { async, ComponentFixture, inject, TestBed } from '@angular/core/testing';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';

dashflux/src/app/components/auth/login/login.component.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Component, OnInit } from '@angular/core';
 import { FormBuilder, FormGroup, Validators } from '@angular/forms';
 

dashflux/src/app/components/auth/signup/signup.component.html

@@ -1,3 +1,10 @@
+<!--
+ Copyright (c) 2018
+ Mainflux
+
+ SPDX-License-Identifier: Apache-2.0
+-->
+
 <div class="container" style="height: 80vh" fxLayoutAlign="center center">
   <form fxLayout="column" [formGroup]="signupForm" (ngSubmit)="signup()" fxFlex="30%" fxFlex.sm="70%" fxFlex.xs="90%">
     <mat-card>

dashflux/src/app/components/auth/signup/signup.component.scss

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 ::ng-deep mat-card-content.loginCard {
     height: 200px;
 }

dashflux/src/app/components/auth/signup/signup.component.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { HttpClientModule } from '@angular/common/http';
 import { async, ComponentFixture, TestBed } from '@angular/core/testing';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';

dashflux/src/app/components/auth/signup/signup.component.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Component, OnInit } from '@angular/core';
 import { AbstractControl, FormBuilder, FormGroup, Validators } from '@angular/forms';
 

dashflux/src/app/components/channels/channel-dialog/channel-dialog.component.html

@@ -1,3 +1,10 @@
+<!--
+ Copyright (c) 2018
+ Mainflux
+
+ SPDX-License-Identifier: Apache-2.0
+-->
+
 <form [formGroup]="addChannelForm" (ngSubmit)="onAddChannel()">
     <h1 *ngIf="!editMode" mat-dialog-title>Add channel</h1>
     <h1 *ngIf="editMode" mat-dialog-title>Edit channel</h1>

dashflux/src/app/components/channels/channel-dialog/channel-dialog.component.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { HttpClientModule } from '@angular/common/http';
 import { async, ComponentFixture, TestBed } from '@angular/core/testing';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';

dashflux/src/app/components/channels/channel-dialog/channel-dialog.component.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Component, EventEmitter, Inject, OnInit, Output } from '@angular/core';
 import { FormBuilder, FormGroup } from '@angular/forms';
 import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material';

dashflux/src/app/components/channels/channels.component.html

@@ -1,3 +1,10 @@
+<!--
+ Copyright (c) 2018
+ Mainflux
+
+ SPDX-License-Identifier: Apache-2.0
+-->
+
 <div class="channelsContainer" fxLayout="row" fxLayoutWrap>
   <ng-container [ngSwitch]="channelsStore.channels?.length > 0">
     <ng-container *ngSwitchCase="true">

dashflux/src/app/components/channels/channels.component.scss

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 .addButton {
     position: fixed;
     bottom: 12px;

dashflux/src/app/components/channels/channels.component.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { HttpClientModule } from '@angular/common/http';
 import { async, ComponentFixture, TestBed } from '@angular/core/testing';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';

dashflux/src/app/components/channels/channels.component.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Component, OnInit } from '@angular/core';
 import { MatDialog } from '@angular/material';
 import { Observable } from 'rxjs/Observable';

dashflux/src/app/components/shared/confirmation-dialog/confirmation-dialog.component.html

@@ -1,3 +1,10 @@
+<!--
+ Copyright (c) 2018
+ Mainflux
+
+ SPDX-License-Identifier: Apache-2.0
+-->
+
 <h1 mat-dialog-title>{{data.question}}</h1>
 <div mat-dialog-actions fxLayoutAlign="end end">
   <button mat-button mat-dialog-close>Cancel</button>

dashflux/src/app/components/shared/confirmation-dialog/confirmation-dialog.component.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { async, ComponentFixture, TestBed } from '@angular/core/testing';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';
 import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material';

dashflux/src/app/components/shared/confirmation-dialog/confirmation-dialog.component.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Component, Inject, OnInit } from '@angular/core';
 import { MAT_DIALOG_DATA } from '@angular/material';
 

dashflux/src/app/components/things/thing-dialog/thing-dialog.component.html

@@ -23,7 +23,7 @@
       </mat-error>
     </mat-form-field>
     <mat-form-field>
-      <textarea formControlName="payload" matInput placeholder="Payload" matTextareaAutosize matAutosizeMinRows="2"
+      <textarea formControlName="metadata" matInput placeholder="Metadata" matTextareaAutosize matAutosizeMinRows="2"
                 matAutosizeMaxRows="5"></textarea>
     </mat-form-field>
   </div>

dashflux/src/app/components/things/thing-dialog/thing-dialog.component.ts

@@ -26,7 +26,7 @@ export class ThingDialogComponent implements OnInit {
         id: null,
         type: ['', [Validators.required]],
         name: ['', [Validators.required, Validators.minLength(5)]],
-        payload: ['']
+        metadata: ['']
       }
     );
 

dashflux/src/app/components/things/things.component.html

@@ -1,3 +1,10 @@
+<!--
+ Copyright (c) 2018
+ Mainflux
+
+ SPDX-License-Identifier: Apache-2.0
+-->
+
 <div class="thingsContainer" fxLayout="row" fxLayoutWrap>
   <ng-container [ngSwitch]="thingsStore.things?.length > 0">
     <ng-container *ngSwitchCase="true">
@@ -17,9 +24,9 @@
             <mat-header-cell fxFlex="10%" *matHeaderCellDef mat-sort-header>Type</mat-header-cell>
             <mat-cell fxFlex="10%" *matCellDef="let row"> {{row.type}}</mat-cell>
           </ng-container>
-          <ng-container matColumnDef="payload">
-            <mat-header-cell fxFlex="35%" *matHeaderCellDef mat-sort-header>Payload</mat-header-cell>
-            <mat-cell fxFlex="35%" *matCellDef="let row"> {{row.payload | json}}</mat-cell>
+          <ng-container matColumnDef="metadata">
+            <mat-header-cell fxFlex="35%" *matHeaderCellDef mat-sort-header>Metadata</mat-header-cell>
+            <mat-cell fxFlex="35%" *matCellDef="let row"> {{row.metadata | json}}</mat-cell>
           </ng-container>
           <!-- Actions -->
           <ng-container matColumnDef="actions">

dashflux/src/app/components/things/things.component.scss

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 .addButton {
     position: fixed;
     bottom: 12px;

dashflux/src/app/components/things/things.component.spec.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { HttpClientModule } from '@angular/common/http';
 import { async, ComponentFixture, TestBed } from '@angular/core/testing';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';

dashflux/src/app/components/things/things.component.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Component, OnInit } from '@angular/core';
 import { MatDialog } from '@angular/material';
 import { toJS } from 'mobx';
@@ -16,7 +23,7 @@ import { ChannelsStore } from '../../core/store/channels.store';
 })
 export class ThingsComponent implements OnInit {
   things: Observable<Thing[]>;
-  displayedColumns = ['id', 'name', 'type', 'payload', 'actions'];
+  displayedColumns = ['id', 'name', 'type', 'metadata', 'actions'];
 
   constructor(
     private dialog: MatDialog,

dashflux/src/app/core/material/material.module.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { NgModule } from '@angular/core';
 import {
   MatButtonModule,

dashflux/src/app/core/services/auth/authentication.service.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import '../../../rxjs-extensions';
 
 import { HttpClient, HttpErrorResponse } from '@angular/common/http';

dashflux/src/app/core/services/auth/token-storage.service.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
 

dashflux/src/app/core/services/auth/unauthorized.interceptor.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Injectable } from '@angular/core';
 import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse } from '@angular/common/http';
 import { Observable } from 'rxjs/Observable';

dashflux/src/app/core/services/channels/channels.service.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { HttpClient, HttpResponse } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';

dashflux/src/app/core/services/mock-auth.service.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
 

dashflux/src/app/core/services/mock-channels.service.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
 

dashflux/src/app/core/services/mock-things.service.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
 

dashflux/src/app/core/services/things/things.service.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ 
 import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 

dashflux/src/app/core/store/models.ts

@@ -8,7 +8,7 @@ export interface Thing {
     id?: '';
     type: string;
     name: string;
-    payload: string;
+    metadata: string;
 }
 
 export interface User {

dashflux/src/app/core/store/things.store.spec.ts

@@ -74,7 +74,7 @@ describe('ThingsStore', () => {
                 const newThing: Thing = {
                     name: 'new thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.addThing(newThing);
@@ -89,7 +89,7 @@ describe('ThingsStore', () => {
                 const newThing: Thing = {
                     name: 'new thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.addThing(newThing);
@@ -104,7 +104,7 @@ describe('ThingsStore', () => {
                 const newThing: Thing = {
                     name: 'new thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.addThing(newThing);
@@ -120,7 +120,7 @@ describe('ThingsStore', () => {
                 const newThing: Thing = {
                     name: 'new thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.addThing(newThing);
@@ -136,7 +136,7 @@ describe('ThingsStore', () => {
                 const editedThing: Thing = {
                     name: 'edited thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.editThing(editedThing);
@@ -151,7 +151,7 @@ describe('ThingsStore', () => {
                 const editedThing: Thing = {
                     name: 'edited thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.editThing(editedThing);
@@ -167,7 +167,7 @@ describe('ThingsStore', () => {
                 const editedThing: Thing = {
                     name: 'edited thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.editThing(editedThing);
@@ -182,7 +182,7 @@ describe('ThingsStore', () => {
                 const editedThing: Thing = {
                     name: 'edited thing',
                     type: 'app',
-                    payload: '',
+                    metadata: '',
                 };
 
                 thingsStore.editThing(editedThing);
@@ -198,7 +198,7 @@ describe('ThingsStore', () => {
                 const thingToBeDeleted: Thing = {
                     name: 'thingToBeDeleted',
                     type: 'app',
-                    payload: ''
+                    metadata: ''
                 };
 
                 thingsStore.deleteThing(thingToBeDeleted);
@@ -213,7 +213,7 @@ describe('ThingsStore', () => {
                 const thingToBeDeleted: Thing = {
                     name: 'thingToBeDeleted',
                     type: 'app',
-                    payload: ''
+                    metadata: ''
                 };
 
 
@@ -230,7 +230,7 @@ describe('ThingsStore', () => {
                 const thingToBeDeleted: Thing = {
                     name: 'thingToBeDeleted',
                     type: 'app',
-                    payload: ''
+                    metadata: ''
                 };
 
                 thingsStore.deleteThing(thingToBeDeleted);
@@ -245,7 +245,7 @@ describe('ThingsStore', () => {
                 const thingToBeDeleted: Thing = {
                     name: 'thingToBeDeleted',
                     type: 'app',
-                    payload: ''
+                    metadata: ''
                 };
 
                 thingsStore.deleteThing(thingToBeDeleted);

dashflux/src/app/rxjs-extensions.ts

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import 'rxjs/add/observable/combineLatest';
 import 'rxjs/add/observable/interval';
 import 'rxjs/add/observable/of';

dashflux/src/index.html

@@ -6,7 +6,7 @@
   <base href="/">
 
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <link rel="icon" type="image/x-icon" href="favicon.ico">
+  <link rel="icon" type="image/x-icon" href="favicon.png">
   <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet"> 
 </head>
 <body>

dashflux/src/styles.scss

@@ -1 +1,8 @@
+/*
+ * Copyright (c) 2018
+ * Mainflux
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 @import '~@angular/material/prebuilt-themes/indigo-pink.css';

doc.go

@@ -1,3 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 // Package mainflux acts as an umbrella package containing multiple different
 // microservices and defines all shared domain concepts.
 package mainflux

docker/Dockerfile.dev

@@ -0,0 +1,4 @@
+FROM scratch
+ARG SVC_NAME
+COPY mainflux-$SVC_NAME /exe
+ENTRYPOINT ["/exe"]

docker/addons/cassandra-reader/docker-compose.yml

@@ -0,0 +1,28 @@
+###
+# This docker-compose file contains optional Cassandra and cassandra-reader. Since these are optional, this file is
+# dependent of docker-compose file from <project_root>/docker. In order to run
+# these optional service, execute command:
+# docker-compose -f docker/docker-compose.yml -f docker/addons/cassandra-reader/docker-compose.yml up
+# from project root.
+###
+
+version: "3"
+
+networks:
+  docker_mainflux-base-net:
+    external: true
+
+services:
+  cassandra-reader:
+    image: mainflux/cassandra-reader:latest
+    container_name: mainflux-cassandra-reader
+    restart: on-failure
+    environment:
+      MF_THINGS_URL: things:8183
+      MF_CASSANDRA_READER_PORT: 8903
+      MF_CASSANDRA_READER_DB_CLUSTER: mainflux-cassandra
+      MF_CASSANDRA_READER_DB_KEYSPACE: mainflux
+    ports:
+      - 8903:8903
+    networks:
+      - docker_mainflux-base-net

docker/addons/cassandra-writer/docker-compose.yml

@@ -0,0 +1,39 @@
+###
+# This docker-compose file contains optional Cassandra and cassandra-writer. Since these are optional, this file is
+# dependent of docker-compose file from <project_root>/docker. In order to run
+# these optional service, execute command:
+# docker-compose -f docker/docker-compose.yml -f docker/addons/cassandra-writer/docker-compose.yml up
+# from project root.
+###
+
+version: "3"
+
+networks:
+  docker_mainflux-base-net:
+    external: true
+
+services:
+  cassandra:
+    image: cassandra:3.11.2
+    container_name: mainflux-cassandra
+    restart: on-failure
+    networks:
+      - docker_mainflux-base-net
+
+  cassandra-writer:
+    image: mainflux/cassandra-writer:latest
+    container_name: mainflux-cassandra-writer
+    depends_on:
+      - cassandra
+    expose:
+      - 8902
+    restart: on-failure
+    environment:
+      MF_NATS_URL: nats://nats:4222
+      MF_CASSANDRA_WRITER_PORT: 8902
+      MF_CASSANDRA_WRITER_DB_CLUSTER: mainflux-cassandra
+      MF_CASSANDRA_WRITER_DB_KEYSPACE: mainflux
+    ports:
+      - 8902:8902
+    networks:
+      - docker_mainflux-base-net

docker/addons/cassandra-writer/init.sh

@@ -0,0 +1,3 @@
+docker-compose -f docker/addons/cassandra-writer/docker-compose.yml up -d
+sleep 20
+docker exec mainflux-cassandra cqlsh -e "CREATE KEYSPACE IF NOT EXISTS mainflux WITH replication = {'class':'SimpleStrategy','replication_factor':'1'};"

docker/addons/influxdb-reader/docker-compose.yml

@@ -0,0 +1,30 @@
+###
+# This docker-compose file contains optional InfluxDB-reader service for the Mainflux
+# platform. Since this service is optional, this file is dependent on the docker-compose.yml
+# file from <project_root>/docker/. In order to run InfluxDB-reader service, core services,
+# as well as the network from the core composition, should be already running.
+###
+
+version: "3"
+
+networks:
+  docker_mainflux-base-net:
+    external: true
+
+services:
+  influxdb-reader:
+    image: mainflux/influxdb-reader:latest
+    container_name: mainflux-influxdb-reader
+    restart: on-failure
+    environment:
+      MF_THINGS_URL: things:8183
+      MF_INFLUX_READER_PORT: 8905
+      MF_INFLUX_READER_DB_NAME: mainflux
+      MF_INFLUX_READER_DB_HOST: mainflux-influxdb
+      MF_INFLUX_READER_DB_PORT: 8086
+      MF_INFLUX_READER_DB_USER: mainflux
+      MF_INFLUX_READER_DB_PASS: mainflux
+    ports:
+      - 8905:8905
+    networks:
+      - docker_mainflux-base-net

docker/addons/influxdb-writer/docker-compose.yml

@@ -1,13 +1,16 @@
 ###
 # This docker-compose file contains optional InfluxDB, InfluxDB-writer and Grafana services
-# for Mainflux platform. Since these are optional, this file is dependent of docker-compose file
-# from <project_root>/docker. In order to run these optional service, execute command:
-# docker-compose -f docker/docker-compose.yml -f docker/addons/influxdb/docker-compose.yml up
-# from project root.
+# for the Mainflux platform. Since this services are optional, this file is dependent on the
+# docker-compose.yml file from <project_root>/docker/. In order to run these services,
+# core services, as well as the network from the core composition, should be already running.
 ###
 
 version: "3"
 
+networks:
+  docker_mainflux-base-net:
+    external: true
+
 services:
 
   influxdb:
@@ -18,26 +21,31 @@ services:
       INFLUXDB_DB: mainflux
       INFLUXDB_ADMIN_USER: mainflux
       INFLUXDB_ADMIN_PASSWORD: mainflux
+    networks:
+      - docker_mainflux-base-net
 
   influxdb-writer:
-    image: mainflux/influxdb:latest
+    image: mainflux/influxdb-writer:latest
     container_name: mainflux-influxdb-writer
     depends_on:
       - influxdb
-      - nats
     expose:
       - 8900
     restart: on-failure
     environment:
       MF_NATS_URL: nats://nats:4222
       MF_INFLUX_WRITER_PORT: 8900
+      MF_INFLUX_WRITER_BATCH_SIZE: 5000
+      MF_INFLUX_WRITER_BATCH_TIMEOUT: 5
       MF_INFLUX_WRITER_DB_NAME: mainflux
-      MF_INFLUX_WRITER_DB_HOST: influxdb
+      MF_INFLUX_WRITER_DB_HOST: mainflux-influxdb
       MF_INFLUX_WRITER_DB_PORT: 8086
       MF_INFLUX_WRITER_DB_USER: mainflux
       MF_INFLUX_WRITER_DB_PASS: mainflux
     ports:
       - 8900:8900
+    networks:
+      - docker_mainflux-base-net
 
   grafana:
     image: grafana/grafana:5.1.3
@@ -47,3 +55,5 @@ services:
     restart: on-failure
     ports:
       - 3001:3000
+    networks:
+      - docker_mainflux-base-net

docker/addons/mongodb-reader/docker-compose.yml

@@ -0,0 +1,29 @@
+###
+# This docker-compose file contains optional MongoDB-reader service
+# for Mainflux platform. Since these are optional, this file is dependent of docker-compose file
+# from <project_root>/docker. In order to run these optional service, execute command:
+# docker-compose -f docker/docker-compose.yml -f docker/addons/mongodb-reader/docker-compose.yml up
+# from project root. MongoDB service is defined in docker/addons/mongodb-writer/docker-compose.yml.
+###
+
+version: "3"
+
+networks:
+  docker_mainflux-base-net:
+    external: true
+
+services:
+  mongodb-reader:
+    image: mainflux/mongodb-reader:latest
+    container_name: mainflux-mongodb-reader
+    restart: on-failure
+    environment:
+      MF_THINGS_URL: things:8183
+      MF_MONGO_READER_PORT: 8904
+      MF_MONGO_READER_DB_NAME: mainflux
+      MF_MONGO_READER_DB_HOST: mongodb
+      MF_MONGO_READER_DB_PORT: 27017
+    ports:
+      - 8904:8904
+    networks:
+      - docker_mainflux-base-net

docker/addons/mongodb-writer/docker-compose.yml

@@ -2,15 +2,18 @@
 # This docker-compose file contains optional MongoDB and MongoDB-writer services
 # for Mainflux platform. Since these are optional, this file is dependent of docker-compose file
 # from <project_root>/docker. In order to run these optional service, execute command:
-# docker-compose -f docker/docker-compose.yml -f docker/addons/mongodb/docker-compose.yml up
+# docker-compose -f docker/docker-compose.yml -f docker/addons/mongodb-writer/docker-compose.yml up
 # from project root. MongoDB default port (27017) is exposed, so you can use various tools for database
 # inspection and data visualization.
 ###
 
 version: "3"
 
-services:
+networks:
+  docker_mainflux-base-net:
+    external: true
 
+services:
   mongodb:
     image: mongo:3.6-jessie
     container_name: mainflux-mongodb
@@ -21,15 +24,14 @@ services:
       MONGO_INITDB_DATABASE: mainflux
     ports:
       - 27017:27017
+    networks:
+      - docker_mainflux-base-net
 
-  mongo-writer:
-    image: mainflux/mongodb:latest
+  mongodb-writer:
+    image: mainflux/mongodb-writer:latest
     container_name: mainflux-mongodb-writer
     depends_on:
       - mongodb
-      - nats
-    expose:
-      - 8901
     restart: on-failure
     environment:
       MF_NATS_URL: nats://nats:4222
@@ -39,3 +41,5 @@ services:
       MF_MONGO_WRITER_DB_PORT: 27017
     ports:
       - 8901:8901
+    networks:
+      - docker_mainflux-base-net

docker/docker-compose.yml

@@ -8,6 +8,10 @@
 
 version: "3"
 
+networks:
+  mainflux-base-net:
+    driver: bridge
+
 services:
   nginx:
     image: nginx:1.13-alpine
@@ -22,11 +26,15 @@ services:
       - 80:80
       - 443:443
       - 8883:8883
+    networks:
+      - mainflux-base-net
 
   nats:
-    image: nats:1.0.2
+    image: nats:1.3.0
     container_name: mainflux-nats
     restart: on-failure
+    networks:
+      - mainflux-base-net
 
   users-db:
     image: postgres:10.2-alpine
@@ -36,6 +44,8 @@ services:
       POSTGRES_USER: mainflux
       POSTGRES_PASSWORD: mainflux
       POSTGRES_DB: users
+    networks:
+      - mainflux-base-net
 
   users:
     image: mainflux/users:latest
@@ -57,6 +67,8 @@ services:
       MF_USERS_SECRET: secret
     ports:
       - 8180:8180
+    networks:
+      - mainflux-base-net
 
   things-db:
     image: postgres:10.2-alpine
@@ -66,6 +78,15 @@ services:
       POSTGRES_USER: mainflux
       POSTGRES_PASSWORD: mainflux
       POSTGRES_DB: things
+    networks:
+      - mainflux-base-net
+
+  things-cache:
+    image: redis:4.0.9-alpine
+    container_name: mainflux-things-cache
+    restart: on-failure
+    networks:
+      - mainflux-base-net
 
   things:
     image: mainflux/things:latest
@@ -83,22 +104,29 @@ services:
       MF_THINGS_DB_USER: mainflux
       MF_THINGS_DB_PASS: mainflux
       MF_THINGS_DB: things
+      MF_THINGS_CACHE_URL: things-cache:6379
       MF_THINGS_HTTP_PORT: 8182
       MF_THINGS_GRPC_PORT: 8183
       MF_USERS_URL: users:8181
       MF_THINGS_SECRET: secret
     ports:
       - 8182:8182
+    networks:
+      - mainflux-base-net
 
   normalizer:
     image: mainflux/normalizer:latest
     container_name: mainflux-normalizer
     restart: on-failure
+    depends_on:
+      - nats
     expose:
       - 8184
     environment:
       MF_NATS_URL: nats://nats:4222
       MF_NORMALIZER_PORT: 8184
+    networks:
+      - mainflux-base-net
 
   dashflux:
     image: mainflux/dashflux:latest
@@ -106,12 +134,15 @@ services:
     restart: on-failure
     ports:
       - 3000:3000
+    networks:
+      - mainflux-base-net
 
   ws-adapter:
     image: mainflux/ws:latest
     container_name: mainflux-ws
     depends_on:
       - things
+      - nats
     expose:
       - 8186
     restart: on-failure
@@ -121,12 +152,15 @@ services:
       MF_THINGS_URL: things:8183
     ports:
       - 8186:8186
+    networks:
+      - mainflux-base-net
 
   http-adapter:
     image: mainflux/http:latest
     container_name: mainflux-http
     depends_on:
       - things
+      - nats
     restart: on-failure
     expose:
       - 8185
@@ -136,18 +170,50 @@ services:
       MF_THINGS_URL: things:8183
     ports:
       - 8185:8185
+    networks:
+      - mainflux-base-net
+
+  redis:
+    image: redis:4.0.9-alpine
+    container_name: mainflux-redis
+    restart: on-failure
+    networks:
+      - mainflux-base-net
 
   mqtt-adapter:
     image: mainflux/mqtt:latest
     container_name: mainflux-mqtt
     depends_on:
       - things
+      - nats
+      - redis
     restart: on-failure
     environment:
       MF_MQTT_ADAPTER_PORT: 1883
       MF_MQTT_WS_PORT: 8880
+      MF_MQTT_REDIS_HOST: redis
       MF_NATS_URL: nats://nats:4222
       MF_THINGS_URL: things:8183
     ports:
       - 1883:1883
       - 8880:8880
+    networks:
+      - mainflux-base-net
+
+  coap-adapter:
+    image: mainflux/coap:latest
+    container_name: mainflux-coap
+    depends_on:
+      - things
+      - nats
+    restart: on-failure
+    expose:
+      - 5683
+    environment:
+      MF_COAP_ADAPTER_PORT: 5683
+      MF_NATS_URL: nats://nats:4222
+      MF_THINGS_URL: things:8183
+    ports:
+      - 5683:5683
+    networks:
+      - mainflux-base-net

docker/nginx.conf

@@ -58,18 +58,10 @@ http {
     # Virtual Host Configs
     ##
 
-    # HTTP
+    # HTTPS
     server {
         listen 80 default_server;
         listen [::]:80 default_server;
-        server_name localhost;
-        access_log off;
-        error_log off;
-        return 301 https://$server_name$request_uri;
-    }
-
-    # HTTPS
-    server {
         # SSL configuration
         #
         listen 443 ssl http2 default_server;

docs/dev-guide.md

@@ -0,0 +1,203 @@
+## Getting Mainflux
+
+Mainflux can be fetched from the official [Mainflux GitHub repository](https://github.com/Mainflux/mainflux):
+
+```
+go get github.com/mainflux/mainflux
+cd $GOPATH/src/github.com/mainflux/mainflux
+```
+
+## Building
+
+### Prerequisites
+Make sure that you have [Protocol Buffers](https://developers.google.com/protocol-buffers/) compiler (`protoc`) installed.
+
+[Go Protobuf](https://github.com/golang/protobuf) installation instructions are [here](https://github.com/golang/protobuf#installation).
+Go Protobuf uses C bindings, so you will need to install [C++ protobuf](https://github.com/google/protobuf) as a prerequisite.
+
+### Build All Services
+
+Use `GNU Make` tool to build all Mainflux services:
+
+```
+make
+```
+
+Build artefacts will be put in the `build` directory.
+
+> N.B. All Mainflux services are built as a statically linked binaries. This way they can be portable (transferred to any platform just by placing them there and running them) as they contain all needed libraries and do not relay on shared system libraries. This helps creating [FROM scratch](https://hub.docker.com/_/scratch/) dockers.
+
+### Build Individual Microservice
+Individual microservices can be built with:
+
+```
+make <microservice_name>
+```
+
+For example:
+
+```
+make http
+```
+
+will build the HTTP Adapter microservice.
+
+### Building Dockers
+
+Dockers can be built with:
+
+```
+make dockers
+```
+
+or individually with:
+
+```
+make docker_<microservice_name>
+```
+
+For example:
+
+```
+make docker_http
+```
+
+> N.B. Mainflux creates `FROM scratch` docker containers which are compact and small in size.
+
+> N.B. The `things-db` and `users-db` containers are built from a vanilla PostgreSQL docker image downloaded from docker hub which does not persist the data when these containers are rebuilt. Thus, __rebuilding of all docker containers with `make dockers` or rebuilding the `things-db` and `users-db` containers separately with `make docker_things-db` and `make docker_users-db` respectively, will cause data loss. All your users, things, channels and connections between them will be lost!__ As we use this setup only for development, we don't guarantee any permanent data persistence. If you need to retain the data between the container rebuilds you can attach volume to the `things-db` and `users-db` containers. Check the official docs on how to use volumes [here](https://docs.docker.com/storage/volumes/) and [here](https://docs.docker.com/compose/compose-file/#volumes).
+
+#### Building Docker images for development
+
+In order to speed up build process, you can use commands such as:
+
+```bash
+make dockers_dev
+```
+
+or individually with
+
+```bash
+make docker_dev_<microservice_name>
+```
+
+Commands `make dockers` and `make dockers_dev` are similar. The main difference is that building images in the development mode is done on the local machine, rather than an intermediate image, which makes building images much faster. Before running this command, corresponding binary needs to be built in order to make changes visible. This can be done using `make` or `make <service_name>` command. Commands `make dockers_dev` and `make docker_dev_<service_name>` should be used only for development to speed up the process of image building. **For deployment images, commands from section above should be used.**
+
+### MQTT Microservice
+The MQTT Microservice in Mainflux is special, as it is currently the only microservice written in NodeJS. It is not compiled, but node modules need to be downloaded in order to start the service:
+
+```
+cd mqtt
+npm install
+```
+
+Note that there is a shorthand for doing these commands with `make` tool:
+
+```
+make mqtt
+```
+
+After that, the MQTT Adapter can be started from top directory (as it needs to find `*.proto` files) with:
+```
+node mqtt/mqtt.js
+```
+
+### Protobuf
+Aforementioned  `make` (which is an alias for `make all` target) is calling `protoc` command prior to compiling individual microservices.
+
+To do this by hand, execute:
+
+```
+protoc --go_out=plugins=grpc:. *.proto
+```
+
+A shorthand to do this via `make` tool is:
+
+```
+make proto
+```
+
+> N.B. This must be done once at the beginning in order to generate protobuf Go structures needed for the build.
+
+### Cross-compiling for ARM
+Mainflux can be compiled for ARM platform and run on Raspberry Pi or other similar IoT gateways, by following the instructions [here](https://dave.cheney.net/2015/08/22/cross-compilation-with-go-1-5) or [here](https://www.alexruf.net/golang/arm/raspberrypi/2016/01/16/cross-compile-with-go-1-5-for-raspberry-pi.html) as well as information
+found [here](https://github.com/golang/go/wiki/GoArm). The environment variables `GOARCH=arm` and `GOARM=7` must be set for the compilation.
+
+Cross-compilation for ARM with Mainflux make:
+
+```
+GOOS=linux GOARCH=arm GOARM=7 make
+```
+
+## Running tests
+To run all of the tests you can execute:
+```
+make test
+```
+Dockertest is used for the tests, so to run them, you will need the Docker daemon/service running.
+
+## Installing
+Installing Go binaries is simple: just move them from `build` to `$GOBIN` (do not fortget to add `$GOBIN` to your `$PATH`).
+
+You can execute:
+
+```
+make install
+```
+
+which will do this copying of the binaries.
+
+> N.B. Only Go binaries will be installed this way. The MQTT adapter is a NodeJS script and will stay in the `mqtt` dir.
+
+## Deployment
+
+### Prerequisites
+Mainflux depends on several infrastructural services, notably [NATS](https://www.nats.io/) broker and [PostgreSQL](https://www.postgresql.org/) database.
+
+#### NATS
+Mainflux uses NATS as it's central message bus. For development purposes (when not run via Docker), it expects that NATS is installed on the local system.
+
+To do this execute:
+
+```
+go get github.com/nats-io/gnatsd
+```
+
+This will install `gnatsd` binary that can be simply run by executing:
+
+```
+gnatsd
+```
+
+#### PostgreSQL
+Mainflux uses PostgreSQL to store metadata (`users`, `things` and `channels` entities alongside with authorization tokens).
+It expects that PostgreSQL DB is installed, set up and running on the local system.
+
+Information how to set-up (prepare) PostgreSQL database can be found [here](https://support.rackspace.com/how-to/postgresql-creating-and-dropping-roles/),
+and it is done by executing following commands:
+
+```
+# Create `users` and `things` databases
+sudo -u postgres createdb users
+sudo -u postgres createdb things
+
+# Set-up Postgres roles
+sudo su - postgres
+psql -U postgres
+postgres=# CREATE ROLE mainflux WITH LOGIN ENCRYPTED PASSWORD 'mainflux';
+postgres=# ALTER USER mainflux WITH LOGIN ENCRYPTED PASSWORD 'mainflux';
+```
+
+### Mainflux Services
+Running of the Mainflux microservices can be tricky, as there is a lot of them and each demand configuration in the form of environment variables.
+
+The whole system (set of microservices) can be run with one command:
+
+```
+make run
+```
+
+which will properly configure and run all microservices.
+
+Please assure that MQTT microservice has `node_modules` installed, as explained in _MQTT Microservice_ chapter.
+
+> N.B. `make run` actually calls helper script `scripts/run.sh`, so you can inspect this script for the details.

docs/getting-started.md

@@ -118,7 +118,7 @@ Content-Length: 1105
       "id": "cb63f852-2d48-44f0-a0cf-e450496c6c92",
       "type": "app",
       "name": "myapp",
-      "key": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE1MjMzNTYzOTcsImlzcyI6Im1haW5mbHV4Iiwic3ViIjoiY2I2M2Y4NTItMmQ0OC00NGYwLWEwY2YtZTQ1MDQ5NmM2YzkyIn0.FE6DWB3yJmBb8uojpQJaKUEbD0Elrjx0HhJA28bVzkU"
+      "key": "cbf02d60-72f2-4180-9f82-2c957db929d1"
     }
   ]
 }
@@ -282,6 +282,32 @@ If you are not able to send custom headers in your handshake request, send it as
 query parameter `authorization`. Then your path should look like this
 `/channels/<channel_id>/messages?authorization=<thing_auth_key>`.
 
+If you are using the docker environment prepend the url with `ws`. So for example
+`/ws/channels/<channel_id>/messages?authorization=<thing_auth_key>`
+
+#### Basic nodejs example
+
+```javascript
+const WebSocket = require('ws');
+
+// do not verify self-signed certificates if you are using one
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
+
+// cbf02d60-72f2-4180-9f82-2c957db929d1  is an example of a thing_auth_key
+const ws = new WebSocket('wss://localhost/ws/channels/1/messages?authorization=cbf02d60-72f2-4180-9f82-2c957db929d1')
+
+ws.on('open', () => {
+    ws.send('something')
+})
+
+ws.on('message', (data) => {
+    console.log(data)
+})
+ws.on('error', (e) => {
+    console.log(e)
+})
+```
+
 ### MQTT
 
 To send and receive messages over MQTT you could use [Mosquitto tools](https://mosquitto.org),
@@ -290,7 +316,7 @@ or [Paho](https://www.eclipse.org/paho/) if you want to use MQTT over WebSocket.
 To publish message over channel, thing should call following command:
 
 ```
-mosquitto_pub -u <thing_id> -P <thing_key> -t channels/<channel_id>/messages -h localhost -m [{"bn":"some-base-name:","bt":1.276020076001e+09, "bu":"A","bver":5, "n":"voltage","u":"V","v":120.1}, {"n":"current","t":-5,"v":1.2}, {"n":"current","t":-4,"v":1.3}]
+mosquitto_pub -u <thing_id> -P <thing_key> -t channels/<channel_id>/messages -h localhost -m '[{"bn":"some-base-name:","bt":1.276020076001e+09, "bu":"A","bver":5, "n":"voltage","u":"V","v":120.1}, {"n":"current","t":-5,"v":1.2}, {"n":"current","t":-4,"v":1.3}]'
 ```
 
 To subscribe to channel, thing should call following command:
@@ -301,3 +327,134 @@ mosquitto_sub -u <thing_id> -P <thing_key> -t channels/<channel_id>/messages -h
 
 If you are using TLS to secure MQTT connection, add `--cafile docker/ssl/certs/ca.crt`
 to every command.
+
+## Add-ons
+
+The `<project_root>/docker` folder contains an `addons` directory. This directory is used for various services that are not core to the Mainflux platform but could be used for providing additional features.
+
+In order to run these services, core services, as well as the network from the core composition, should be already running.
+
+### Writers
+
+Writers provide an implementation of various `message writers`. Message writers are services that consume normalized (in `SenML` format) Mainflux messages and store them in specific data store.
+
+#### InfluxDB, InfluxDB-writer and Grafana
+
+From the project root execute the following command:
+
+```bash
+docker-compose -f docker/addons/influxdb-writer/docker-compose.yml up -d
+``` 
+This will install and start:
+
+- [InfluxDB](https://docs.influxdata.com/influxdb) - time series database
+- InfluxDB writer - message repository implementation for InfluxDB
+- [Grafana](https://grafana.com) - tool for database exploration and data visualization and analytics
+
+Those new services will take some additional ports:
+
+- 8086 by InfluxDB
+- 8900 by InfluxDB writer service
+- 3001 by Grafana
+
+To access Grafana, navigate to `http://localhost:3001` and login with: `admin`, password: `admin`
+
+#### Cassandra and Cassandra-writer
+
+```bash
+./docker/addons/cassandra-writer/init.sh
+``` 
+_Please note that Cassandra may not be suitable for your testing enviroment because it has high system requirements._
+
+#### MongoDB and MongoDB-writer
+
+```bash
+docker-compose -f docker/addons/mongodb-writer/docker-compose.yml up -d
+```
+MongoDB default port (27017) is exposed, so you can use various tools for database inspection and data visualization.
+
+### Readers
+
+Readers provide an implementation of various `message readers`.
+Message readers are services that consume normalized (in `SenML` format) Mainflux messages from data storage and opens HTTP API for message consumption.
+Installing corresponding writer before reader is implied. 
+
+
+#### InfluxDB-reader 
+
+```bash
+docker-compose -f docker/addons/influxdb-reader/docker-compose.yml up -d
+``` 
+Service exposes [HTTP API](https://github.com/mainflux/mainflux/blob/master/readers/swagger.yml) for fetching messages on port 8905
+
+
+To read sent messages on channel with id `channel_id` you should send `GET` request to `/channels/<channel_id>/messages` with thing access token in `Authorization` header. That thing must be connected to  channel with `channel_id`
+
+```
+curl -s -S -i  -H "Authorization: <thing_token>" http://localhost:8905/channels/<channel_id>/messages
+```
+
+Response should look like this:
+
+```
+HTTP/1.1 200 OK
+Content-Type: application/json
+Date: Tue, 18 Sep 2018 18:56:19 GMT
+Content-Length: 228
+
+{
+    "messages": [
+        {
+            "Channel": 1,
+            "Publisher": 2,
+            "Protocol": "mqtt",
+            "Name": "name:voltage",
+            "Unit": "V",
+            "Value": 5.6,
+            "Time": 48.56
+        },
+        {
+            "Channel": 1,
+            "Publisher": 2,
+            "Protocol": "mqtt",
+            "Name": "name:temperature",
+            "Unit": "C",
+            "Value": 24.3,
+            "Time": 48.56
+        }
+    ]
+}
+```
+Note that you will receive only those messages that were sent by authorization token's owner.
+You can specify `offset` and `limit` parameters in order to fetch specific group of messages. In that case, your request should look like:
+
+```
+curl -s -S -i  -H "Authorization: <thing_token>" http://localhost:8905/channels/<channel_id>/messages?offset=0&limit=5
+```
+If you don't provide them, default values will be used instead: 0 for `offset`, and 10 for `limit`.
+
+#### Cassandra-reader
+
+```bash
+docker-compose -f docker/addons/cassandra-reader/docker-compose.yml up -d
+``` 
+Service exposes [HTTP API](https://github.com/mainflux/mainflux/blob/master/readers/swagger.yml) for fetching messages on port 8903
+
+Aside from port, reading request is same as for other readers:
+
+```
+curl -s -S -i  -H "Authorization: <thing_token>" http://localhost:8903/channels/<channel_id>/messages
+```
+
+#### MongoDB-reader
+
+```bash
+docker-compose -f docker/addons/mongodb-reader/docker-compose.yml up -d
+``` 
+Service exposes [HTTP API](https://github.com/mainflux/mainflux/blob/master/readers/swagger.yml) for fetching messages on port 8904
+
+Aside from port, reading request is same as for other readers:
+
+```
+curl -s -S -i  -H "Authorization: <thing_token>" http://localhost:8904/channels/<channel_id>/messages
+```

env.go

@@ -1,3 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package mainflux
 
 import "os"

http/README.md

@@ -8,11 +8,12 @@ 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_PORT | Service HTTP port   | 8180                  |
-| MF_NATS_URL          | NATS instance URL   | nats://localhost:4222 |
-| MF_THINGS_URL        | Things service URL  | localhost:8181        |
+| 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        |
 
 ## Deployment
 
@@ -30,6 +31,7 @@ services:
     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]
 ```
 
@@ -48,7 +50,7 @@ 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_PORT=[Service HTTP port] $GOBIN/mainflux-http
+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] $GOBIN/mainflux-http
 ```
 
 ## Usage

http/adapter.go

@@ -1,3 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 // Package http contains the domain concept definitions needed to support
 // Mainflux http adapter service functionality.
 package http