Added changelog for 0.9.0 release (#799)

Signed-off-by: nmarcetic <n.marcetic86@gmail.com>

.dockerignore

@@ -0,0 +1,10 @@
+.git
+.github
+build
+ui
+docker
+docs
+k8s
+load-test
+metrics
+scripts

.env

@@ -0,0 +1,153 @@
+# Docker: Environment variables in Compose
+
+## NGINX
+MF_NGINX_HTTP_PORT=80
+MF_NGINX_SSL_PORT=443
+MF_NGINX_MQTT_PORT=8883
+
+## NATS
+MF_NATS_URL=nats://nats:4222
+
+## REDIS
+MF_REDIS_TCP_PORT=6379
+
+## UI
+MF_UI_PORT=3000
+
+## Grafana
+MF_GRAFANA_PORT=3000
+
+## Jaeger
+MF_JAEGER_PORT=6831
+MF_JAEGER_FRONTEND=16686
+MF_JAEGER_COLLECTOR=14268
+MF_JAEGER_CONFIGS=5778
+MF_JAEGER_URL=jaeger:6831
+
+## Core Services
+### Users
+MF_USERS_LOG_LEVEL=debug
+MF_USERS_HTTP_PORT=8180
+MF_USERS_GRPC_PORT=8181
+MF_USERS_DB_PORT=5432
+MF_USERS_DB_USER=mainflux
+MF_USERS_DB_PASS=mainflux
+MF_USERS_DB=users
+MF_USERS_SECRET=secret
+
+### Things
+MF_THINGS_LOG_LEVEL=debug
+MF_THINGS_HTTP_PORT=8182
+MF_THINGS_AUTH_HTTP_PORT=8989
+MF_THINGS_AUTH_GRPC_PORT=8183
+MF_THINGS_DB_PORT=5432
+MF_THINGS_DB_USER=mainflux
+MF_THINGS_DB_PASS=mainflux
+MF_THINGS_DB=things
+MF_THINGS_SECRET=secret
+
+### Normalizer
+MF_NORMALIZER_LOG_LEVEL=debug
+MF_NORMALIZER_PORT=8184
+
+### WS
+MF_WS_ADAPTER_LOG_LEVEL=debug
+MF_WS_ADAPTER_PORT=8186
+
+### HTTP
+MF_HTTP_ADAPTER_PORT=8185
+
+### MQTT
+MF_MQTT_ADAPTER_LOG_LEVEL=debug
+MF_MQTT_ADAPTER_PORT=1883
+MF_MQTT_ADAPTER_WS_PORT=8880
+
+### COAP
+MF_COAP_ADAPTER_LOG_LEVEL=debug
+MF_COAP_ADAPTER_PORT=5683
+
+## Addons Services
+### Bootstrap
+MF_BOOTSTRAP_LOG_LEVEL=debug
+MF_BOOTSTRAP_PORT=8200
+MF_BOOTSTRAP_DB_PORT=5432
+MF_BOOTSTRAP_DB_USER=mainflux
+MF_BOOTSTRAP_DB_PASS=mainflux
+MF_BOOTSTRAP_DB=bootstrap
+MF_BOOTSTRAP_DB_SSL_MODE=disable
+
+### LoRa
+MF_LORA_ADAPTER_LOG_LEVEL=debug
+MF_LORA_ADAPTER_MESSAGES_URL=tcp://lora.mqtt.mainflux.io:1883
+MF_LORA_ADAPTER_HTTP_PORT=8187
+
+### Cassandra Writer
+MF_CASSANDRA_WRITER_LOG_LEVEL=debug
+MF_CASSANDRA_WRITER_PORT=8902
+MF_CASSANDRA_WRITER_DB_PORT=9042
+MF_CASSANDRA_WRITER_DB_CLUSTER=mainflux-cassandra
+MF_CASSANDRA_WRITER_DB_KEYSPACE=mainflux
+
+### Cassandra Reader
+MF_CASSANDRA_READER_LOG_LEVEL=debug
+MF_CASSANDRA_READER_PORT=8903
+MF_CASSANDRA_READER_DB_PORT=9042
+MF_CASSANDRA_READER_DB_CLUSTER=mainflux-cassandra
+MF_CASSANDRA_READER_DB_KEYSPACE=mainflux
+
+### InfluxDB Writer
+MF_INFLUX_WRITER_LOG_LEVEL=debug
+MF_INFLUX_WRITER_PORT=8900
+MF_INFLUX_WRITER_BATCH_SIZE=5000
+MF_INFLUX_WRITER_BATCH_TIMEOUT=5
+MF_INFLUX_WRITER_DB_PORT=8086
+MF_INFLUX_WRITER_DB_NAME=mainflux
+MF_INFLUX_WRITER_DB_USER=mainflux
+MF_INFLUX_WRITER_DB_PASS=mainflux
+MF_INFLUX_WRITER_GRAFANA_PORT=3001
+
+### InfluxDB Reader
+MF_INFLUX_READER_LOG_LEVEL=debug
+MF_INFLUX_READER_PORT=8905
+MF_INFLUX_READER_DB_NAME=mainflux
+MF_INFLUX_READER_DB_PORT=8086
+MF_INFLUX_READER_DB_USER=mainflux
+MF_INFLUX_READER_DB_PASS=mainflux
+
+### MongoDB Writer
+MF_MONGO_WRITER_LOG_LEVEL=debug
+MF_MONGO_WRITER_PORT=8901
+MF_MONGO_WRITER_DB_NAME=mainflux
+MF_MONGO_WRITER_DB_PORT=27017
+
+### MongoDB Reader
+MF_MONGO_READER_LOG_LEVEL=debug
+MF_MONGO_READER_PORT=8904
+MF_MONGO_READER_DB_NAME=mainflux
+MF_MONGO_READER_DB_PORT=27017
+
+### Postgres Writer
+MF_POSTGRES_WRITER_LOG_LEVEL=debug
+MF_POSTGRES_WRITER_PORT=9104
+MF_POSTGRES_WRITER_DB_PORT=5432
+MF_POSTGRES_WRITER_DB_USER=mainflux
+MF_POSTGRES_WRITER_DB_PASS=mainflux
+MF_POSTGRES_WRITER_DB_NAME=messages
+MF_POSTGRES_WRITER_DB_SSL_MODE=disable
+MF_POSTGRES_WRITER_DB_SSL_CERT=""
+MF_POSTGRES_WRITER_DB_SSL_KEY=""
+MF_POSTGRES_WRITER_DB_SSL_ROOT_CERT=""
+
+### Postgres Reader
+MF_POSTGRES_READER_LOG_LEVEL=debug
+MF_POSTGRES_READER_PORT=9204
+MF_POSTGRES_READER_CLIENT_TLS=false
+MF_POSTGRES_READER_CA_CERTS=""
+MF_POSTGRES_READER_DB_PORT=5432
+MF_POSTGRES_READER_DB_USER=mainflux
+MF_POSTGRES_READER_DB_PASS=mainflux
+MF_POSTGRES_READER_DB_NAME=messages
+MF_POSTGRES_READER_DB_SSL_MODE=disable
+MF_POSTGRES_READER_DB_SSL_CERT=""
+MF_POSTGRES_READER_DB_SSL_KEY=""
+MF_POSTGRES_READER_DB_SSL_ROOT_CERT=""

.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,3 @@
 build
-*.pb.go
 
 site/

CHANGELOG.md

@@ -0,0 +1,293 @@
+# Mainflux Changelog
+
+## Generation
+Mainflux release notes for the latest release can be obtained via:
+```
+make changelog
+```
+
+Otherwise, whole log in a similar format can be observed via:
+```
+git log --pretty=oneline --abbrev-commit
+```
+
+## 0.9.0 - 19. JUL 2019.
+### Features
+- Create and push docker manifest for new release from Makefile (#794)
+- MF-399 - Add open tracing support (#782)
+- MF-783 - Allow access checking by a thing ID (#784)
+- NOISSUE - Add authorization HTTP API to things service (#772)
+- Remove cli executable from repo (#776)
+- NOISSUE - Use .env vars in docker-compose (#770)
+- MF-663 - enable nginx port conf from docker env (#769)
+- Update docs (#766)
+- NOISSUE - Remove installing non-existent package in ci (#758)
+-  NOISSUE - Add searchable Channels name  (#754)
+- MF-466 - ARM docker deployment (#756)
+- Add missing Websocket.js into docker ui image (#755)
+- NOISSUE - Add searchable Things name (#750)
+- NOISSUE - Add certificate fields to the Bootstrap service (#752)
+- Update grpc and protobuf deps in mqtt adapter (#751)
+- MF-742 - Things to support single user scenario (#749)
+- MF-732 - Add Postgres reader (#740)
+- MF-722 - Change UUID lib (#746)
+- Add performance improvement to writer filtering (#744)
+- NOISSUE - Update nginx version (#748)
+- MF-574 - Add missing environment variables to Cassandra writer (#745)
+- NOISSUE - Add compile test to CI (#743)
+- MF-708 - Assign Writer(s) to a channel (#737)
+- MF-732 - Add PostgreSQL writer (#733)
+- NOISSUE - Add readers pagination in SDK (#736)
+- Add UI websocket open/close and send/receive (#728)
+- MF-707 - Allow custom Thing key (#726)
+- MF-525 - Add pagination response to the readers (#729)
+- NOISSUE - Rm Things type from lora-adapter (#727)
+- skip deleting of persistent volumes by default (#723)
+- MF-488 - Remove Thing type (app or device) (#718)
+- Remove empty channels check (#720)
+- MF-655 Proper usage of docker volumes (#657)
+- NOISSUE - Improve UI styling (#719)
+- MF-715 - Conflict on updating connection with a valid list of channels (#716)
+- MF-711 - Create separate Redis instance for ES (#717)
+- NOISSUE - Update event fields naming (#713)
+- MF-698 - Add missing info and docs about sys event sourcing (#712)
+- MF-549 - Change metadata format from JSON string to JSON object (#706)
+- NOISSUE - Replace repeating code by card gen func (#697)
+- Update Bootstrap service docker-compose.yml (#700)
+- Remove Debug function (#699)
+- MF-687 - Add event sourcing to Bootstrap service (#695)
+- NOISSUE - Remove debugging message from response of handle error function (#696)
+- Add event stream to MQTT adapter for conn status (#692)
+- NOISSUE - Improve UI style (#691)
+- Update docs structure (#686)
+- Use images instead of carousel (#685)
+- NOISSUE - Update docs (#683)
+- MF-662 - Change menu style (#678)
+- MF-651 - X509 Mutual TLS authentication (#676)
+- Update Aedes version for MQTT adapter (#677)
+- MF-661 - Bootstrap pagination in UI (#672)
+- Update subtopics section in documentation (#670)
+- Remove default base URL value (#671)
+
+### Bugfixes
+- NOISSUE - Fix Readers logs (#735)
+- NOISSUE - Fix Docker for ARM (#760)
+- NOISSUE - Fix count when search by name is performed (#767)
+- NOISSUE - Typo fix (#777)
+- NOISSUE - Fix Postgres logs in Things service (#734)
+- Fix CI with fixed plugin versions (#747)
+- fix building problems (#741)
+- fix docker-compose env (#775)
+- Fix MF_THINGS_AUTH_GRPC_PORT in addons' docker-compose files (#781)
+- Fix MQTT raw message deserialization (#753)
+- fix variant option for manifest annotate (#765)
+- fix to makefile for OSX/Darwin (#724)
+- Fix .dockerignore file by removing index.html (#725)
+- Fix things and channels metadata create and edit & remove thing type (#721)
+- Fix Bootstrap service event map keys (#705)
+- Fix logging in publish event callback (#694)
+- Fix InfluxDB time bug (#689)
+- Fix users service to work in offline mode (#795)
+- fix mainflux_id parameter in bootstrap swagger (#789)
+- Fix offset calculation after deleting thing/channel, not to go to negative offset after deleting last thing/channel (#679)
+- Use errors and null packets in authorized pub/sub (#773)
+- NOISSUE - Fix CoAP adapter (#779)
+
+
+### Summary
+https://github.com/mainflux/mainflux/milestone/10?closed=1
+
+## 0.8.0 - 20. MAR 2019.
+### Features
+- MF-571 - Add Env.elm to set custom base URL (#654)
+- NOISSUE Added docs about docker-compose config overriding (#653)
+- MF-539 - Improve Bootstrap Service documentation (#646)
+- MF-596 - Add subtopic to RawMessage (#642)
+- NOISSUE - Prevent infinite loop in lora-adapter if Redis init fail (#647)
+- Corrected grammar and rephrased a few sentences to read nicely (#641)
+- MF-571 - Elm UI (#632)
+- MF-552 - Use event sourcing to keep Bootstrap service in sync with Things service (#603)
+- MF-540 - Add pagination in API responses for Bootstrap service (#575)
+- MF-600 - Handle custom LoRa Server application decoder (#608)
+- update docker-compose (#590)
+- Update generated code (#602)
+- Add generated files check (#601)
+- MF-597 - Removed legacy code as not needed anymore (#598)
+- NOISSUE - Added normalizer service to run script (#594)
+- Changed RawMessage (#587)
+- NOISSUE - fix CLI log (#581)
+- MF-519 - Refine Message (#567)
+- NOISSUE - Add name field for Bootstrap Config (#564)
+- Fix non-SenML message routing in normalizer (#573)
+- NOISSUE - Update authors list (#569)
+- Update lora.md (#568)
+- NOISSUE- Improve LoRa doc (#562)
+- MF-551 - Add metadata fields to Bootstrap Channels (#563)
+- Fix MQTT adapter by setting subscription queue (#561)
+- MF-558 - Add MQTT subtopics documentation (#559)
+- Fix regexp for SUB (#557)
+- Simplify MQTT topipc regexp (#555)
+- MF-429 -Enabled MQTT subtopic's (#554)
+- Add env var for number of concurrent messages (#545)
+- NOISSUE - Update doc and fix empty key bug (#544)
+- MF-370 - Simplify and refine CI (#541)
+- NOISSUE - Add connection commands to CLI (#542)
+- NOISSUE - Refine docs (#537)
+- Update licnese year (#533)
+- MF-513 - Add Bootstrapping service (#524)
+- Add dedicated env vars for event sourcing (#536)
+- NOISSUE - Fix docs (#535)
+- Add lora doc to getting-started.md (#529)
+- MF-483 - Enable channels and devices corresponding lists in backend (#520)
+- Add missing components doc to architecture.md (#531)
+
+### Bugfixes
+- MF-639 Split Content-Type header field on semicolon and evaluate all substrings (#644)
+- MF-656 - Change bootstrap service port to 8200 (#658)
+- Replace crossOrigin with relative path and fix messaging bug (#645)
+- MF-579 Things & Channels returns 404 when not found or ID is malformed, not 500 (#633)
+- Fix run command in dev guide (#605)
+- MF-583 - Correct cmd/mongodb-reader HTTPServer log Info (#584)
+- Fix Dusan Maldenovic GitHub (#570)
+- Fix CLI docs (#566)
+- Fix pagination response for empty page (#547)
+- Fix swagger and provisioning docs (#546)
+- NOISSUE - Fix event sourcing client on LoRa adapter (#527)
+- Fix MQTT adapter scaling issue (#526)
+- NOISSUE - Fix subtopic regex and restrict empty subtopic parts (#659)
+- Fix missing css in container ui (#638)
+- NOISSUE - Fix lora-adapter Object decode (#610)
+- NOISSUE - Fix users logs in main.go (#577)
+- NOISSUE - Fix normalizer exposed port in docker-compose (#548)
+
+### Summary
+https://github.com/mainflux/mainflux/milestone/9?closed=1
+
+
+## 0.7.0 - 08. DEC 2018.
+### Features
+
+- MF-486 - Add provisioning command to CLI (#487)
+- Fix lora-adapter event store handlers (#492)
+- NOISSUE - Add LoRa route map validation and fix LoRa messages URL (#491)
+- MF-475 - Replace increment ID with UUID (#490)
+- MF-166 - Add lora-adapter service (#481)
+- NOISSUE - Add Makefile target to clean old imgs (#485)
+- MF-473 -  Add metadata field to channel (#476)
+- Make CoAP ping period configurable (#469)
+- Add nginx ingress config to k8s services (#472)
+- Add CoAP section in getting-started (#468)
+- NOISSUE - Move CLI documentation from getting started guide to separate page (#470)
+- NOISSUE - Update Getting Started doc with CLI usage (#465)
+- Update CoAP docs with URL example (#463)
+- MF-447 - Add event sourcing to things service (#460)
+- Add TLS support to CoAP adapter and all readers (#459)
+- MF-417 - Implement SDK tests (#438)
+- MF-454 - Use message Time field as a time for InfluxDB points (#455)
+- NOISSUE - Add .dockerignore to project root (#457)
+- Update docker-compose so that every service has debug log level (#453)
+- NOISSUE - Add TLS flag for Mainflux services (#452)
+- MF-448 - Option for Postgres SSL Mode (#449)
+- MF-443 Update project dependencies (#444)
+- MF-426 - Add optional MF_CA_CERTS env variable to allow GRPC client to use TLS certs (#430)
+- Expose the InfluxDB and Cassandra ports to host (#441)
+- MF-374 - Bring back CoAP adapter (#413)
+
+### Bugfixes
+- gRPC Load Balancing between http-adapter and things (#387)
+- MF-407 - Values of zero are being omitted  (#434)
+
+### Summary
+https://github.com/mainflux/mainflux/milestone/8?closed=1
+
+
+## 0.6.0 - 26. OCT 2018.
+### Features
+
+- Added Go SDK (#357)
+- Updated NATS version (#412)
+- Added debbug level to MFX logger (#379)
+- Added Documentation for readers (#389)
+- Added Redis cache to improve performance (#382)
+
+
+## 0.5.1 - 05. SEP 2018.
+### Features
+- Improve performance by adding Redis cache (#382)
+
+### Bugfixes
+- Mixed up name and type of the things (#375)
+- Fix MQTT topic (#380)
+
+
+## 0.5.0 - 28. AUG 2018
+### Features
+- InfluxDB Reader (#311)
+- Cassandra Reader (#313)
+- MongoDB Reader (#344)
+- MQTT Persistance via Redis (#328)
+- CLI integrated into monorepo (#216)
+- Normalizer logging (#333)
+- WS swagger doc (#337)
+- Payload renamed to Metadata (#343)
+- Protobuf files added (#363)
+- SPDX headers added (#325)
+
+### Bugfixes
+- Docker network for InfluxDB (#346)
+- Vendor correct gRPC version (#340)
+
+### Summary
+https://github.com/mainflux/mainflux/milestone/6?closed=1
+
+
+## 0.4.0 - 01. JUN 2018.
+* Integrated MQTT adapter (#165 )
+* Support for storing messages in MongoDB (#237)
+* Support for storing messages in InfluxDB (#236)
+* Use UUID PKs with auto-incremented values (#269 )
+* Replaced JWT with plain string tokens in things service (#268 )
+* Emit non-SenML messages (#239 )
+* Support for Grafana (#296)
+* Added WS Load test (#299 )
+
+
+## 0.3.0 - 14. MAY 2018.
+- CoAP API for message exchange (#186)
+- Split `manager` service into `clients` and `users` (#266)
+- Replaced ORM with raw SQL (#265)
+- Setup Kubernetes (#226, #273)
+- Fix docker compose (#274)
+- Integrated `dashflux` into monorepo (#258)
+- Integrated (*non-compatible*) `mqtt` into monorepo (#260)
+
+
+## 0.2.3 - 24. APR 2018.
+- Fix examples in the documentation (#243)
+- Add service name in info response (#241)
+- Improve code coverage in WS adapter (#242)
+
+
+## 0.2.2 - 23. APR 2018.
+- Setup load testing scenarios (#225)
+
+
+## 0.2.1 - 22. APR 2018.
+- Fixed `Content-Type` header checking (#238)
+
+## 0.2.0 - 18. APR 2018
+- Protobuf message serialization (#192)
+- Websocket API for exchanging messages (#188)
+- Channel & client retrieval paging (#227)
+- Service instrumentation (#213)
+- `go-kit` based JSON logger (#212)
+- Project documentation (#218, #220)
+- API tests (#211, #224)
+
+
+## 0.1.2 - 18. MAR 2018.
+### Bug fixes
+
+- Fixed go lint warnings (#189)
+- Compose failing startup (#185)
+- Added missing service startup messages (#190)

CONTRIBUTING.md

@@ -1,7 +1,7 @@
 # Contributing to Mainflux
 
-The following is a set of guidelines for contributing to Mainflux and its libraries, which are
-hosted in the [Mainflux Organization](https://github.com/mainflux) on GitHub.
+The following is a set of guidelines to contribute to Mainflux and its libraries, which are
+hosted on the [Mainflux Organization](https://github.com/mainflux) on GitHub.
 
 This project adheres to the [Contributor Covenant 1.2](http://contributor-covenant.org/version/1/2/0).
 By participating, you are expected to uphold this code. Please report unacceptable behavior to
@@ -9,16 +9,15 @@ By participating, you are expected to uphold this code. Please report unacceptab
 
 ## Reporting issues
 
-Reporting issues is a great way to contribute to the project. We always appreciate a well-written,
-thorough bug reports.
+Reporting issues are a great way to contribute to the project. We are perpetually grateful about a well-written,
+thorough bug report.
 
-Prior to raising a new issue, check out [our issue
-list](https://github.com/mainflux/mainflux/issues) to determine whether it already include the
-problem you are facing.
+Before raising a new issue, check [our issue
+list](https://github.com/mainflux/mainflux/issues) to determine if it already contains the
+problem that you are facing.
 
-A good bug report shouldn't leave others needing to chase you up for more information. Please try to
-be as detailed as possible. The following questions might serve as a template for writing a detailed
-reports:
+A good bug report shouldn't leave others needing to chase you for more information. Please be as detailed as possible. The following questions might serve as a template for writing a detailed
+report:
 
 - What were you trying to achieve?
 - What are the expected results?
@@ -29,16 +28,16 @@ reports:
 ## Pull requests
 
 Good pull requests (e.g. patches, improvements, new features) are a fantastic help. They should
-remain focused in scope and avoid containing unrelated commits.
+remain focused in scope and avoid unrelated commits.
 
-**Please ask first** before embarking any significant pull request (e.g. implementing new features,
+**Please ask first** before embarking on any significant pull request (e.g. implementing new features,
 refactoring code etc.), otherwise you risk spending a lot of time working on something that the
 maintainers might not want to merge into the project.
 
 Please adhere to the coding conventions used throughout the project. If in doubt, consult the
 [Effective Go](https://golang.org/doc/effective_go.html) style guide.
 
-To start contributing to the project, [fork](https://help.github.com/articles/fork-a-repo/) it,
+To contribute to the project, [fork](https://help.github.com/articles/fork-a-repo/) it,
 clone your fork repository, and configure the remotes:
 
 ```
@@ -47,7 +46,7 @@ cd mainflux
 git remote add upstream https://github.com/mainflux/mainflux.git
 ```
 
-If you cloned a while ago, get the latest changes from upstream:
+If your cloned repository is behind the upstream commits, then get the latest changes from upstream:
 
 ```
 git checkout master
@@ -63,8 +62,8 @@ git checkout -b MF-[issue-number]
 
 Commit your changes in logical chunks. When you are ready to commit, make sure
 to write a Good Commit Message™. Consult the [Erlang's contributing guide](https://github.com/erlang/otp/wiki/Writing-good-commit-messages)
-if you're not sure what constitutes a Good Commit Message™. Use [interactive rebase](https://help.github.com/articles/about-git-rebase)
-to group your commits into logical units of working before making them public.
+if you're unsure of what constitutes a Good Commit Message™. Use [interactive rebase](https://help.github.com/articles/about-git-rebase)
+to group your commits into logical units of work before making it public.
 
 Note that every commit you make must be signed. By signing off your work you indicate that you
 are accepting the [Developer Certificate of Origin](https://developercertificate.org/).

Gopkg.lock

@@ -3,92 +3,143 @@
 
 [[projects]]
   branch = "master"
+  digest = "1:6da51e5ec493ad2b44cb04129e2d0a068c8fb9bd6cb5739d199573558696bb94"
   name = "github.com/Azure/go-ansiterm"
   packages = [
     ".",
-    "winterm"
+    "winterm",
   ]
+  pruneopts = "UT"
   revision = "d6e3b3328b783f23731bc4d058875b0371ff8109"
 
 [[projects]]
+  digest = "1:9f3b30d9f8e0d7040f729b82dcbc8f0dead820a133b3147ce355fc451f32d761"
+  name = "github.com/BurntSushi/toml"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "3012a1dbe2e4bd1391d42b32f0577cb7bbc7f005"
+  version = "v0.3.1"
+
+[[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]]
-  name = "github.com/asaskevich/govalidator"
-  packages = ["."]
-  revision = "ccb8e960c48f04d6935e72476ae4a51028f9e22f"
-  version = "v9"
-
 [[projects]]
   branch = "master"
+  digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d"
   name = "github.com/beorn7/perks"
   packages = ["quantile"]
+  pruneopts = "UT"
   revision = "3a771d992973f24aa725d07868b467d1ddfceafb"
 
 [[projects]]
+  digest = "1:2209584c0f7c9b68c23374e659357ab546e1b70eec2761f03280f69a8fd23d77"
   name = "github.com/cenkalti/backoff"
   packages = ["."]
+  pruneopts = "UT"
   revision = "2ea60e5f094469f9e65adb9cd103795b73ae743e"
   version = "v2.0.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:bb300c7f4b52deb1fcc65f6be624ae3dc289453824c2f1f184963dc41d941a68"
   name = "github.com/cisco/senml"
   packages = ["."]
-  revision = "448c9510575e1dd6f780cb10addbad998cf80418"
+  pruneopts = "UT"
+  revision = "910a55054e168c1122b905e3f8acdc5ff97cbec1"
 
 [[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"
-  name = "github.com/dereulenspiegel/coap-mux"
-  packages = ["."]
-  revision = "e137e310a99955be01d60b2237da89153ea40987"
-
-[[projects]]
+  digest = "1:76dc72490af7174349349838f2fe118996381b31ea83243812a97e5a0fd5ed55"
   name = "github.com/dgrijalva/jwt-go"
   packages = ["."]
+  pruneopts = "UT"
   revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e"
   version = "v3.2.0"
 
 [[projects]]
+  digest = "1:a5036bc703c3994f70ced9b34e9941381aa6bd03e69a0ce538f43bf14dc8dc98"
+  name = "github.com/docker/docker"
+  packages = [
+    "pkg/namesgenerator",
+    "pkg/random",
+  ]
+  pruneopts = "UT"
+  revision = "092cba3727bb9b4a2f0e922cd6c0f93ea270e363"
+  version = "v1.13.1"
+
+[[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:184008c955d6a3226b700c13ed0e875a7a051a759618f9bccba9b5c99f17faa5"
+  name = "github.com/eclipse/paho.mqtt.golang"
+  packages = [
+    ".",
+    "packets",
+  ]
+  pruneopts = "UT"
+  revision = "36d01c2b4cbeb3d2a12063e4880ce30800af9560"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:865079840386857c809b72ce300be7580cb50d3d3129ce11bf9aa6ca2bc1934a"
+  name = "github.com/fatih/color"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
+  version = "v1.7.0"
+
+[[projects]]
+  digest = "1:80abda6d164916248f3297f714a17b1a33e54bb5694ff283409b4d0320357b3a"
   name = "github.com/go-kit/kit"
   packages = [
     "endpoint",
@@ -96,116 +147,269 @@
     "metrics",
     "metrics/internal/lv",
     "metrics/prometheus",
+    "tracing/opentracing",
     "transport/grpc",
-    "transport/http"
+    "transport/http",
   ]
-  revision = "4dc7be5d2d12881735283bcab7352178e190fc71"
-  version = "v0.6.0"
+  pruneopts = "UT"
+  revision = "ca4112baa34cb55091301bdc13b1420a122b1b9e"
+  version = "v0.7.0"
 
 [[projects]]
+  digest = "1:31a18dae27a29aa074515e43a443abfd2ba6deb6d69309d8d7ce789c45f34659"
   name = "github.com/go-logfmt/logfmt"
   packages = ["."]
+  pruneopts = "UT"
   revision = "390ab7935ee28ec6b286364bba9b4dd6410cb3d5"
   version = "v0.3.0"
 
 [[projects]]
+  digest = "1:424f6593024cdf0f6f90cba81bc69ca98df3758525e6fb248198ef15ead603a9"
+  name = "github.com/go-redis/redis"
+  packages = [
+    ".",
+    "internal",
+    "internal/consistenthash",
+    "internal/hashtag",
+    "internal/pool",
+    "internal/proto",
+    "internal/singleflight",
+    "internal/util",
+  ]
+  pruneopts = "UT"
+  revision = "7f89fbac80bcc62ce920b6dbc6ca60238d7725d1"
+  version = "v6.15.0"
+
+[[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]]
-  name = "github.com/gogo/protobuf"
-  packages = ["proto"]
-  revision = "1adfc126b41513cc696b209667c8656ea7aac67c"
-  version = "v1.0.0"
+  branch = "master"
+  digest = "1:348bbd07b4a983b2f811f81948c78142de09bb9fcf25284bee5e2ab3bdd0f6f9"
+  name = "github.com/gocql/gocql"
+  packages = [
+    ".",
+    "internal/lru",
+    "internal/murmur",
+    "internal/streams",
+  ]
+  pruneopts = "UT"
+  revision = "68ae1e384be4d7cd7df0f5b77f331759d806308e"
 
 [[projects]]
+  digest = "1:bed9d72d596f94e65fff37f4d6c01398074a6bb1c3f3ceff963516bd01db6ff5"
+  name = "github.com/gofrs/uuid"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "6b08a5c5172ba18946672b49749cde22873dd7c2"
+  version = "v3.2.0"
+
+[[projects]]
+  digest = "1:bbadccf3d3317ea03c0dac0b45b673b4b397c8f91a1d2eff550a3c51c4ad770e"
+  name = "github.com/gogo/protobuf"
+  packages = ["proto"]
+  pruneopts = "UT"
+  revision = "636bf0302bc95575d69441b25a2603156ffdddf1"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:5ac24c0ad5dc117fb2b6d90d205c876ec599c09cccb702a36586680e09cb20b5"
   name = "github.com/golang/protobuf"
   packages = [
     "proto",
     "ptypes",
     "ptypes/any",
     "ptypes/duration",
-    "ptypes/timestamp"
+    "ptypes/empty",
+    "ptypes/timestamp",
   ]
-  revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/gorilla/websocket"
-  packages = ["."]
-  revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
+  pruneopts = "UT"
+  revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5"
   version = "v1.2.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:4a0c6bb4805508a6287675fac876be2ac1182539ca8a32468d8128882e9d5009"
+  name = "github.com/golang/snappy"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2e65f85255dbc3072edf28d6b5b8efc472979f5a"
+
+[[projects]]
+  digest = "1:7b5c6e2eeaa9ae5907c391a91c132abfd5c9e8a784a341b5625e750c67e6825d"
+  name = "github.com/gorilla/websocket"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "66b9c49e59c6c48f0ffce28c2d8b8a5678502c6d"
+  version = "v1.4.0"
+
+[[projects]]
+  digest = "1:364b908b9b27b97ab838f2f6f1b1f46281fa29b978a037d72a9b1d4f6d940190"
+  name = "github.com/hailocab/go-hostpool"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e80d13ce29ede4452c43dea11e79b9bc8a15b478"
+
+[[projects]]
+  branch = "master"
+  digest = "1:6727359c2ab1efe714cc87acb36be6cf15a3aae078d8ae736a17fec787dab307"
+  name = "github.com/hokaccha/go-prettyjson"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "f579f869bbfea48a61fbea09207cadd1aaeceb83"
+
+[[projects]]
+  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
+  name = "github.com/inconshreveable/mousetrap"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+  version = "v1.0"
+
+[[projects]]
+  digest = "1:65b0a07f85f7b5cc019c26775efc278a155a5dea0a8aa617c980e8308d16bc55"
+  name = "github.com/influxdata/influxdb"
+  packages = [
+    "client/v2",
+    "models",
+    "pkg/escape",
+  ]
+  pruneopts = "UT"
+  revision = "a2ba6e7654fb078f8a3f5add1f8d935df38161bd"
+  version = "v1.6.4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:965881afde38cce93606988d7ef9cd187b394a8a73b11a7dde379206f5e2fba3"
+  name = "github.com/jmoiron/sqlx"
+  packages = [
+    ".",
+    "reflectx",
+  ]
+  pruneopts = "UT"
+  revision = "cdf62fdf55f66fb2484fe214f89c059f0bd3f567"
+
+[[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:4ce94f3d2074662c04677db471456feb56078244ebcfe3789e6e95901c085bc5"
   name = "github.com/nats-io/go-nats"
   packages = [
     ".",
     "encoders/builtin",
-    "util"
+    "util",
   ]
-  revision = "062418ea1c2181f52dc0f954f6204370519a868b"
-  version = "v1.5.0"
+  pruneopts = "UT"
+  revision = "fb0396ee0bdb8018b0fef30d6d1de798ce99cd05"
+  version = "v1.6.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:c2024d8533dc702a6ef5c92d5cf1494858eff4484d8abbf794f21acd29e7ef70"
+  name = "github.com/opentracing/opentracing-go"
+  packages = [
+    ".",
+    "ext",
+    "log",
+    "mocktracer",
+  ]
+  pruneopts = "UT"
+  revision = "659c90643e714681897ec2521c60567dd21da733"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:3b830e06971be8448e7c9e57c9cc15ce53ab7e8846e7b7c39110a177c7fae466"
   name = "github.com/ory/dockertest"
   packages = [
     "docker",
@@ -231,110 +435,240 @@
     "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:26663fafdea73a38075b07e8e9d82fc0056379d2be8bb4e13899e8fda7c7dd23"
   name = "github.com/prometheus/client_golang"
   packages = [
     "prometheus",
-    "prometheus/promhttp"
+    "prometheus/internal",
+    "prometheus/promhttp",
   ]
-  revision = "c5b7fccd204277076155f10851dad72b76a49317"
-  version = "v0.8.0"
+  pruneopts = "UT"
+  revision = "abad2d1bd44235a26707c172eab6bca5bf2dbad3"
+  version = "v0.9.1"
 
 [[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:89cf776c0a621a34017c819b66b9e0f0bb076d3c5b9ca74763fb89570e140038"
   name = "github.com/rubenv/sql-migrate"
   packages = [
     ".",
-    "sqlparse"
+    "sqlparse",
   ]
-  revision = "081fe17d19ff4e2dd9f5a0c1158e6bcf74da6906"
-
-[[projects]]
-  name = "github.com/satori/go.uuid"
-  packages = ["."]
-  revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3"
-  version = "v1.2.0"
+  pruneopts = "UT"
+  revision = "ba2c6a7295c59448dbc195cef2f41df5163b3892"
 
 [[projects]]
+  digest = "1:9e9193aa51197513b3abcb108970d831fbcf40ef96aa845c4f03276e1fa316d2"
   name = "github.com/sirupsen/logrus"
   packages = ["."]
+  pruneopts = "UT"
   revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
   version = "v1.0.5"
 
 [[projects]]
+  digest = "1:d3ffbc45dfe6929a4ba313464c2d761d96325d306eda29512da56c034db2a4dd"
   name = "github.com/sony/gobreaker"
   packages = ["."]
-  revision = "e9556a45379ef1da12e54847edb2fb3d7d566f36"
-  version = "0.3.0"
+  pruneopts = "UT"
+  revision = "b2a34562d02c4d5fd6645399c69e00141fb24e5a"
+  version = "0.4.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:c40d65817cdd41fac9aa7af8bed56927bb2d6d47e4fea566a74880f5c2b1c41e"
   name = "github.com/stretchr/testify"
-  packages = ["assert"]
-  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
-  version = "v1.2.1"
+  packages = [
+    "assert",
+    "require",
+  ]
+  pruneopts = "UT"
+  revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686"
+  version = "v1.2.2"
 
 [[projects]]
+  digest = "1:3b0ac1ac6f703e6d43f4e29c97da2c9e34465c66e2e19f9828e9841d1c9279a4"
+  name = "github.com/uber/jaeger-client-go"
+  packages = [
+    ".",
+    "config",
+    "internal/baggage",
+    "internal/baggage/remote",
+    "internal/spanlog",
+    "internal/throttler",
+    "internal/throttler/remote",
+    "log",
+    "rpcmetrics",
+    "thrift",
+    "thrift-gen/agent",
+    "thrift-gen/baggage",
+    "thrift-gen/jaeger",
+    "thrift-gen/sampling",
+    "thrift-gen/zipkincore",
+    "transport",
+    "utils",
+  ]
+  pruneopts = "UT"
+  revision = "2f47546e3facd43297739439600bcf43f44cce5d"
+  version = "v2.16.0"
+
+[[projects]]
+  digest = "1:c9d69a04f7fa171f50360bbcc32196b4de8ab8837ef772f6302d0140a1e3e7f6"
+  name = "github.com/uber/jaeger-lib"
+  packages = ["metrics"]
+  pruneopts = "UT"
+  revision = "0e30338a695636fe5bcf7301e8030ce8dd2a8530"
+  version = "v2.0.0"
+
+[[projects]]
+  digest = "1:03aa6e485e528acb119fb32901cf99582c380225fc7d5a02758e08b180cb56c3"
   name = "github.com/ugorji/go"
   packages = ["codec"]
+  pruneopts = "UT"
   revision = "b4c50a2b199d93b13dc15e78929cfb23bfdf21ab"
   version = "v1.1.1"
 
 [[projects]]
   branch = "master"
+  digest = "1:40fdfd6ab85ca32b6935853bbba35935dcb1d796c8135efd85947566c76e662e"
+  name = "github.com/xdg/scram"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "7eeb5667e42c09cb51bf7b7c28aea8c56767da90"
+
+[[projects]]
+  branch = "master"
+  digest = "1:f5c1d04bc09c644c592b45b9f0bad4030521b1a7d11c7dadbb272d9439fa6e8e"
+  name = "github.com/xdg/stringprep"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "73f8eece6fdcd902c185bf651de50f3828bed5ed"
+
+[[projects]]
+  digest = "1:21f9cb6f1337c4776ed1d2d7b7ed6ffba3269ca12274c065364a5c0edee1f28b"
+  name = "go.mongodb.org/mongo-driver"
+  packages = [
+    "bson",
+    "bson/bsoncodec",
+    "bson/bsonrw",
+    "bson/bsontype",
+    "bson/primitive",
+    "event",
+    "internal",
+    "mongo",
+    "mongo/options",
+    "mongo/readconcern",
+    "mongo/readpref",
+    "mongo/writeconcern",
+    "tag",
+    "version",
+    "x/bsonx",
+    "x/bsonx/bsoncore",
+    "x/mongo/driver",
+    "x/mongo/driver/auth",
+    "x/mongo/driver/auth/internal/gssapi",
+    "x/mongo/driver/session",
+    "x/mongo/driver/topology",
+    "x/mongo/driver/uuid",
+    "x/network/address",
+    "x/network/command",
+    "x/network/compressor",
+    "x/network/connection",
+    "x/network/connstring",
+    "x/network/description",
+    "x/network/result",
+    "x/network/wiremessage",
+  ]
+  pruneopts = "UT"
+  revision = "1c3b9b9a41eecdf056560e07b68e6407b8d598c3"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:7310f5459b88177d24e26c5ec7deb100b78ec03c0437d7a7aaec3c7eac333a55"
   name = "golang.org/x/crypto"
   packages = [
     "bcrypt",
     "blowfish",
-    "ssh/terminal"
+    "pbkdf2",
+    "ssh/terminal",
   ]
-  revision = "2d027ae1dddd4694d54f7a8b6cbe78dca8720226"
+  pruneopts = "UT"
+  revision = "4d3f4d9ffa16a13f451c3b2999e9c49e9750bf06"
 
 [[projects]]
   branch = "master"
+  digest = "1:70e155783b8dfd4f7697243384e2f361930ff0751459580769ce44d511f38b05"
   name = "golang.org/x/net"
   packages = [
     "context",
@@ -342,21 +676,36 @@
     "http2",
     "http2/hpack",
     "idna",
+    "internal/socks",
     "internal/timeseries",
-    "trace"
+    "proxy",
+    "trace",
+    "websocket",
   ]
+  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",
@@ -372,33 +721,40 @@
     "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:c3ad9841823db6da420a5625b367913b4ff54bbe60e8e3c98bd20e243e62e2d2"
   name = "google.golang.org/grpc"
   packages = [
     ".",
     "balancer",
     "balancer/base",
     "balancer/roundrobin",
-    "channelz",
     "codes",
     "connectivity",
     "credentials",
     "encoding",
     "encoding/proto",
-    "grpclb/grpc_lb_v1/messages",
     "grpclog",
     "internal",
+    "internal/backoff",
+    "internal/channelz",
+    "internal/envconfig",
+    "internal/grpcrand",
+    "internal/transport",
     "keepalive",
     "metadata",
     "naming",
@@ -409,26 +765,86 @@
     "stats",
     "status",
     "tap",
-    "transport"
   ]
-  revision = "41344da2231b913fa3d983840a57a6b1b7b631a1"
-  version = "v1.12.0"
+  pruneopts = "UT"
+  revision = "2e463a05d100327ca47ac218281906921038fd95"
+  version = "v1.16.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:de4bc452b049bde272d99e944aabcf218dc22df0a478a42a7107932f82430ae2"
   name = "gopkg.in/ory-am/dockertest.v3"
   packages = ["."]
-  revision = "2e92e7784b6fb199fd168aa46269a2f1b34f299e"
-  version = "v3.3.0"
+  pruneopts = "UT"
+  revision = "9f1141b78507d23603f6be530587664ebb63a8d2"
+  version = "v3.3.2"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "cce4c6cd08b6213615afc135d8e7d4f255d4ee32b42062e1f3208de246366418"
+  input-imports = [
+    "github.com/BurntSushi/toml",
+    "github.com/cisco/senml",
+    "github.com/dgrijalva/jwt-go",
+    "github.com/docker/docker/pkg/namesgenerator",
+    "github.com/dustin/go-coap",
+    "github.com/eclipse/paho.mqtt.golang",
+    "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/tracing/opentracing",
+    "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/gofrs/uuid",
+    "github.com/gogo/protobuf/proto",
+    "github.com/golang/protobuf/proto",
+    "github.com/golang/protobuf/ptypes/empty",
+    "github.com/gorilla/websocket",
+    "github.com/hokaccha/go-prettyjson",
+    "github.com/influxdata/influxdb/client/v2",
+    "github.com/jmoiron/sqlx",
+    "github.com/lib/pq",
+    "github.com/nats-io/go-nats",
+    "github.com/opentracing/opentracing-go",
+    "github.com/opentracing/opentracing-go/mocktracer",
+    "github.com/prometheus/client_golang/prometheus",
+    "github.com/prometheus/client_golang/prometheus/promhttp",
+    "github.com/rubenv/sql-migrate",
+    "github.com/sony/gobreaker",
+    "github.com/spf13/cobra",
+    "github.com/stretchr/testify/assert",
+    "github.com/stretchr/testify/require",
+    "github.com/uber/jaeger-client-go/config",
+    "go.mongodb.org/mongo-driver/bson",
+    "go.mongodb.org/mongo-driver/mongo",
+    "go.mongodb.org/mongo-driver/mongo/options",
+    "golang.org/x/crypto/bcrypt",
+    "golang.org/x/net/context",
+    "google.golang.org/grpc",
+    "google.golang.org/grpc/codes",
+    "google.golang.org/grpc/credentials",
+    "google.golang.org/grpc/status",
+    "gopkg.in/ory-am/dockertest.v3",
+  ]
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -1,26 +1,22 @@
 [[constraint]]
-  name = "github.com/asaskevich/govalidator"
-  version = "9.0.0"
-
-[[constraint]]
-  branch = "master"
   name = "github.com/cisco/senml"
-
-[[constraint]]
   branch = "master"
-  name = "github.com/dereulenspiegel/coap-mux"
 
 [[constraint]]
   name = "github.com/dgrijalva/jwt-go"
   version = "3.2.0"
 
 [[constraint]]
-  branch = "master"
-  name = "github.com/dustin/go-coap"
+  name = "github.com/eclipse/paho.mqtt.golang"
+  version = "1.1.1"
+
+[[constraint]]
+  name = "github.com/fatih/color"
+  version = "1.7.0"
 
 [[constraint]]
   name = "github.com/go-kit/kit"
-  version = "0.6.0"
+  version = "0.7.0"
 
 [[constraint]]
   name = "github.com/go-zoo/bone"
@@ -28,51 +24,96 @@
 
 [[constraint]]
   name = "github.com/golang/protobuf"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "github.com/jinzhu/gorm"
-  version = "1.9.1"
+  version = "1.2.0"
 
 [[constraint]]
+  name = "github.com/hokaccha/go-prettyjson"
   branch = "master"
+
+[[constraint]]
   name = "github.com/lib/pq"
+  branch = "master"
 
 [[constraint]]
   name = "github.com/nats-io/go-nats"
-  version = "1.4.0"
+  version = "1.6.0"
 
 [[constraint]]
   name = "github.com/prometheus/client_golang"
-  version = "0.8.0"
-
-[[constraint]]
-  name = "github.com/satori/go.uuid"
-  version = "1.2.0"
+  version = "0.9.1"
 
 [[constraint]]
   name = "github.com/sony/gobreaker"
-  version = "0.3.0"
+  version = "0.4.0"
+
+[[constraint]]
+  name = "github.com/spf13/cobra"
+  version = "0.0.3"
 
 [[constraint]]
   name = "github.com/stretchr/testify"
-  version = "1.2.1"
+  version = "1.2.2"
 
 [[constraint]]
-  branch = "master"
   name = "golang.org/x/crypto"
+  branch = "master"
 
 [[constraint]]
   name = "gopkg.in/ory-am/dockertest.v3"
-  version = "3.1.6"
+  version = "3.3.2"
 
 [[constraint]]
   name = "github.com/gorilla/websocket"
-  version = "1.2.0"
+  version = "1.4.0"
 
 [[constraint]]
-  branch = "master"
   name = "github.com/rubenv/sql-migrate"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/jmoiron/sqlx"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/influxdata/influxdb"
+  version = "1.6.4"
+
+
+[[constraint]]
+  name = "github.com/gocql/gocql"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/dustin/go-coap"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/gogo/protobuf"
+  version = "1.1.1"
+
+[[constraint]]
+  name = "google.golang.org/grpc"
+  version = "1.16.0"
+
+[[constraint]]
+  name = "github.com/go-redis/redis"
+  version = "v6.15.0"
+
+[[constraint]]
+  name = "go.mongodb.org/mongo-driver"
+  version = "~1.0.0"
+
+[[constraint]]
+  name = "github.com/BurntSushi/toml"
+  version = "~v0.3.1"
+
+[[constraint]]
+  name = "github.com/gofrs/uuid"
+  version = "~v3.2.0"
+
+[[constraint]]
+  name = "github.com/opentracing/opentracing-go"
+  version = "~v1.1.0"
 
 [prune]
   go-tests = true

LICENSE

@@ -176,7 +176,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2015-2018 Mainflux
+   Copyright 2015-2019 Mainflux
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

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,56 +1,156 @@
+## Copyright (c) 2015-2019
+## Mainflux
+##
+## SPDX-License-Identifier: Apache-2.0
+
 BUILD_DIR = build
-SERVICES = users clients http normalizer ws coap
+SERVICES = users things http normalizer ws coap lora influxdb-writer influxdb-reader mongodb-writer mongodb-reader cassandra-writer cassandra-reader postgres-writer postgres-reader cli bootstrap
 DOCKERS = $(addprefix docker_,$(SERVICES))
+DOCKERS_DEV = $(addprefix docker_dev_,$(SERVICES))
 CGO_ENABLED ?= 0
-GOOS ?= linux
+GOARCH ?= amd64
 
 define compile_service
 	CGO_ENABLED=$(CGO_ENABLED) GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) go build -ldflags "-s -w" -o ${BUILD_DIR}/mainflux-$(1) cmd/$(1)/main.go
 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=$(subst docker_,,$(1)) \
+		--build-arg GOARCH=$(GOARCH) \
+		--build-arg GOARM=$(GOARM) \
+		--tag=mainflux/$(subst docker_,,$(1))-$(2) \
+		-f docker/Dockerfile .
 endef
 
-all: $(SERVICES)
+define make_docker_dev
+	docker build \
+		--no-cache \
+		--build-arg SVC=$(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 ui latest_manifest
 
 clean:
 	rm -rf ${BUILD_DIR}
+	rm -rf mqtt/node_modules
 
+cleandocker:
+	# Stop all containers (if running)
+	docker-compose -f docker/docker-compose.yml stop
+	# Remove mainflux containers
+	docker ps -f name=mainflux -aq | xargs -r docker rm
+
+	# Remove exited containers
+	docker ps -f name=mainflux -f status=dead -f status=exited -aq | xargs -r docker rm -v
+
+	# Remove unused images
+	docker images "mainflux\/*" -f dangling=true -q | xargs -r docker rmi
+
+	# Remove old mainflux images
+	docker images -q mainflux\/* | xargs -r docker rmi
+
+ifdef pv
+	# Remove unused volumes
+	docker volume ls -f name=mainflux -f dangling=true -q | xargs -r docker volume rm
+endif
 install:
 	cp ${BUILD_DIR}/* $(GOBIN)
 
-proto:
-	protoc --go_out=plugins=grpc:. *.proto
+test:
+	go test -v -race -count 1 -tags test $(shell go list ./... | grep -v 'vendor\|cmd')
 
-$(SERVICES): proto
+proto:
+	protoc --gofast_out=plugins=grpc:. *.proto
+
+$(SERVICES):
 	$(call compile_service,$(@))
 
 $(DOCKERS):
-	$(call make_docker,$(@))
+	$(call make_docker,$(@),$(GOARCH))
 
-dockers: $(DOCKERS)
-	docker build --tag=mainflux/dashflux -f dashflux/docker/Dockerfile dashflux
-	docker build --tag=mainflux/mqtt -f mqtt/Dockerfile mqtt
+$(DOCKERS_DEV):
+	$(call make_docker_dev,$(@))
+
+docker_ui:
+	$(MAKE) -C ui docker
+
+docker_mqtt:
+	# MQTT Docker build must be done from root dir because it copies .proto files
+ifeq ($(GOARCH), arm)
+	docker build --tag=mainflux/mqtt-arm -f mqtt/Dockerfile.arm .
+else
+	docker build --tag=mainflux/mqtt-amd64 -f mqtt/Dockerfile .
+endif
+
+dockers: $(DOCKERS) docker_ui docker_mqtt
+
+dockers_dev: $(DOCKERS_DEV)
+
+ui:
+	$(MAKE) -C ui
+
+mqtt:
+	cd mqtt && npm install
+
+define docker_push
+	for svc in $(SERVICES); do \
+		docker push mainflux/$$svc-$(1):$(2); \
+	done
+	docker push mainflux/ui-$(1):$(2)
+	docker push mainflux/mqtt-$(1):$(2)
+endef
+
+changelog:
+	git log $(shell git describe --tags --abbrev=0)..HEAD --pretty=format:"- %s"
+
+define docker_manifest
+	for svc in $(SERVICES); do \
+		docker manifest create mainflux/$$svc:$(1) mainflux/$$svc-amd64:$(1) mainflux/$$svc-arm:$(1); \
+		docker manifest annotate mainflux/$$svc:$(1) mainflux/$$svc-arm:$(1) --arch arm --variant v7; \
+		docker manifest push mainflux/$$svc:$(1); \
+	done
+	docker manifest create mainflux/ui:$(1) mainflux/ui-amd64:$(1) mainflux/ui-arm:$(1)
+	docker manifest annotate mainflux/ui:$(1) mainflux/ui-arm:$(1) --arch arm --variant v7
+	docker manifest push mainflux/ui:$(1)
+	docker manifest create mainflux/mqtt:$(1) mainflux/mqtt-amd64:$(1) mainflux/mqtt-arm:$(1)
+	docker manifest annotate mainflux/mqtt:$(1) mainflux/mqtt-arm:$(1) --arch arm --variant v7
+	docker manifest push mainflux/mqtt:$(1)
+endef
 
 latest: dockers
-	for svc in $(SERVICES); do \
-		docker push mainflux/$$svc; \
-	done
-	docker push mainflux/dashflux
-	docker push mainflux/mqtt
+	$(call docker_push,$(GOARCH),latest)
+
+latest_manifest:
+	$(call docker_manifest,latest)
 
 release:
 	$(eval version = $(shell git describe --abbrev=0 --tags))
 	git checkout $(version)
-	$(MAKE) dockers
+	GOARCH=$(GOARCH) GOARM=$(GOARM) $(MAKE) dockers
 	for svc in $(SERVICES); do \
-		docker tag mainflux/$$svc mainflux/$$svc:$(version); \
-		docker push mainflux/$$svc:$(version); \
+		docker tag mainflux/$$svc-$(GOARCH) mainflux/$$svc-$(GOARCH):$(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)
+	docker tag mainflux/ui mainflux/ui-$(GOARCH):$(version)
+	docker tag mainflux/mqtt mainflux/mqtt-$(GOARCH):$(version)
+	$(call docker_push,$(GOARCH),$(version))
+	$(call docker_manifest,$(version))
+
+rundev:
+	cd scripts && ./run.sh
+
+run:
+	docker-compose -f docker/docker-compose.yml up
+
+runui:
+	$(MAKE) -C ui run
+
+runlora:
+	docker-compose -f docker/docker-compose.yml up -d
+	docker-compose -f docker/addons/influxdb-writer/docker-compose.yml up -d
+	docker-compose -f docker/addons/lora-adapter/docker-compose.yml up

README.md

@@ -10,22 +10,31 @@
 
 Mainflux is modern, scalable, secure open source and patent-free IoT cloud platform written in Go.
 
-It accepts user, device, and application connections over various network protocols (i.e. HTTP,
+It accepts user and thing connections over various network protocols (i.e. HTTP,
 MQTT, WebSocket, CoAP), thus making a seamless bridge between them. It is used as the IoT middleware
 for building complex IoT solutions.
 
 For more details, check out the [official documentation][docs].
 
-## Features
+Mainflux is member of the [Linux Foundation][lf] and an active contributor
+to the [EdgeX Foundry][edgex] project. It has been made with :heart: by [Mainflux company][company],
+which maintains the project and offers professional services around it.
 
-- Protocol bridging (i.e. HTTP, MQTT, WebSocket, CoAP)
+## Features
+- Multi-protocol connectivity and protocol bridging (HTTP, MQTT, WebSocket and CoAP)
 - Device management and provisioning
 - Fine-grained access control
+- Storage support (Cassandra, InfluxDB and MongoDB)
 - Platform logging and instrumentation support
-- Container-based deployment using [Docker][docker]
-
-## Quickstart
+- Event sourcing
+- Container-based deployment using [Docker][docker] and [Kubernetes][kubernetes]
+- [LoRaWAN][lora] network integration
+- SDK
+- CLI
+- Small memory footprint and fast execution
+- Domain-driven design architecture, high-quality code and test coverage
 
+## Install
 Before proceeding, install the following prerequisites:
 
 - [Docker](https://docs.docker.com/install/)
@@ -37,20 +46,65 @@ Once everything is installed, execute the following commands from project root:
 docker-compose -f docker/docker-compose.yml up -d
 ```
 
-## Contributing
+This will bring up all Mainflux dockers and inter-connect them in the composition.
 
+## Usage
+Best way to quickstart using Mainflux is via CLI:
+```
+make cli
+./build/mainflux-cli version
+```
+
+> Mainflux CLI can also be downloaded as a tarball from [offical release page][rel]
+
+If this works, head to [official documentation][docs] to understand Mainflux provisioning and messaging.
+
+## Documentation
+Official documentation is hosted at [Mainflux Read The Docs page][docs].
+
+Documentation is auto-generated from Markdown files in `./docs` directory.
+If you spot an error or need for corrections, please let us know - or even better: send us a PR.
+
+Additional practical information, news and tutorials can be found on the [Mainflux blog][blog].
+
+## Authors
+Main architect and BDFL of Mainflux project is [@drasko][drasko].
+
+Additionally, [@nmarcetic][nikola] and [@janko-isidorovic][janko] assured
+overall architecture and design, while [@manuio][manu] and [@darkodraskovic][darko]
+helped with crafting initial implementation and continiusly work on the project evolutions.
+
+Besides them, Mainflux is constantly improved and actively
+developed by [@anovakovic01][alex], [@dusanb94][dusan], [@srados][sava],
+[@gsaleh][george], [@blokovi][iva], [@chombium][kole] and a large set of contributors.
+
+Maintainers are listed in [MAINTAINERS](MAINTAINERS) file.
+
+Mainflux team would like to give special thanks to [@mijicd][dejan] for his monumental work
+on designing and implementing highly improved and optimized version of the platform,
+and [@malidukica][dusanm] for his effort on implementing initial user interface.
+
+## Contributing
 Thank you for your interest in Mainflux and wish to contribute!
 
 1. Take a look at our [open issues](https://github.com/mainflux/mainflux/issues).
-2. Checkout the [contribution guide](.github/CONTRIBUTING.md) to learn more about our style and conventions.
+2. Checkout the [contribution guide](CONTRIBUTING.md) to learn more about our style and conventions.
 3. Make your changes compatible to our workflow.
 
-## Community
+### We're Hiring
+If you are interested in working professionally on Mainflux,
+please head to company's [careers page][careers] or shoot us an e-mail at <careers@mainflux.com>.
 
+Note that the best way to grab our attention is by sending PRs :sunglasses:.
+
+## Community
 - [Google group][forum]
 - [Gitter][gitter]
 - [Twitter][twitter]
 
+## License
+[Apache-2.0](LICENSE)
+
 [banner]: https://github.com/mainflux/mainflux/blob/master/docs/img/gopherBanner.jpg
 [ci-badge]: https://semaphoreci.com/api/v1/mainflux/mainflux/branches/master/badge.svg
 [ci-url]: https://semaphoreci.com/mainflux/mainflux
@@ -65,3 +119,24 @@ Thank you for your interest in Mainflux and wish to contribute!
 [cov-url]: https://codecov.io/gh/mainflux/mainflux
 [license]: https://img.shields.io/badge/license-Apache%20v2.0-blue.svg
 [twitter]: https://twitter.com/mainflux
+[lora]: https://lora-alliance.org/
+[kubernetes]: https://kubernetes.io/
+[rel]: https://github.com/mainflux/mainflux/releases
+[careers]: https://www.mainflux.com/careers.html
+[lf]: https://www.linuxfoundation.org/
+[edgex]: https://www.edgexfoundry.org/
+[company]: https://www.mainflux.com/
+[blog]: https://medium.com/mainflux-iot-platform
+[drasko]: https://github.com/drasko
+[nikola]: https://github.com/nmarcetic
+[dejan]: https://github.com/mijicd
+[manu]: https://github.com/manuIO
+[darko]: https://github.com/darkodraskovic
+[janko]: https://github.com/janko-isidorovic
+[alex]: https://github.com/anovakovic01
+[dusan]: https://github.com/dusanb94
+[sava]: https://github.com/srados
+[george]: https://github.com/gesaleh
+[iva]: https://github.com/blokovi
+[kole]: https://github.com/chombium
+[dusanm]: https://github.com/malidukica

api.go

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

bootstrap/README.md

@@ -0,0 +1,139 @@
+# BOOTSTRAP SERVICE
+
+New devices need to be configured properly and connected to the Mainflux. Bootstrap service is used in order to accomplish that. This service provides the following features:
+
+  1) Creating new Mainflux Things
+  2) Providing basic configuration for the newly created Things
+  3) Enabling/disabling Things
+
+Pre-provisioning a new Thing is as simple as sending Configuration data to the Bootstrap service. Once the Thing is online, it sends a request for initial config to Bootstrap service. Bootstrap service provides an API for enabling and disabling Things. Only enabled Things can exchange messages over Mainflux. Bootstrapping does not implicitly enable Things, it has to be done manually.
+
+In order to bootstrap successfully, the Thing needs to send bootstrapping request to the specific URL, as well as a secret key. This key and URL are pre-provisioned during the manufacturing process. If the Thing is provisioned on the Bootstrap service side, the corresponding configuration will be sent as a response. Otherwise, the Thing will be saved so that it can be provisioned later.
+
+## Thing Configuration Entity
+
+Thing Configuration consists of two logical parts: the custom configuration that can be interpreted by the Thing itself and Mainflux-related configuration. Mainflux config contains:
+
+  1) corresponding Mainflux Thing ID
+  2) corresponding Mainflux Thing key
+  3) list of the Mainflux channels the Thing is connected to
+
+>Note: list of channels contains IDs of the Mainflux channels. These channels are _pre-provisioned_ on the Mainflux side and, unlike corresponding Mainflux Thing, Bootstrap service is not able to create Mainflux Channels.
+
+Enabling and disabling Thing (adding Thing to/from whitelist) is as simple as connecting corresponding Mainflux Thing to the given list of Channels. Configuration keeps _state_ of the Thing:
+
+| State    | What it means                                          |
+|----------|--------------------------------------------------------|
+| Inactive | Thing is created, but isn't enabled                    |
+| Active   | Thing is able to communicate using Mainflux            |
+
+Switching between states `Active` and `Inactive` enables and disables Thing, respectively.
+
+Thing configuration also contains the so-called `external ID` and `external key`. An external ID is a unique identifier of corresponding Thing. For example, a device MAC address is a good choice for external ID. External key is a secret key that is used for authentication during the bootstrapping procedure.
+
+## 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_BOOTSTRAP_LOG_LEVEL        | Log level for Bootstrap (debug, info, warn, error)                      | error                 |
+| MF_BOOTSTRAP_DB_HOST          | Database host address                                                   | localhost             |
+| MF_BOOTSTRAP_DB_PORT          | Database host port                                                      | 5432                  |
+| MF_BOOTSTRAP_DB_USER          | Database user                                                           | mainflux              |
+| MF_BOOTSTRAP_DB_PASS          | Database password                                                       | mainflux              |
+| MF_BOOTSTRAP_DB               | Name of the database used by the service                                | bootstrap             |
+| MF_BOOTSTRAP_DB_SSL_MODE      | Database connection SSL mode (disable, require, verify-ca, verify-full) | disable               |
+| MF_BOOTSTRAP_DB_SSL_CERT      | Path to the PEM encoded certificate file                                |                       |
+| MF_BOOTSTRAP_DB_SSL_KEY       | Path to the PEM encoded key file                                        |                       |
+| MF_BOOTSTRAP_DB_SSL_ROOT_CERT | Path to the PEM encoded root certificate file                           |                       |
+| MF_BOOTSTRAP_CLIENT_TLS       | Flag that indicates if TLS should be turned on                          | false                 |
+| MF_BOOTSTRAP_CA_CERTS         | Path to trusted CAs in PEM format                                       |                       |
+| MF_BOOTSTRAP_PORT             | Bootstrap service HTTP port                                             | 8180                  |
+| MF_BOOTSTRAP_SERVER_CERT      | Path to server certificate in pem format                                |                       |
+| MF_BOOTSTRAP_SERVER_KEY       | Path to server key in pem format                                        |                       |
+| MF_SDK_BASE_URL               | Base url for Mainflux SDK                                               | http://localhost      |
+| MF_SDK_THINGS_PREFIX          | SDK prefix for Things service                                           |                       |
+| MF_USERS_URL                  | Users service URL                                                       | localhost:8181        |
+| MF_THINGS_ES_URL              | Things service event source URL                                         | localhost:6379        |
+| MF_THINGS_ES_PASS             | Things service event source password                                    |                       |
+| MF_THINGS_ES_DB               | Things service event source database                                    | 0                     |
+| MF_BOOTSTRAP_ES_URL           | Bootstrap service event source URL                                      | localhost:6379        |
+| MF_BOOTSTRAP_ES_PASS          | Bootstrap service event source password                                 |                       |
+| MF_BOOTSTRAP_ES_DB            | Bootstrap service event source database                                 | 0                     |
+| MF_BOOTSTRAP_INSTANCE_NAME    | Bootstrap service instance name                                         | bootstrap             |
+| MF_JAEGER_URL                 | Jaeger server URL                                                       | localhost:6831        |
+| MF_BOOTSTRAP_THINGS_TIMEOUT   | Things gRPC request timeout in seconds                                  | 1                     |
+
+## Deployment
+
+The service itself 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"
+  bootstrap:
+    image: mainflux/bootstrap:latest
+    container_name: mainflux-bootstrap
+    depends_on:
+      - bootstrap-db
+    restart: on-failure
+    ports:
+      - 8200:8200
+    environment:
+      MF_BOOTSTRAP_LOG_LEVEL: [Bootstrap log level]
+      MF_BOOTSTRAP_DB_HOST: [Database host address]
+      MF_BOOTSTRAP_DB_PORT: [Database host port]
+      MF_BOOTSTRAP_DB_USER: [Database user]
+      MF_BOOTSTRAP_DB_PASS: [Database password]
+      MF_BOOTSTRAP_DB: [Name of the database used by the service]
+      MF_BOOTSTRAP_DB_SSL_MODE: [SSL mode to connect to the database with]
+      MF_BOOTSTRAP_DB_SSL_CERT: [Path to the PEM encoded certificate file]
+      MF_BOOTSTRAP_DB_SSL_KEY: [Path to the PEM encoded key file]
+      MF_BOOTSTRAP_DB_SSL_ROOT_CERT: [Path to the PEM encoded root certificate file]
+      MF_BOOTSTRAP_CLIENT_TLS: [Boolean value to enable/disable client TLS]
+      MF_BOOTSTRAP_CA_CERTS: [Path to trusted CAs in PEM format]
+      MF_BOOTSTRAP_PORT: 8200
+      MF_BOOTSTRAP_SERVER_CERT: [String path to server cert in pem format]
+      MF_BOOTSTRAP_SERVER_KEY: [String path to server key in pem format]
+      MF_SDK_BASE_URL: [Base SDK URL for the Mainflux services]
+      MF_SDK_THINGS_PREFIX: [SDK prefix for Things service]
+      MF_USERS_URL: [Users service URL]
+      MF_THINGS_ES_URL: [Things service event source URL]
+      MF_THINGS_ES_PASS: [Things service event source password]
+      MF_THINGS_ES_DB: [Things service event source database]
+      MF_BOOTSTRAP_ES_URL: [Bootstrap service event source URL]
+      MF_BOOTSTRAP_ES_PASS: [Bootstrap service event source password]
+      MF_BOOTSTRAP_ES_DB: [Bootstrap service event source database]
+      MF_BOOTSTRAP_INSTANCE_NAME: [Bootstrap service instance name]
+      MF_JAEGER_URL: [Jaeger server URL]
+      MF_BOOTSTRAP_THINGS_TIMEOUT: [Things gRPC request timeout in seconds]
+```
+
+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 service
+make bootstrap
+
+# copy binary to bin
+make install
+
+# set the environment variables and run the service
+MF_BOOTSTRAP_LOG_LEVEL=[Bootstrap log level] MF_BOOTSTRAP_DB_HOST=[Database host address] MF_BOOTSTRAP_DB_PORT=[Database host port] MF_BOOTSTRAP_DB_USER=[Database user] MF_BOOTSTRAP_DB_PASS=[Database password] MF_BOOTSTRAP_DB=[Name of the database used by the service] MF_BOOTSTRAP_DB_SSL_MODE=[SSL mode to connect to the database with] MF_BOOTSTRAP_DB_SSL_CERT=[Path to the PEM encoded certificate file] MF_BOOTSTRAP_DB_SSL_KEY=[Path to the PEM encoded key file] MF_BOOTSTRAP_DB_SSL_ROOT_CERT=[Path to the PEM encoded root certificate file] MF_BOOTSTRAP_CLIENT_TLS=[Boolean value to enable/disable client TLS] MF_BOOTSTRAP_CA_CERTS=[Path to trusted CAs in PEM format] MF_BOOTSTRAP_PORT=[Service HTTP port] MF_BOOTSTRAP_SERVER_CERT=[Path to server certificate] MF_BOOTSTRAP_SERVER_KEY=[Path to server key] MF_SDK_BASE_URL=[Base SDK URL for the Mainflux services] MF_SDK_THINGS_PREFIX=[SDK prefix for Things service] MF_USERS_URL=[Users service URL] MF_JAEGER_URL=[Jaeger server URL] MF_BOOTSTRAP_THINGS_TIMEOUT=[Things gRPC request timeout in seconds] $GOBIN/mainflux-bootstrap
+```
+
+Setting `MF_BOOTSTRAP_CA_CERTS` expects a file in PEM format of trusted CAs. This will enable TLS against the Users gRPC endpoint trusting only those CAs that are provided.
+
+## Usage
+
+For more information about service capabilities and its usage, please check out
+the [API documentation](swagger.yml).
+
+[doc]: http://mainflux.readthedocs.io

bootstrap/api/doc.go

@@ -0,0 +1,9 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// Package api contains implementation of bootstrap service HTTP API.
+package api

bootstrap/api/endpoint.go

@@ -0,0 +1,261 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package api
+
+import (
+	"context"
+
+	"github.com/go-kit/kit/endpoint"
+	"github.com/mainflux/mainflux/bootstrap"
+)
+
+func addEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(addReq)
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		channels := []bootstrap.Channel{}
+		for _, c := range req.Channels {
+			channels = append(channels, bootstrap.Channel{ID: c})
+		}
+
+		config := bootstrap.Config{
+			MFThing:     req.ThingID,
+			ExternalID:  req.ExternalID,
+			ExternalKey: req.ExternalKey,
+			MFChannels:  channels,
+			Name:        req.Name,
+			ClientCert:  req.ClientCert,
+			ClientKey:   req.ClientKey,
+			CACert:      req.CACert,
+			Content:     req.Content,
+		}
+
+		saved, err := svc.Add(req.key, config)
+		if err != nil {
+			return nil, err
+		}
+
+		res := configRes{
+			id:      saved.MFThing,
+			created: true,
+		}
+
+		return res, nil
+	}
+}
+
+func updateCertEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(updateCertReq)
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		if err := svc.UpdateCert(req.key, req.thingKey, req.ClientCert, req.ClientKey, req.CACert); err != nil {
+			return nil, err
+		}
+
+		res := configRes{}
+
+		return res, nil
+	}
+}
+
+func viewEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(entityReq)
+
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		config, err := svc.View(req.key, req.id)
+		if err != nil {
+			return nil, err
+		}
+
+		var channels []channelRes
+		for _, ch := range config.MFChannels {
+			channels = append(channels, channelRes{
+				ID:       ch.ID,
+				Name:     ch.Name,
+				Metadata: ch.Metadata,
+			})
+		}
+
+		res := viewRes{
+			MFThing:     config.MFThing,
+			MFKey:       config.MFKey,
+			Channels:    channels,
+			ExternalID:  config.ExternalID,
+			ExternalKey: config.ExternalKey,
+			Name:        config.Name,
+			Content:     config.Content,
+			State:       config.State,
+		}
+
+		return res, nil
+	}
+}
+
+func updateEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(updateReq)
+
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		config := bootstrap.Config{
+			MFThing: req.id,
+			Name:    req.Name,
+			Content: req.Content,
+		}
+
+		if err := svc.Update(req.key, config); err != nil {
+			return nil, err
+		}
+
+		res := configRes{
+			id:      config.MFThing,
+			created: false,
+		}
+
+		return res, nil
+	}
+}
+
+func updateConnEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(updateConnReq)
+
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		if err := svc.UpdateConnections(req.key, req.id, req.Channels); err != nil {
+			return nil, err
+		}
+
+		res := configRes{
+			id:      req.id,
+			created: false,
+		}
+
+		return res, nil
+	}
+}
+
+func listEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(listReq)
+
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		page, err := svc.List(req.key, req.filter, req.offset, req.limit)
+		if err != nil {
+			return nil, err
+		}
+		switch {
+		case req.filter.Unknown:
+			res := listUnknownRes{}
+			for _, cfg := range page.Configs {
+				res.Configs = append(res.Configs, unknownRes{
+					ExternalID:  cfg.ExternalID,
+					ExternalKey: cfg.ExternalKey,
+				})
+			}
+			return res, nil
+		default:
+			res := listRes{
+				Total:   page.Total,
+				Offset:  page.Offset,
+				Limit:   page.Limit,
+				Configs: []viewRes{},
+			}
+
+			for _, cfg := range page.Configs {
+				var channels []channelRes
+				for _, ch := range cfg.MFChannels {
+					channels = append(channels, channelRes{
+						ID:       ch.ID,
+						Name:     ch.Name,
+						Metadata: ch.Metadata,
+					})
+				}
+
+				view := viewRes{
+					MFThing:     cfg.MFThing,
+					MFKey:       cfg.MFKey,
+					Channels:    channels,
+					ExternalID:  cfg.ExternalID,
+					ExternalKey: cfg.ExternalKey,
+					Name:        cfg.Name,
+					Content:     cfg.Content,
+					State:       cfg.State,
+				}
+				res.Configs = append(res.Configs, view)
+			}
+
+			return res, nil
+		}
+	}
+}
+
+func removeEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(entityReq)
+
+		if err := req.validate(); err != nil {
+			return removeRes{}, err
+		}
+
+		if err := svc.Remove(req.key, req.id); err != nil {
+			return nil, err
+		}
+
+		return removeRes{}, nil
+	}
+}
+
+func bootstrapEndpoint(svc bootstrap.Service, reader bootstrap.ConfigReader) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(bootstrapReq)
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		cfg, err := svc.Bootstrap(req.key, req.id)
+		if err != nil {
+			return nil, err
+		}
+
+		return reader.ReadConfig(cfg)
+	}
+}
+
+func stateEndpoint(svc bootstrap.Service) endpoint.Endpoint {
+	return func(_ context.Context, request interface{}) (interface{}, error) {
+		req := request.(changeStateReq)
+
+		if err := req.validate(); err != nil {
+			return nil, err
+		}
+
+		if err := svc.ChangeState(req.key, req.id, req.State); err != nil {
+			return nil, err
+		}
+
+		return stateRes{}, nil
+	}
+}

bootstrap/api/logging.go

@@ -0,0 +1,199 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// +build !test
+
+package api
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/mainflux/mainflux/bootstrap"
+	log "github.com/mainflux/mainflux/logger"
+)
+
+var _ bootstrap.Service = (*loggingMiddleware)(nil)
+
+type loggingMiddleware struct {
+	logger log.Logger
+	svc    bootstrap.Service
+}
+
+// NewLoggingMiddleware adds logging facilities to the core service.
+func NewLoggingMiddleware(svc bootstrap.Service, logger log.Logger) bootstrap.Service {
+	return &loggingMiddleware{logger, svc}
+}
+
+func (lm *loggingMiddleware) Add(key string, cfg bootstrap.Config) (saved bootstrap.Config, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method add for key %s and thing %s took %s to complete", key, saved.MFThing, 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.Add(key, cfg)
+}
+
+func (lm *loggingMiddleware) View(key, id string) (saved bootstrap.Config, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method view for key %s and thing %s took %s to complete", key, saved.MFThing, 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.View(key, id)
+}
+
+func (lm *loggingMiddleware) Update(key string, cfg bootstrap.Config) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method update for key %s and thing %s took %s to complete", key, cfg.MFThing, 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.Update(key, cfg)
+}
+
+func (lm *loggingMiddleware) UpdateCert(key, thingKey, clientCert, clientKey, caCert string) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method update_cert for thing with key %s took %s to complete", thingKey, 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.UpdateCert(key, thingKey, clientCert, clientKey, caCert)
+}
+
+func (lm *loggingMiddleware) UpdateConnections(key, id string, connections []string) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method update_connections for key %s and thing %s took %s to complete", key, id, 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.UpdateConnections(key, id, connections)
+}
+
+func (lm *loggingMiddleware) List(key string, filter bootstrap.Filter, offset, limit uint64) (res bootstrap.ConfigsPage, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method list for key %s and offset %d and limit %d took %s to complete", key, offset, limit, 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.List(key, filter, offset, limit)
+}
+
+func (lm *loggingMiddleware) Remove(key, id string) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method remove for key %s and thing %s took %s to complete", key, id, 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.Remove(key, id)
+}
+
+func (lm *loggingMiddleware) Bootstrap(externalKey, externalID string) (cfg bootstrap.Config, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method bootstrap for thing with external id %s took %s to complete", externalID, 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.Bootstrap(externalKey, externalID)
+}
+
+func (lm *loggingMiddleware) ChangeState(key, id string, state bootstrap.State) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method change_state for key %s and thing %s took %s to complete", key, id, 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.ChangeState(key, id, state)
+}
+
+func (lm *loggingMiddleware) UpdateChannelHandler(channel bootstrap.Channel) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method update_channel_handler for channel %s took %s to complete", channel.ID, 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.UpdateChannelHandler(channel)
+}
+
+func (lm *loggingMiddleware) RemoveConfigHandler(id string) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method remove_config_handler for config %s took %s to complete", id, 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.RemoveConfigHandler(id)
+}
+
+func (lm *loggingMiddleware) RemoveChannelHandler(id string) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method remove_channel_handler for channel %s took %s to complete", id, 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.RemoveChannelHandler(id)
+}
+
+func (lm *loggingMiddleware) DisconnectThingHandler(channelID, thingID string) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method disconnect_thing_handler for channel %s and thing %s took %s to complete", channelID, thingID, 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.DisconnectThingHandler(channelID, thingID)
+}

bootstrap/api/metrics.go

@@ -0,0 +1,152 @@
+//
+// 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/bootstrap"
+)
+
+var _ bootstrap.Service = (*metricsMiddleware)(nil)
+
+type metricsMiddleware struct {
+	counter metrics.Counter
+	latency metrics.Histogram
+	svc     bootstrap.Service
+}
+
+// MetricsMiddleware instruments core service by tracking request count and
+// latency.
+func MetricsMiddleware(svc bootstrap.Service, counter metrics.Counter, latency metrics.Histogram) bootstrap.Service {
+	return &metricsMiddleware{
+		counter: counter,
+		latency: latency,
+		svc:     svc,
+	}
+}
+
+func (mm *metricsMiddleware) Add(key string, cfg bootstrap.Config) (saved bootstrap.Config, err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "add").Add(1)
+		mm.latency.With("method", "add").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.Add(key, cfg)
+}
+
+func (mm *metricsMiddleware) View(id, key string) (saved bootstrap.Config, err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "view").Add(1)
+		mm.latency.With("method", "view").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.View(id, key)
+}
+
+func (mm *metricsMiddleware) Update(key string, cfg bootstrap.Config) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "update").Add(1)
+		mm.latency.With("method", "update").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.Update(key, cfg)
+}
+
+func (mm *metricsMiddleware) UpdateCert(key, thingKey, clientCert, clientKey, caCert string) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "update_cert").Add(1)
+		mm.latency.With("method", "update_cert").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.UpdateCert(key, thingKey, clientCert, clientKey, caCert)
+}
+
+func (mm *metricsMiddleware) UpdateConnections(key, id string, connections []string) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "update_connections").Add(1)
+		mm.latency.With("method", "update_connections").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.UpdateConnections(key, id, connections)
+}
+
+func (mm *metricsMiddleware) List(key string, filter bootstrap.Filter, offset, limit uint64) (saved bootstrap.ConfigsPage, err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "list").Add(1)
+		mm.latency.With("method", "list").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.List(key, filter, offset, limit)
+}
+
+func (mm *metricsMiddleware) Remove(id, key string) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "remove").Add(1)
+		mm.latency.With("method", "remove").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.Remove(id, key)
+}
+
+func (mm *metricsMiddleware) Bootstrap(externalKey, externalID string) (cfg bootstrap.Config, err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "bootstrap").Add(1)
+		mm.latency.With("method", "bootstrap").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.Bootstrap(externalKey, externalID)
+}
+
+func (mm *metricsMiddleware) ChangeState(id, key string, state bootstrap.State) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "change_state").Add(1)
+		mm.latency.With("method", "change_state").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.ChangeState(id, key, state)
+}
+
+func (mm *metricsMiddleware) UpdateChannelHandler(channel bootstrap.Channel) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "update_channel").Add(1)
+		mm.latency.With("method", "update_channel").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.UpdateChannelHandler(channel)
+}
+
+func (mm *metricsMiddleware) RemoveConfigHandler(id string) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "remove_config").Add(1)
+		mm.latency.With("method", "remove_config").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.RemoveConfigHandler(id)
+}
+
+func (mm *metricsMiddleware) RemoveChannelHandler(id string) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "remove_channel").Add(1)
+		mm.latency.With("method", "remove_channel").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.RemoveChannelHandler(id)
+}
+
+func (mm *metricsMiddleware) DisconnectThingHandler(channelID, thingID string) (err error) {
+	defer func(begin time.Time) {
+		mm.counter.With("method", "disconnect_thing_handler").Add(1)
+		mm.latency.With("method", "disconnect_thing_handler").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return mm.svc.DisconnectThingHandler(channelID, thingID)
+}

bootstrap/api/requests.go

@@ -0,0 +1,172 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package api
+
+import "github.com/mainflux/mainflux/bootstrap"
+
+type apiReq interface {
+	validate() error
+}
+
+type addReq struct {
+	key         string
+	ThingID     string   `json:"thing_id"`
+	ExternalID  string   `json:"external_id"`
+	ExternalKey string   `json:"external_key"`
+	Channels    []string `json:"channels"`
+	Name        string   `json:"name"`
+	Content     string   `json:"content"`
+	ClientCert  string   `json:"client_cert"`
+	ClientKey   string   `json:"client_key"`
+	CACert      string   `json:"ca_cert"`
+}
+
+func (req addReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.ExternalID == "" || req.ExternalKey == "" {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	return nil
+}
+
+type entityReq struct {
+	key string
+	id  string
+}
+
+func (req entityReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.id == "" {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	return nil
+}
+
+type updateReq struct {
+	key     string
+	id      string
+	Name    string `json:"name"`
+	Content string `json:"content"`
+}
+
+func (req updateReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.id == "" {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	return nil
+}
+
+type updateCertReq struct {
+	key        string
+	thingKey   string
+	ClientCert string `json:"client_cert"`
+	ClientKey  string `json:"client_key"`
+	CACert     string `json:"ca_cert"`
+}
+
+func (req updateCertReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.thingKey == "" {
+		return bootstrap.ErrNotFound
+	}
+
+	return nil
+}
+
+type updateConnReq struct {
+	key      string
+	id       string
+	Channels []string `json:"channels"`
+}
+
+func (req updateConnReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.id == "" {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	return nil
+}
+
+type listReq struct {
+	key    string
+	filter bootstrap.Filter
+	offset uint64
+	limit  uint64
+}
+
+func (req listReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.limit == 0 || req.limit > maxLimit {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	return nil
+}
+
+type bootstrapReq struct {
+	key string
+	id  string
+}
+
+func (req bootstrapReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.id == "" {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	return nil
+}
+
+type changeStateReq struct {
+	key   string
+	id    string
+	State bootstrap.State `json:"state"`
+}
+
+func (req changeStateReq) validate() error {
+	if req.key == "" {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	if req.id == "" {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	if req.State != bootstrap.Inactive &&
+		req.State != bootstrap.Active {
+		return bootstrap.ErrMalformedEntity
+	}
+
+	return nil
+}

bootstrap/api/requests_test.go

@@ -0,0 +1,297 @@
+package api
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/mainflux/mainflux/bootstrap"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAddReqValidation(t *testing.T) {
+	cases := []struct {
+		desc        string
+		key         string
+		externalID  string
+		externalKey string
+		err         error
+	}{
+		{
+			desc:        "empty key",
+			key:         "",
+			externalID:  "external-id",
+			externalKey: "external-key",
+			err:         bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc:        "empty external ID",
+			key:         "key",
+			externalID:  "",
+			externalKey: "external-key",
+			err:         bootstrap.ErrMalformedEntity,
+		},
+		{
+			desc:        "empty external key",
+			key:         "key",
+			externalID:  "external-id",
+			externalKey: "",
+			err:         bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		req := addReq{
+			key:         tc.key,
+			ExternalID:  tc.externalID,
+			ExternalKey: tc.externalKey,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestEntityReqValidation(t *testing.T) {
+	cases := []struct {
+		desc string
+		key  string
+		id   string
+		err  error
+	}{
+		{
+			desc: "empty key",
+			key:  "",
+			id:   "id",
+			err:  bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc: "empty id",
+			key:  "key",
+			id:   "",
+			err:  bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		req := entityReq{
+			key: tc.key,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateReqValidation(t *testing.T) {
+	cases := []struct {
+		desc string
+		key  string
+		id   string
+		err  error
+	}{
+		{
+			desc: "empty key",
+			key:  "",
+			id:   "id",
+			err:  bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc: "empty id",
+			key:  "key",
+			id:   "",
+			err:  bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		req := updateReq{
+			key: tc.key,
+			id:  tc.id,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateCertReqValidation(t *testing.T) {
+	cases := []struct {
+		desc     string
+		key      string
+		thingKey string
+		err      error
+	}{
+		{
+			desc:     "empty key",
+			key:      "",
+			thingKey: "thingKey",
+			err:      bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc:     "empty thing key",
+			key:      "key",
+			thingKey: "",
+			err:      bootstrap.ErrNotFound,
+		},
+	}
+
+	for _, tc := range cases {
+		req := updateCertReq{
+			key:      tc.key,
+			thingKey: tc.thingKey,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateConnReqValidation(t *testing.T) {
+	cases := []struct {
+		desc string
+		key  string
+		id   string
+		err  error
+	}{
+		{
+			desc: "empty key",
+			key:  "",
+			id:   "id",
+			err:  bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc: "empty id",
+			key:  "key",
+			id:   "",
+			err:  bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		req := updateReq{
+			key: tc.key,
+			id:  tc.id,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestListReqValidation(t *testing.T) {
+	cases := []struct {
+		desc   string
+		offset uint64
+		key    string
+		limit  uint64
+		err    error
+	}{
+		{
+			desc:   "empty key",
+			key:    "",
+			offset: 0,
+			limit:  1,
+			err:    bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc:   "too large limit",
+			key:    "key",
+			offset: 0,
+			limit:  maxLimit + 1,
+			err:    bootstrap.ErrMalformedEntity,
+		},
+		{
+			desc:   "zero limit",
+			key:    "key",
+			offset: 0,
+			limit:  0,
+			err:    bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		req := listReq{
+			key:    tc.key,
+			offset: tc.offset,
+			limit:  tc.limit,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestBootstrapReqValidation(t *testing.T) {
+	cases := []struct {
+		desc      string
+		externKey string
+		externID  string
+		err       error
+	}{
+		{
+			desc:      "empty external key",
+			externKey: "",
+			externID:  "id",
+			err:       bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc:      "empty external id",
+			externKey: "key",
+			externID:  "",
+			err:       bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		req := bootstrapReq{
+			id:  tc.externID,
+			key: tc.externKey,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestChangeStateReqValidation(t *testing.T) {
+	cases := []struct {
+		desc  string
+		key   string
+		id    string
+		state bootstrap.State
+		err   error
+	}{
+		{
+			desc:  "empty key",
+			key:   "",
+			id:    "id",
+			state: bootstrap.State(1),
+			err:   bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc:  "empty id",
+			key:   "key",
+			id:    "",
+			state: bootstrap.State(0),
+			err:   bootstrap.ErrMalformedEntity,
+		},
+		{
+			desc:  "invalid state",
+			key:   "key",
+			id:    "id",
+			state: bootstrap.State(14),
+			err:   bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		req := changeStateReq{
+			key:   tc.key,
+			id:    tc.id,
+			State: tc.state,
+		}
+
+		err := req.validate()
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}

bootstrap/api/responses.go

@@ -0,0 +1,148 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package api
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/bootstrap"
+)
+
+var (
+	_ mainflux.Response = (*removeRes)(nil)
+	_ mainflux.Response = (*configRes)(nil)
+	_ mainflux.Response = (*stateRes)(nil)
+	_ mainflux.Response = (*viewRes)(nil)
+	_ mainflux.Response = (*listRes)(nil)
+)
+
+type removeRes struct{}
+
+func (res removeRes) Code() int {
+	return http.StatusNoContent
+}
+
+func (res removeRes) Headers() map[string]string {
+	return map[string]string{}
+}
+
+func (res removeRes) Empty() bool {
+	return true
+}
+
+type configRes struct {
+	id      string
+	created bool
+}
+
+func (res configRes) Code() int {
+	if res.created {
+		return http.StatusCreated
+	}
+
+	return http.StatusOK
+}
+
+func (res configRes) Headers() map[string]string {
+	if res.created {
+		return map[string]string{
+			"Location": fmt.Sprintf("/things/configs/%s", res.id),
+		}
+	}
+
+	return map[string]string{}
+}
+
+func (res configRes) Empty() bool {
+	return true
+}
+
+type channelRes struct {
+	ID       string      `json:"id"`
+	Name     string      `json:"name,omitempty"`
+	Metadata interface{} `json:"metadata,omitempty"`
+}
+
+type viewRes struct {
+	MFThing     string          `json:"mainflux_id,omitempty"`
+	MFKey       string          `json:"mainflux_key,omitempty"`
+	Channels    []channelRes    `json:"mainflux_channels,omitempty"`
+	ExternalID  string          `json:"external_id"`
+	ExternalKey string          `json:"external_key,omitempty"`
+	Content     string          `json:"content,omitempty"`
+	Name        string          `json:"name,omitempty"`
+	State       bootstrap.State `json:"state"`
+}
+
+func (res viewRes) Code() int {
+	return http.StatusOK
+}
+
+func (res viewRes) Headers() map[string]string {
+	return map[string]string{}
+}
+
+func (res viewRes) Empty() bool {
+	return false
+}
+
+type unknownRes struct {
+	ExternalID  string `json:"external_id"`
+	ExternalKey string `json:"external_key,omitempty"`
+}
+
+type listUnknownRes struct {
+	Configs []unknownRes `json:"configs"`
+}
+
+func (res listUnknownRes) Code() int {
+	return http.StatusOK
+}
+
+func (res listUnknownRes) Headers() map[string]string {
+	return map[string]string{}
+}
+
+func (res listUnknownRes) Empty() bool {
+	return false
+}
+
+type listRes struct {
+	Total   uint64    `json:"total"`
+	Offset  uint64    `json:"offset"`
+	Limit   uint64    `json:"limit"`
+	Configs []viewRes `json:"configs"`
+}
+
+func (res listRes) Code() int {
+	return http.StatusOK
+}
+
+func (res listRes) Headers() map[string]string {
+	return map[string]string{}
+}
+
+func (res listRes) Empty() bool {
+	return false
+}
+
+type stateRes struct{}
+
+func (res stateRes) Code() int {
+	return http.StatusOK
+}
+
+func (res stateRes) Headers() map[string]string {
+	return map[string]string{}
+}
+
+func (res stateRes) Empty() bool {
+	return true
+}

bootstrap/api/transport.go

@@ -0,0 +1,352 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	kithttp "github.com/go-kit/kit/transport/http"
+	"github.com/go-zoo/bone"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/bootstrap"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+const (
+	contentType  = "application/json"
+	maxLimit     = 100
+	defaultLimit = 10
+)
+
+var (
+	errUnsupportedContentType = errors.New("unsupported content type")
+	errInvalidQueryParams     = errors.New("invalid query params")
+	fullMatch                 = []string{"state", "external_id", "mainflux_id", "mainflux_key"}
+	partialMatch              = []string{"name"}
+)
+
+// MakeHandler returns a HTTP handler for API endpoints.
+func MakeHandler(svc bootstrap.Service, reader bootstrap.ConfigReader) http.Handler {
+	opts := []kithttp.ServerOption{
+		kithttp.ServerErrorEncoder(encodeError),
+	}
+	r := bone.New()
+
+	r.Post("/things/configs", kithttp.NewServer(
+		addEndpoint(svc),
+		decodeAddRequest,
+		encodeResponse,
+		opts...))
+
+	r.Get("/things/configs/:id", kithttp.NewServer(
+		viewEndpoint(svc),
+		decodeEntityRequest,
+		encodeResponse,
+		opts...))
+
+	r.Put("/things/configs/:id", kithttp.NewServer(
+		updateEndpoint(svc),
+		decodeUpdateRequest,
+		encodeResponse,
+		opts...))
+
+	r.Put("/things/configs/certs/:key", kithttp.NewServer(
+		updateCertEndpoint(svc),
+		decodeUpdateCertRequest,
+		encodeResponse,
+		opts...))
+
+	r.Put("/things/configs/connections/:id", kithttp.NewServer(
+		updateConnEndpoint(svc),
+		decodeUpdateConnRequest,
+		encodeResponse,
+		opts...))
+
+	r.Get("/things/configs", kithttp.NewServer(
+		listEndpoint(svc),
+		decodeListRequest,
+		encodeResponse,
+		opts...))
+
+	r.Get("/things/unknown/configs", kithttp.NewServer(
+		listEndpoint(svc),
+		decodeUnknownRequest,
+		encodeResponse,
+		opts...))
+
+	r.Get("/things/bootstrap/:external_id", kithttp.NewServer(
+		bootstrapEndpoint(svc, reader),
+		decodeBootstrapRequest,
+		encodeResponse,
+		opts...))
+
+	r.Put("/things/state/:id", kithttp.NewServer(
+		stateEndpoint(svc),
+		decodeStateRequest,
+		encodeResponse,
+		opts...))
+
+	r.Delete("/things/configs/:id", kithttp.NewServer(
+		removeEndpoint(svc),
+		decodeEntityRequest,
+		encodeResponse,
+		opts...))
+
+	r.GetFunc("/version", mainflux.Version("bootstrap"))
+	r.Handle("/metrics", promhttp.Handler())
+
+	return r
+}
+
+func decodeAddRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
+		return nil, errUnsupportedContentType
+	}
+
+	req := addReq{key: r.Header.Get("Authorization")}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+func decodeUpdateRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
+		return nil, errUnsupportedContentType
+	}
+
+	req := updateReq{key: r.Header.Get("Authorization")}
+	req.id = bone.GetValue(r, "id")
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+func decodeUpdateCertRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
+		return nil, errUnsupportedContentType
+	}
+
+	req := updateCertReq{key: r.Header.Get("Authorization")}
+	req.thingKey = bone.GetValue(r, "key")
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+func decodeUpdateConnRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
+		return nil, errUnsupportedContentType
+	}
+
+	req := updateConnReq{key: r.Header.Get("Authorization")}
+	req.id = bone.GetValue(r, "id")
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+func decodeUnknownRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	q, err := url.ParseQuery(r.URL.RawQuery)
+	if err != nil {
+		return nil, errInvalidQueryParams
+	}
+
+	offset, limit, err := parsePagePrams(q)
+	if err != nil {
+		return nil, err
+	}
+
+	req := listReq{
+		key:    r.Header.Get("Authorization"),
+		filter: bootstrap.Filter{Unknown: true},
+		offset: offset,
+		limit:  limit,
+	}
+
+	return req, nil
+}
+
+func decodeListRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	q, err := url.ParseQuery(r.URL.RawQuery)
+	if err != nil {
+		return nil, errInvalidQueryParams
+	}
+
+	offset, limit, err := parsePagePrams(q)
+	if err != nil {
+		return nil, err
+	}
+
+	filter := parseFilter(q)
+
+	req := listReq{
+		key:    r.Header.Get("Authorization"),
+		filter: filter,
+		offset: offset,
+		limit:  limit,
+	}
+
+	return req, nil
+}
+
+func decodeBootstrapRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	req := bootstrapReq{
+		id:  bone.GetValue(r, "external_id"),
+		key: r.Header.Get("Authorization"),
+	}
+
+	return req, nil
+}
+
+func decodeStateRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
+		return nil, errUnsupportedContentType
+	}
+
+	req := changeStateReq{key: r.Header.Get("Authorization")}
+	req.id = bone.GetValue(r, "id")
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+func decodeEntityRequest(_ context.Context, r *http.Request) (interface{}, error) {
+	req := entityReq{
+		key: r.Header.Get("Authorization"),
+		id:  bone.GetValue(r, "id"),
+	}
+
+	return req, nil
+}
+
+func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
+	w.Header().Set("Content-Type", contentType)
+	if ar, ok := response.(mainflux.Response); ok {
+		for k, v := range ar.Headers() {
+			w.Header().Set(k, v)
+		}
+
+		w.WriteHeader(ar.Code())
+
+		if ar.Empty() {
+			return nil
+		}
+	}
+
+	return json.NewEncoder(w).Encode(response)
+}
+
+func encodeError(_ context.Context, err error, w http.ResponseWriter) {
+	w.Header().Set("Content-Type", contentType)
+
+	switch err {
+	case errUnsupportedContentType:
+		w.WriteHeader(http.StatusUnsupportedMediaType)
+	case errInvalidQueryParams, bootstrap.ErrMalformedEntity:
+		w.WriteHeader(http.StatusBadRequest)
+	case bootstrap.ErrNotFound:
+		w.WriteHeader(http.StatusNotFound)
+	case bootstrap.ErrUnauthorizedAccess:
+		w.WriteHeader(http.StatusForbidden)
+	case bootstrap.ErrConflict:
+		w.WriteHeader(http.StatusConflict)
+	case bootstrap.ErrThings:
+		w.WriteHeader(http.StatusServiceUnavailable)
+	case io.EOF:
+		w.WriteHeader(http.StatusBadRequest)
+	default:
+		switch err.(type) {
+		case *json.SyntaxError:
+			w.WriteHeader(http.StatusBadRequest)
+		case *json.UnmarshalTypeError:
+			w.WriteHeader(http.StatusBadRequest)
+		default:
+			w.WriteHeader(http.StatusInternalServerError)
+		}
+	}
+}
+
+func parseUint(s string) (uint64, error) {
+	if s == "" {
+		return 0, nil
+	}
+
+	ret, err := strconv.ParseUint(s, 10, 64)
+	if err != nil {
+		return 0, errInvalidQueryParams
+	}
+
+	return ret, nil
+}
+
+func parsePagePrams(q url.Values) (uint64, uint64, error) {
+	offset, err := parseUint(q.Get("offset"))
+	q.Del("offset")
+	if err != nil {
+		return 0, 0, err
+	}
+
+	limit, err := parseUint(q.Get("limit"))
+	q.Del("limit")
+	if err != nil {
+		return 0, 0, err
+	}
+
+	if limit > maxLimit {
+		limit = maxLimit
+	}
+
+	if limit == 0 {
+		limit = defaultLimit
+	}
+
+	return offset, limit, nil
+}
+
+func parseFilter(values url.Values) bootstrap.Filter {
+	ret := bootstrap.Filter{
+		FullMatch:    make(map[string]string),
+		PartialMatch: make(map[string]string),
+	}
+	for k := range values {
+		if contains(fullMatch, k) {
+			ret.FullMatch[k] = values.Get(k)
+		}
+		if contains(partialMatch, k) {
+			ret.PartialMatch[k] = strings.ToLower(values.Get(k))
+		}
+	}
+
+	return ret
+}
+
+func contains(l []string, s string) bool {
+	for _, v := range l {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}

bootstrap/configs.go

@@ -0,0 +1,113 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package bootstrap
+
+// Config represents Configuration entity. It wraps information about external entity
+// as well as info about corresponding Mainflux entities.
+// MFThing represents corresponding Mainflux Thing ID.
+// MFKey is key of corresponding Mainflux Thing.
+// MFChannels is a list of Mainflux Channels corresponding Mainflux Thing connects to.
+type Config struct {
+	MFThing     string
+	Owner       string
+	Name        string
+	ClientCert  string
+	ClientKey   string
+	CACert      string
+	MFKey       string
+	MFChannels  []Channel
+	ExternalID  string
+	ExternalKey string
+	Content     string
+	State       State
+}
+
+// Channel represents Mainflux channel corresponding Mainflux Thing is connected to.
+type Channel struct {
+	ID       string
+	Name     string
+	Metadata map[string]interface{}
+}
+
+// Filter is used for the search filters.
+type Filter struct {
+	Unknown      bool
+	FullMatch    map[string]string
+	PartialMatch map[string]string
+}
+
+// ConfigsPage contains page related metadata as well as list of Configs that
+// belong to this page.
+type ConfigsPage struct {
+	Total   uint64
+	Offset  uint64
+	Limit   uint64
+	Configs []Config
+}
+
+// ConfigRepository specifies a Config persistence API.
+type ConfigRepository interface {
+	// Save persists the Config. Successful operation is indicated by non-nil
+	// error response.
+	Save(Config, []string) (string, error)
+
+	// RetrieveByID retrieves the Config having the provided identifier, that is owned
+	// by the specified user.
+	RetrieveByID(string, string) (Config, error)
+
+	// RetrieveAll retrieves a subset of Configs that are owned
+	// by the specific user, with given filter parameters.
+	RetrieveAll(string, Filter, uint64, uint64) ConfigsPage
+
+	// RetrieveByExternalID returns Config for given external ID.
+	RetrieveByExternalID(string, string) (Config, error)
+
+	// Update updates an existing Config. A non-nil error is returned
+	// to indicate operation failure.
+	Update(Config) error
+
+	// UpdateCerts updates an existing Config certificate and key.
+	// A non-nil error is returned to indicate operation failure.
+	UpdateCert(string, string, string, string, string) error
+
+	// UpdateConnections updates a list of Channels the Config is connected to
+	// adding new Channels if needed.
+	UpdateConnections(string, string, []Channel, []string) error
+
+	// Remove removes the Config having the provided identifier, that is owned
+	// by the specified user.
+	Remove(string, string) error
+
+	// ChangeState changes of the Config, that is owned by the specific user.
+	ChangeState(string, string, State) error
+
+	// SaveUnknown saves Thing which unsuccessfully bootstrapped.
+	SaveUnknown(string, string) error
+
+	// RetrieveUnknown returns a subset of unsuccessfully bootstrapped Things.
+	RetrieveUnknown(uint64, uint64) ConfigsPage
+
+	// ListExisting retrieves those channels from the given list that exist in DB.
+	ListExisting(string, []string) ([]Channel, error)
+
+	// Methods RemoveThing, UpdateChannel, and RemoveChannel are related to
+	// event sourcing. That's why these methods surpass ownership check.
+
+	// RemoveThing removes Config of the Thing with the given ID.
+	RemoveThing(string) error
+
+	// UpdateChannel updates channel with the given ID.
+	UpdateChannel(Channel) error
+
+	// RemoveChannel removes channel with the given ID.
+	RemoveChannel(string) error
+
+	// DisconnectHandler changes state of the Config when the corresponding Thing is
+	// disconnected from the Channel.
+	DisconnectThing(string, string) error
+}

bootstrap/doc.go

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

bootstrap/mocks/configs.go

@@ -0,0 +1,368 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package mocks
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/mainflux/mainflux/bootstrap"
+)
+
+const (
+	emptyState  = -1
+	notFoundIdx = -1
+)
+
+var _ bootstrap.ConfigRepository = (*configRepositoryMock)(nil)
+
+type configRepositoryMock struct {
+	mu       sync.Mutex
+	counter  uint64
+	configs  map[string]bootstrap.Config
+	channels map[string]bootstrap.Channel
+	unknown  map[string]string
+}
+
+// NewConfigsRepository creates in-memory config repository.
+func NewConfigsRepository(unknown map[string]string) bootstrap.ConfigRepository {
+	return &configRepositoryMock{
+		configs:  make(map[string]bootstrap.Config),
+		channels: make(map[string]bootstrap.Channel),
+		unknown:  unknown,
+	}
+}
+
+func (crm *configRepositoryMock) Save(config bootstrap.Config, connections []string) (string, error) {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	for _, v := range crm.configs {
+		if v.MFThing == config.MFThing || v.ExternalID == config.ExternalID {
+			return "", bootstrap.ErrConflict
+		}
+	}
+
+	crm.counter++
+	config.MFThing = strconv.FormatUint(crm.counter, 10)
+	crm.configs[config.MFThing] = config
+
+	for _, ch := range config.MFChannels {
+		crm.channels[ch.ID] = ch
+	}
+
+	config.MFChannels = []bootstrap.Channel{}
+
+	for _, ch := range connections {
+		config.MFChannels = append(config.MFChannels, crm.channels[ch])
+	}
+
+	crm.configs[config.MFThing] = config
+	delete(crm.unknown, config.ExternalID)
+
+	return config.MFThing, nil
+}
+
+func (crm *configRepositoryMock) RetrieveByID(key, id string) (bootstrap.Config, error) {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	c, ok := crm.configs[id]
+	if !ok {
+		return bootstrap.Config{}, bootstrap.ErrNotFound
+	}
+	if c.Owner != key {
+		return bootstrap.Config{}, bootstrap.ErrUnauthorizedAccess
+	}
+
+	return c, nil
+
+}
+
+func (crm *configRepositoryMock) RetrieveAll(key string, filter bootstrap.Filter, offset, limit uint64) bootstrap.ConfigsPage {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	configs := make([]bootstrap.Config, 0)
+
+	if offset < 0 || limit <= 0 {
+		return bootstrap.ConfigsPage{}
+	}
+
+	first := uint64(offset) + 1
+	last := first + uint64(limit)
+	var state bootstrap.State = emptyState
+	var name string
+	if s, ok := filter.FullMatch["state"]; ok {
+		val, _ := strconv.Atoi(s)
+		state = bootstrap.State(val)
+	}
+
+	if s, ok := filter.PartialMatch["name"]; ok {
+		name = strings.ToLower(s)
+	}
+
+	var total uint64
+	for _, v := range crm.configs {
+		id, _ := strconv.ParseUint(v.MFThing, 10, 64)
+		if (state == emptyState || v.State == state) &&
+			(name == "" || strings.Index(strings.ToLower(v.Name), name) != notFoundIdx) &&
+			v.Owner == key {
+			if id >= first && id < last {
+				configs = append(configs, v)
+			}
+			total++
+		}
+	}
+
+	sort.SliceStable(configs, func(i, j int) bool {
+		return configs[i].MFThing < configs[j].MFThing
+	})
+
+	return bootstrap.ConfigsPage{
+		Total:   total,
+		Offset:  offset,
+		Limit:   limit,
+		Configs: configs,
+	}
+}
+
+func (crm *configRepositoryMock) RetrieveByExternalID(externalKey, externalID string) (bootstrap.Config, error) {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	for _, cfg := range crm.configs {
+		if cfg.ExternalID == externalID && cfg.ExternalKey == externalKey {
+			return cfg, nil
+		}
+	}
+
+	return bootstrap.Config{}, bootstrap.ErrNotFound
+}
+
+func (crm *configRepositoryMock) Update(config bootstrap.Config) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	cfg, ok := crm.configs[config.MFThing]
+	if !ok || cfg.Owner != config.Owner {
+		return bootstrap.ErrNotFound
+	}
+
+	cfg.Name = config.Name
+	cfg.Content = config.Content
+	crm.configs[config.MFThing] = cfg
+
+	return nil
+}
+
+func (crm *configRepositoryMock) UpdateCert(owner, thingKey, clientCert, clientKey, caCert string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+	var forUpdate bootstrap.Config
+	for _, v := range crm.configs {
+		if v.MFKey == thingKey && v.Owner == owner {
+			forUpdate = v
+			break
+		}
+	}
+	if _, ok := crm.configs[forUpdate.MFThing]; !ok {
+		return bootstrap.ErrNotFound
+	}
+	forUpdate.ClientCert = clientCert
+	forUpdate.ClientKey = clientKey
+	forUpdate.CACert = caCert
+	crm.configs[forUpdate.MFThing] = forUpdate
+
+	return nil
+}
+
+func (crm *configRepositoryMock) UpdateConnections(key, id string, channels []bootstrap.Channel, connections []string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	config, ok := crm.configs[id]
+	if !ok {
+		return bootstrap.ErrNotFound
+	}
+
+	for _, ch := range channels {
+		crm.channels[ch.ID] = ch
+	}
+
+	config.MFChannels = []bootstrap.Channel{}
+	for _, conn := range connections {
+		ch, ok := crm.channels[conn]
+		if !ok {
+			return bootstrap.ErrNotFound
+		}
+		config.MFChannels = append(config.MFChannels, ch)
+	}
+	crm.configs[id] = config
+
+	return nil
+}
+
+func (crm *configRepositoryMock) Remove(key, id string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	for k, v := range crm.configs {
+		if v.Owner == key && k == id {
+			delete(crm.configs, k)
+			break
+		}
+	}
+
+	return nil
+}
+
+func (crm *configRepositoryMock) ChangeState(key, id string, state bootstrap.State) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	config, ok := crm.configs[id]
+	if !ok {
+		return bootstrap.ErrNotFound
+	}
+	if config.Owner != key {
+		return bootstrap.ErrUnauthorizedAccess
+	}
+
+	config.State = state
+	crm.configs[id] = config
+	return nil
+}
+
+func (crm *configRepositoryMock) RetrieveUnknown(offset, limit uint64) bootstrap.ConfigsPage {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	configs := []bootstrap.Config{}
+	i := uint64(0)
+	l := int(limit)
+	var keys []string
+	for k := range crm.unknown {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, k := range keys {
+		if i >= offset && len(configs) < l {
+			configs = append(configs, bootstrap.Config{
+				ExternalID:  k,
+				ExternalKey: crm.unknown[k],
+			})
+		}
+		i++
+	}
+
+	return bootstrap.ConfigsPage{
+		Total:   uint64(len(crm.unknown)),
+		Offset:  offset,
+		Limit:   limit,
+		Configs: configs,
+	}
+}
+
+func (crm *configRepositoryMock) RemoveUnknown(key, id string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	for k, v := range crm.unknown {
+		if k == id && v == key {
+			delete(crm.unknown, k)
+			return nil
+		}
+	}
+
+	return nil
+}
+
+func (crm *configRepositoryMock) SaveUnknown(key, id string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	crm.unknown[id] = key
+	return nil
+}
+
+func (crm *configRepositoryMock) ListExisting(key string, connections []string) ([]bootstrap.Channel, error) {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	var ret []bootstrap.Channel
+
+	for k, v := range crm.channels {
+		for _, conn := range connections {
+			if conn == k {
+				ret = append(ret, v)
+				break
+			}
+		}
+	}
+
+	return ret, nil
+}
+
+func (crm *configRepositoryMock) RemoveThing(id string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	delete(crm.configs, id)
+	return nil
+}
+
+func (crm *configRepositoryMock) UpdateChannel(ch bootstrap.Channel) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	channel, ok := crm.channels[ch.ID]
+	if !ok {
+		return nil
+	}
+
+	channel.Name = ch.Name
+	channel.Metadata = ch.Metadata
+	crm.channels[ch.ID] = channel
+	return nil
+}
+
+func (crm *configRepositoryMock) RemoveChannel(id string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	delete(crm.channels, id)
+	return nil
+}
+
+func (crm *configRepositoryMock) DisconnectThing(channelID, thingID string) error {
+	crm.mu.Lock()
+	defer crm.mu.Unlock()
+
+	idx := -1
+	if config, ok := crm.configs[thingID]; ok {
+		for i, ch := range config.MFChannels {
+			if ch.ID == channelID {
+				idx = i
+				break
+			}
+		}
+
+		if idx != -1 {
+			config.MFChannels = append(config.MFChannels[0:idx], config.MFChannels[idx:]...)
+		}
+		crm.configs[thingID] = config
+	}
+
+	delete(crm.channels, channelID)
+
+	return nil
+}

bootstrap/mocks/things.go

@@ -0,0 +1,217 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package mocks
+
+import (
+	"context"
+	"strconv"
+	"sync"
+
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/things"
+)
+
+var _ things.Service = (*mainfluxThings)(nil)
+
+type mainfluxThings struct {
+	mu          sync.Mutex
+	counter     uint64
+	things      map[string]things.Thing
+	channels    map[string]things.Channel
+	users       mainflux.UsersServiceClient
+	connections map[string][]string
+}
+
+// NewThingsService returns Mainflux Things service mock.
+// Only methods used by SDK are mocked.
+func NewThingsService(things map[string]things.Thing, channels map[string]things.Channel, users mainflux.UsersServiceClient) things.Service {
+	return &mainfluxThings{
+		things:      things,
+		channels:    channels,
+		users:       users,
+		connections: make(map[string][]string),
+	}
+}
+
+func (svc *mainfluxThings) AddThing(_ context.Context, owner string, thing things.Thing) (things.Thing, error) {
+	svc.mu.Lock()
+	defer svc.mu.Unlock()
+
+	userID, err := svc.users.Identify(context.Background(), &mainflux.Token{Value: owner})
+	if err != nil {
+		return things.Thing{}, things.ErrUnauthorizedAccess
+	}
+
+	svc.counter++
+	thing.Owner = userID.Value
+	thing.ID = strconv.FormatUint(svc.counter, 10)
+	thing.Key = thing.ID
+	svc.things[thing.ID] = thing
+	return thing, nil
+}
+
+func (svc *mainfluxThings) ViewThing(_ context.Context, owner, id string) (things.Thing, error) {
+	svc.mu.Lock()
+	defer svc.mu.Unlock()
+
+	userID, err := svc.users.Identify(context.Background(), &mainflux.Token{Value: owner})
+	if err != nil {
+		return things.Thing{}, things.ErrUnauthorizedAccess
+	}
+
+	if t, ok := svc.things[id]; ok && t.Owner == userID.Value {
+		return t, nil
+
+	}
+
+	return things.Thing{}, things.ErrNotFound
+}
+
+func (svc *mainfluxThings) Connect(_ context.Context, owner, chanID, thingID string) error {
+	svc.mu.Lock()
+	defer svc.mu.Unlock()
+
+	userID, err := svc.users.Identify(context.Background(), &mainflux.Token{Value: owner})
+	if err != nil {
+		return things.ErrUnauthorizedAccess
+	}
+
+	if svc.channels[chanID].Owner != userID.Value {
+		return things.ErrNotFound
+	}
+
+	svc.connections[chanID] = append(svc.connections[chanID], thingID)
+	return nil
+}
+
+func (svc *mainfluxThings) Disconnect(_ context.Context, owner, chanID, thingID string) error {
+	svc.mu.Lock()
+	defer svc.mu.Unlock()
+
+	userID, err := svc.users.Identify(context.Background(), &mainflux.Token{Value: owner})
+	if err != nil || svc.channels[chanID].Owner != userID.Value {
+		return things.ErrUnauthorizedAccess
+	}
+
+	ids := svc.connections[chanID]
+	i := 0
+	for _, t := range ids {
+		if t == thingID {
+			break
+		}
+		i++
+	}
+
+	if i == len(ids) {
+		return things.ErrNotFound
+	}
+
+	var tmp []string
+	if i != len(ids)-2 {
+		tmp = ids[i+1:]
+	}
+	ids = append(ids[:i], tmp...)
+	svc.connections[chanID] = ids
+
+	return nil
+}
+
+func (svc *mainfluxThings) RemoveThing(_ context.Context, owner, id string) error {
+	svc.mu.Lock()
+	defer svc.mu.Unlock()
+
+	userID, err := svc.users.Identify(context.Background(), &mainflux.Token{Value: owner})
+	if err != nil {
+		return things.ErrUnauthorizedAccess
+	}
+
+	if t, ok := svc.things[id]; !ok || t.Owner != userID.Value {
+		return things.ErrNotFound
+	}
+
+	delete(svc.things, id)
+	conns := make(map[string][]string)
+	for k, v := range svc.connections {
+		idx := findIndex(v, id)
+		if idx != -1 {
+			var tmp []string
+			if idx != len(v)-2 {
+				tmp = v[idx+1:]
+			}
+			conns[k] = append(v[:idx], tmp...)
+		}
+	}
+
+	svc.connections = conns
+	return nil
+}
+
+func (svc *mainfluxThings) ViewChannel(_ context.Context, owner, id string) (things.Channel, error) {
+	if c, ok := svc.channels[id]; ok {
+		return c, nil
+	}
+	return things.Channel{}, things.ErrNotFound
+}
+
+func (svc *mainfluxThings) UpdateThing(context.Context, string, things.Thing) error {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) UpdateKey(context.Context, string, string, string) error {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) ListThings(context.Context, string, uint64, uint64, string) (things.ThingsPage, error) {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) ListChannelsByThing(context.Context, string, string, uint64, uint64) (things.ChannelsPage, error) {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) ListThingsByChannel(context.Context, string, string, uint64, uint64) (things.ThingsPage, error) {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) CreateChannel(context.Context, string, things.Channel) (things.Channel, error) {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) UpdateChannel(context.Context, string, things.Channel) error {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) ListChannels(context.Context, string, uint64, uint64, string) (things.ChannelsPage, error) {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) RemoveChannel(context.Context, string, string) error {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) CanAccess(context.Context, string, string) (string, error) {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) CanAccessByID(context.Context, string, string) error {
+	panic("not implemented")
+}
+
+func (svc *mainfluxThings) Identify(context.Context, string) (string, error) {
+	panic("not implemented")
+}
+
+func findIndex(list []string, val string) int {
+	for i, v := range list {
+		if v == val {
+			return i
+		}
+	}
+
+	return -1
+}

bootstrap/mocks/users.go

@@ -1,3 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package mocks
 
 import (
@@ -19,9 +26,9 @@ func NewUsersService(users map[string]string) mainflux.UsersServiceClient {
 	return &usersServiceMock{users}
 }
 
-func (svc usersServiceMock) Identify(ctx context.Context, in *mainflux.Token, opts ...grpc.CallOption) (*mainflux.Identity, error) {
+func (svc usersServiceMock) Identify(ctx context.Context, in *mainflux.Token, opts ...grpc.CallOption) (*mainflux.UserID, error) {
 	if id, ok := svc.users[in.Value]; ok {
-		return &mainflux.Identity{Value: id}, nil
+		return &mainflux.UserID{Value: id}, nil
 	}
 	return nil, users.ErrUnauthorizedAccess
 }

bootstrap/postgres/configs.go

@@ -0,0 +1,714 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package postgres
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/lib/pq"
+	"github.com/mainflux/mainflux/bootstrap"
+	"github.com/mainflux/mainflux/logger"
+)
+
+const (
+	duplicateErr      = "unique_violation"
+	uuidErr           = "invalid input syntax for type uuid"
+	connConstraintErr = "connections_config_id_fkey"
+	fkViolation       = "foreign_key_violation"
+	configFieldsNum   = 8
+	chanFieldsNum     = 3
+	connFieldsNum     = 2
+	cleanupQuery      = `DELETE FROM channels ch WHERE NOT EXISTS (
+						 SELECT channel_id FROM connections c WHERE ch.mainflux_channel = c.channel_id);`
+)
+
+var _ bootstrap.ConfigRepository = (*configRepository)(nil)
+
+type configRepository struct {
+	db  *sqlx.DB
+	log logger.Logger
+}
+
+// NewConfigRepository instantiates a PostgreSQL implementation of config
+// repository.
+func NewConfigRepository(db *sqlx.DB, log logger.Logger) bootstrap.ConfigRepository {
+	return &configRepository{db: db, log: log}
+}
+
+func (cr configRepository) Save(cfg bootstrap.Config, connections []string) (string, error) {
+	q := `INSERT INTO configs (mainflux_thing, owner, name, client_cert, client_key, ca_cert, mainflux_key, external_id, external_key, content, state)
+		  VALUES (:mainflux_thing, :owner, :name, :client_cert, :client_key, :ca_cert, :mainflux_key, :external_id, :external_key, :content, :state)`
+
+	tx, err := cr.db.Beginx()
+	if err != nil {
+		return "", err
+	}
+
+	dbcfg := toDBConfig(cfg)
+
+	if _, err := tx.NamedExec(q, dbcfg); err != nil {
+		e := err
+		if pqErr, ok := err.(*pq.Error); ok && pqErr.Code.Name() == duplicateErr {
+			e = bootstrap.ErrConflict
+		}
+
+		cr.rollback("Failed to insert a Config", tx, err)
+
+		return "", e
+	}
+
+	if err := insertChannels(cfg.Owner, cfg.MFChannels, tx); err != nil {
+		cr.rollback("Failed to insert Channels", tx, err)
+
+		return "", err
+	}
+
+	if err := insertConnections(cfg, connections, tx); err != nil {
+		cr.rollback("Failed to insert connections", tx, err)
+
+		return "", err
+	}
+
+	q = "DELETE FROM unknown_configs WHERE external_id = :external_id AND external_key = :external_key"
+
+	if _, err := tx.NamedExec(q, dbcfg); err != nil {
+		cr.rollback("Failed to remove from unknown", tx, err)
+
+		return "", err
+	}
+
+	if err := tx.Commit(); err != nil {
+		cr.rollback("Failed to commit Config save", tx, err)
+	}
+
+	return cfg.MFThing, nil
+}
+
+func (cr configRepository) RetrieveByID(key, id string) (bootstrap.Config, error) {
+	q := `SELECT mainflux_thing, mainflux_key, external_id, external_key, name, content, state 
+		  FROM configs 
+		  WHERE mainflux_thing = $1 AND owner = $2`
+
+	dbcfg := dbConfig{
+		MFThing: id,
+		Owner:   key,
+	}
+
+	if err := cr.db.QueryRowx(q, id, key).StructScan(&dbcfg); err != nil {
+		empty := bootstrap.Config{}
+		if err == sql.ErrNoRows {
+			return empty, bootstrap.ErrNotFound
+		}
+
+		return empty, err
+	}
+
+	q = `SELECT mainflux_channel, name, metadata FROM channels ch
+		 INNER JOIN connections conn
+		 ON ch.mainflux_channel = conn.channel_id AND ch.owner = conn.config_owner
+		 WHERE conn.config_id = :mainflux_thing AND conn.config_owner = :owner`
+
+	rows, err := cr.db.NamedQuery(q, dbcfg)
+	if err != nil {
+		cr.log.Error(fmt.Sprintf("Failed to retrieve connected due to %s", err))
+		return bootstrap.Config{}, err
+	}
+	defer rows.Close()
+
+	chans := []bootstrap.Channel{}
+	for rows.Next() {
+		dbch := dbChannel{}
+		if err := rows.StructScan(&dbch); err != nil {
+			cr.log.Error(fmt.Sprintf("Failed to read connected thing due to %s", err))
+			return bootstrap.Config{}, err
+		}
+		dbch.Owner = nullString(dbcfg.Owner)
+
+		ch, err := toChannel(dbch)
+		if err != nil {
+			return bootstrap.Config{}, err
+		}
+		chans = append(chans, ch)
+	}
+
+	cfg := toConfig(dbcfg)
+	cfg.MFChannels = chans
+
+	return cfg, nil
+}
+
+func (cr configRepository) RetrieveAll(key string, filter bootstrap.Filter, offset, limit uint64) bootstrap.ConfigsPage {
+	search, params := cr.retrieveAll(key, filter)
+	n := len(params)
+
+	q := `SELECT mainflux_thing, mainflux_key, external_id, external_key, name, content, state
+	      FROM configs %s ORDER BY mainflux_thing LIMIT $%d OFFSET $%d`
+	q = fmt.Sprintf(q, search, n+1, n+2)
+
+	rows, err := cr.db.Query(q, append(params, limit, offset)...)
+	if err != nil {
+		cr.log.Error(fmt.Sprintf("Failed to retrieve configs due to %s", err))
+		return bootstrap.ConfigsPage{}
+	}
+	defer rows.Close()
+
+	var name, content sql.NullString
+	configs := []bootstrap.Config{}
+
+	for rows.Next() {
+		c := bootstrap.Config{Owner: key}
+		if err := rows.Scan(&c.MFThing, &c.MFKey, &c.ExternalID, &c.ExternalKey, &name, &content, &c.State); err != nil {
+			cr.log.Error(fmt.Sprintf("Failed to read retrieved config due to %s", err))
+			return bootstrap.ConfigsPage{}
+		}
+
+		c.Name = name.String
+		c.Content = content.String
+		configs = append(configs, c)
+	}
+
+	q = fmt.Sprintf(`SELECT COUNT(*) FROM configs %s`, search)
+
+	var total uint64
+	if err := cr.db.QueryRow(q, params...).Scan(&total); err != nil {
+		cr.log.Error(fmt.Sprintf("Failed to count configs due to %s", err))
+		return bootstrap.ConfigsPage{}
+	}
+
+	return bootstrap.ConfigsPage{
+		Total:   total,
+		Limit:   limit,
+		Offset:  offset,
+		Configs: configs,
+	}
+}
+
+func (cr configRepository) RetrieveByExternalID(externalKey, externalID string) (bootstrap.Config, error) {
+	q := `SELECT mainflux_thing, mainflux_key, owner, name, client_cert, client_key, ca_cert, content, state 
+		  FROM configs 
+		  WHERE external_key = $1 AND external_id = $2`
+	dbcfg := dbConfig{
+		ExternalID:  externalID,
+		ExternalKey: externalKey,
+	}
+
+	if err := cr.db.QueryRowx(q, externalKey, externalID).StructScan(&dbcfg); err != nil {
+		empty := bootstrap.Config{}
+		if err == sql.ErrNoRows {
+			return empty, bootstrap.ErrNotFound
+		}
+		return empty, err
+	}
+
+	q = `SELECT mainflux_channel, name, metadata FROM channels ch
+		 INNER JOIN connections conn
+		 ON ch.mainflux_channel = conn.channel_id AND ch.owner = conn.config_owner
+		 WHERE conn.config_id = :mainflux_thing AND conn.config_owner = :owner`
+
+	rows, err := cr.db.NamedQuery(q, dbcfg)
+	if err != nil {
+		cr.log.Error(fmt.Sprintf("Failed to retrieve connected due to %s", err))
+		return bootstrap.Config{}, err
+	}
+	defer rows.Close()
+
+	channels := []bootstrap.Channel{}
+	for rows.Next() {
+		dbch := dbChannel{}
+		if err := rows.StructScan(&dbch); err != nil {
+			cr.log.Error(fmt.Sprintf("Failed to read connected thing due to %s", err))
+			return bootstrap.Config{}, err
+		}
+
+		ch, err := toChannel(dbch)
+		if err != nil {
+			cr.log.Error(fmt.Sprintf("Failed to deserialize channel due to %s", err))
+			return bootstrap.Config{}, err
+		}
+
+		channels = append(channels, ch)
+	}
+
+	cfg := toConfig(dbcfg)
+	cfg.MFChannels = channels
+
+	return cfg, nil
+}
+
+func (cr configRepository) Update(cfg bootstrap.Config) error {
+	q := `UPDATE configs SET name = $1, content = $2 WHERE mainflux_thing = $3 AND owner = $4`
+
+	content := nullString(cfg.Content)
+	name := nullString(cfg.Name)
+
+	res, err := cr.db.Exec(q, name, content, cfg.MFThing, cfg.Owner)
+	if err != nil {
+		return err
+	}
+
+	cnt, err := res.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if cnt == 0 {
+		return bootstrap.ErrNotFound
+	}
+
+	return nil
+}
+
+func (cr configRepository) UpdateCert(key, thingKey, clientCert, clientKey, caCert string) error {
+	q := `UPDATE configs SET client_cert = $1, client_key = $2, ca_cert = $3 WHERE mainflux_key = $4 AND owner = $5`
+
+	res, err := cr.db.Exec(q, clientCert, clientKey, caCert, thingKey, key)
+	if err != nil {
+		return err
+	}
+
+	cnt, err := res.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if cnt == 0 {
+		return bootstrap.ErrNotFound
+	}
+
+	return nil
+}
+
+func (cr configRepository) UpdateConnections(key, id string, channels []bootstrap.Channel, connections []string) error {
+	tx, err := cr.db.Beginx()
+	if err != nil {
+		return err
+	}
+
+	if err := insertChannels(key, channels, tx); err != nil {
+		cr.rollback("Failed to insert Channels during the update", tx, err)
+
+		return err
+	}
+
+	if err := updateConnections(key, id, connections, tx); err != nil {
+		if e, ok := err.(*pq.Error); ok {
+			if e.Code.Name() == fkViolation && e.Constraint == connConstraintErr {
+				return bootstrap.ErrNotFound
+			}
+		}
+		cr.rollback("Failed to update connections during the update", tx, err)
+
+		return err
+	}
+
+	if err := tx.Commit(); err != nil {
+		cr.rollback("Failed to commit Config update", tx, err)
+	}
+
+	return nil
+}
+
+func (cr configRepository) Remove(key, id string) error {
+	q := `DELETE FROM configs WHERE mainflux_thing = $1 AND owner = $2`
+	if _, err := cr.db.Exec(q, id, key); err != nil {
+		return err
+	}
+
+	if _, err := cr.db.Exec(cleanupQuery); err != nil {
+		cr.log.Warn("Failed to clean dangling channels after removal")
+	}
+
+	return nil
+}
+
+func (cr configRepository) ChangeState(key, id string, state bootstrap.State) error {
+	q := `UPDATE configs SET state = $1 WHERE mainflux_thing = $2 AND owner = $3;`
+
+	res, err := cr.db.Exec(q, state, id, key)
+	if err != nil {
+		return err
+	}
+
+	cnt, err := res.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if cnt == 0 {
+		return bootstrap.ErrNotFound
+	}
+
+	return nil
+}
+
+func (cr configRepository) ListExisting(key string, ids []string) ([]bootstrap.Channel, error) {
+	var channels []bootstrap.Channel
+	if len(ids) == 0 {
+		return channels, nil
+	}
+
+	q := "SELECT mainflux_channel, name, metadata FROM channels WHERE owner = $1 AND mainflux_channel = ANY ($2)"
+	rows, err := cr.db.Queryx(q, key, pq.Array(ids))
+	if err != nil {
+		return []bootstrap.Channel{}, err
+	}
+
+	for rows.Next() {
+		var dbch dbChannel
+		if err := rows.StructScan(&dbch); err != nil {
+			cr.log.Error(fmt.Sprintf("Failed to read retrieved channels due to %s", err))
+			return []bootstrap.Channel{}, err
+		}
+
+		ch, err := toChannel(dbch)
+		if err != nil {
+			cr.log.Error(fmt.Sprintf("Failed to deserialize channel due to %s", err))
+			return []bootstrap.Channel{}, err
+		}
+
+		channels = append(channels, ch)
+	}
+
+	return channels, nil
+}
+
+func (cr configRepository) SaveUnknown(key, id string) error {
+	q := `INSERT INTO unknown_configs (external_id, external_key) VALUES ($1, $2)`
+
+	if _, err := cr.db.Exec(q, id, key); err != nil {
+		if pqErr, ok := err.(*pq.Error); ok && pqErr.Code.Name() == duplicateErr {
+			return nil
+		}
+		return err
+	}
+
+	return nil
+}
+
+func (cr configRepository) RetrieveUnknown(offset, limit uint64) bootstrap.ConfigsPage {
+	q := `SELECT external_id, external_key FROM unknown_configs LIMIT $1 OFFSET $2`
+	rows, err := cr.db.Query(q, limit, offset)
+	if err != nil {
+		cr.log.Error(fmt.Sprintf("Failed to retrieve config due to %s", err))
+		return bootstrap.ConfigsPage{}
+	}
+	defer rows.Close()
+
+	items := []bootstrap.Config{}
+	for rows.Next() {
+		c := bootstrap.Config{}
+		if err := rows.Scan(&c.ExternalID, &c.ExternalKey); err != nil {
+			cr.log.Error(fmt.Sprintf("Failed to read retrieved config due to %s", err))
+			return bootstrap.ConfigsPage{}
+		}
+
+		items = append(items, c)
+	}
+
+	q = fmt.Sprintf(`SELECT COUNT(*) FROM unknown_configs`)
+
+	var total uint64
+	if err := cr.db.QueryRow(q).Scan(&total); err != nil {
+		cr.log.Error(fmt.Sprintf("Failed to count unknown configs due to %s", err))
+		return bootstrap.ConfigsPage{}
+	}
+
+	return bootstrap.ConfigsPage{
+		Total:   total,
+		Offset:  offset,
+		Limit:   limit,
+		Configs: items,
+	}
+}
+
+func (cr configRepository) RemoveThing(id string) error {
+	q := `DELETE FROM configs WHERE mainflux_thing = $1`
+	_, err := cr.db.Exec(q, id)
+
+	if _, err := cr.db.Exec(cleanupQuery); err != nil {
+		cr.log.Warn("Failed to clean dangling channels after removal")
+	}
+
+	return err
+}
+
+func (cr configRepository) UpdateChannel(channel bootstrap.Channel) error {
+	dbch, err := toDBChannel("", channel)
+	if err != nil {
+		return err
+	}
+
+	q := `UPDATE channels SET name = :name, metadata = :metadata WHERE mainflux_channel = :mainflux_channel`
+	_, err = cr.db.NamedExec(q, dbch)
+
+	return err
+}
+
+func (cr configRepository) RemoveChannel(id string) error {
+	q := `DELETE FROM channels WHERE mainflux_channel = $1`
+	_, err := cr.db.Exec(q, id)
+
+	return err
+}
+
+func (cr configRepository) DisconnectThing(channelID, thingID string) error {
+	q := `UPDATE configs SET state = $1 WHERE EXISTS (
+		SELECT 1 FROM connections WHERE config_id = $2 AND channel_id = $3)`
+	_, err := cr.db.Exec(q, bootstrap.Inactive, thingID, channelID)
+
+	return err
+}
+
+func (cr configRepository) retrieveAll(key string, filter bootstrap.Filter) (string, []interface{}) {
+	template := `WHERE owner = $1 %s`
+	params := []interface{}{key}
+	// One empty string so that strings Join works if only one filter is applied.
+	queries := []string{""}
+	// Since key is the first param, start from 2.
+	counter := 2
+	for k, v := range filter.FullMatch {
+		queries = append(queries, fmt.Sprintf("%s = $%d", k, counter))
+		params = append(params, v)
+		counter++
+	}
+	for k, v := range filter.PartialMatch {
+		queries = append(queries, fmt.Sprintf("LOWER(%s) LIKE '%%' || $%d || '%%'", k, counter))
+		params = append(params, v)
+		counter++
+	}
+
+	f := strings.Join(queries, " AND ")
+
+	return fmt.Sprintf(template, f), params
+}
+
+func (cr configRepository) rollback(content string, tx *sqlx.Tx, err error) {
+	cr.log.Error(fmt.Sprintf("%s %s", content, err))
+
+	if err := tx.Rollback(); err != nil {
+		cr.log.Error(fmt.Sprintf("Failed to rollback due to %s", err))
+	}
+}
+
+func insertChannels(key string, channels []bootstrap.Channel, tx *sqlx.Tx) error {
+	if len(channels) == 0 {
+		return nil
+	}
+
+	var chans []dbChannel
+	for _, ch := range channels {
+		dbch, err := toDBChannel(key, ch)
+		if err != nil {
+			return err
+		}
+		chans = append(chans, dbch)
+	}
+
+	q := `INSERT INTO channels (mainflux_channel, owner, name, metadata) 
+		  VALUES (:mainflux_channel, :owner, :name, :metadata)`
+	if _, err := tx.NamedExec(q, chans); err != nil {
+		e := err
+		if pqErr, ok := err.(*pq.Error); ok && pqErr.Code.Name() == duplicateErr {
+			e = bootstrap.ErrConflict
+		}
+		return e
+	}
+
+	return nil
+}
+
+func insertConnections(cfg bootstrap.Config, connections []string, tx *sqlx.Tx) error {
+	if len(connections) == 0 {
+		return nil
+	}
+
+	q := `INSERT INTO connections (config_id, channel_id, config_owner, channel_owner) 
+		  VALUES (:config_id, :channel_id, :config_owner, :channel_owner)`
+	conns := []dbConnection{}
+	for _, conn := range connections {
+		dbconn := dbConnection{
+			Config:       cfg.MFThing,
+			Channel:      conn,
+			ConfigOwner:  cfg.Owner,
+			ChannelOwner: cfg.Owner,
+		}
+		conns = append(conns, dbconn)
+	}
+	_, err := tx.NamedExec(q, conns)
+
+	return err
+}
+
+func updateConnections(key, id string, connections []string, tx *sqlx.Tx) error {
+	if len(connections) == 0 {
+		return nil
+	}
+
+	q := `DELETE FROM connections
+		  WHERE config_id = $1 AND config_owner = $2 AND channel_owner = $2
+		  AND channel_id NOT IN ($3)`
+
+	res, err := tx.Exec(q, id, key, pq.Array(connections))
+	if err != nil {
+		return err
+	}
+
+	cnt, err := res.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	q = `INSERT INTO connections (config_id, channel_id, config_owner, channel_owner) 
+		 VALUES (:config_id, :channel_id, :config_owner, :channel_owner)`
+
+	conns := []dbConnection{}
+	for _, conn := range connections {
+		dbconn := dbConnection{
+			Config:       id,
+			Channel:      conn,
+			ConfigOwner:  key,
+			ChannelOwner: key,
+		}
+		conns = append(conns, dbconn)
+	}
+
+	if _, err := tx.NamedExec(q, conns); err != nil {
+		return err
+	}
+
+	if cnt == 0 {
+		return nil
+	}
+
+	_, err = tx.Exec(cleanupQuery)
+
+	return err
+}
+
+func nullString(s string) sql.NullString {
+	if s == "" {
+		return sql.NullString{}
+	}
+
+	return sql.NullString{
+		String: s,
+		Valid:  true,
+	}
+}
+
+type dbConfig struct {
+	MFThing     string          `db:"mainflux_thing"`
+	Owner       string          `db:"owner"`
+	Name        sql.NullString  `db:"name"`
+	ClientCert  sql.NullString  `db:"client_cert"`
+	ClientKey   sql.NullString  `db:"client_key"`
+	CaCert      sql.NullString  `db:"ca_cert"`
+	MFKey       string          `db:"mainflux_key"`
+	ExternalID  string          `db:"external_id"`
+	ExternalKey string          `db:"external_key"`
+	Content     sql.NullString  `db:"content"`
+	State       bootstrap.State `db:"state"`
+}
+
+func toDBConfig(cfg bootstrap.Config) dbConfig {
+	return dbConfig{
+		MFThing:     cfg.MFThing,
+		Owner:       cfg.Owner,
+		Name:        nullString(cfg.Name),
+		ClientCert:  nullString(cfg.ClientCert),
+		ClientKey:   nullString(cfg.ClientKey),
+		CaCert:      nullString(cfg.CACert),
+		MFKey:       cfg.MFKey,
+		ExternalID:  cfg.ExternalID,
+		ExternalKey: cfg.ExternalKey,
+		Content:     nullString(cfg.Content),
+		State:       cfg.State,
+	}
+}
+
+func toConfig(dbcfg dbConfig) bootstrap.Config {
+	cfg := bootstrap.Config{
+		MFThing:     dbcfg.MFThing,
+		Owner:       dbcfg.Owner,
+		MFKey:       dbcfg.MFKey,
+		ExternalID:  dbcfg.ExternalID,
+		ExternalKey: dbcfg.ExternalKey,
+		State:       dbcfg.State,
+	}
+
+	if dbcfg.Name.Valid {
+		cfg.Name = dbcfg.Name.String
+	}
+
+	if dbcfg.Content.Valid {
+		cfg.Content = dbcfg.Content.String
+	}
+
+	if dbcfg.ClientCert.Valid {
+		cfg.ClientCert = dbcfg.ClientCert.String
+	}
+
+	if dbcfg.ClientKey.Valid {
+		cfg.ClientKey = dbcfg.ClientKey.String
+	}
+
+	if dbcfg.CaCert.Valid {
+		cfg.CACert = dbcfg.CaCert.String
+	}
+	return cfg
+}
+
+type dbChannel struct {
+	ID       string         `db:"mainflux_channel"`
+	Name     sql.NullString `db:"name"`
+	Owner    sql.NullString `db:"owner"`
+	Metadata string         `db:"metadata"`
+}
+
+func toDBChannel(owner string, ch bootstrap.Channel) (dbChannel, error) {
+	dbch := dbChannel{
+		ID:    ch.ID,
+		Name:  nullString(ch.Name),
+		Owner: nullString(owner),
+	}
+
+	metadata, err := json.Marshal(ch.Metadata)
+	if err != nil {
+		return dbChannel{}, err
+	}
+
+	dbch.Metadata = string(metadata)
+	return dbch, nil
+}
+
+func toChannel(dbch dbChannel) (bootstrap.Channel, error) {
+	ch := bootstrap.Channel{
+		ID: dbch.ID,
+	}
+
+	if dbch.Name.Valid {
+		ch.Name = dbch.Name.String
+	}
+
+	if err := json.Unmarshal([]byte(dbch.Metadata), &ch.Metadata); err != nil {
+		return bootstrap.Channel{}, err
+	}
+
+	return ch, nil
+}
+
+type dbConnection struct {
+	Config       string `db:"config_id"`
+	Channel      string `db:"channel_id"`
+	ConfigOwner  string `db:"config_owner"`
+	ChannelOwner string `db:"channel_owner"`
+}

bootstrap/postgres/configs_test.go

@@ -0,0 +1,772 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package postgres_test
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/gofrs/uuid"
+	"github.com/mainflux/mainflux/bootstrap"
+	"github.com/mainflux/mainflux/bootstrap/postgres"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const numConfigs = 10
+
+var (
+	config = bootstrap.Config{
+		MFThing:     "mf-thing",
+		MFKey:       "mf-key",
+		ExternalID:  "external-id",
+		ExternalKey: "external-key",
+		Owner:       "user@email.com",
+		MFChannels: []bootstrap.Channel{
+			bootstrap.Channel{ID: "1", Name: "name 1", Metadata: map[string]interface{}{"meta": 1.0}},
+			bootstrap.Channel{ID: "2", Name: "name 2", Metadata: map[string]interface{}{"meta": 2.0}},
+		},
+		Content: "content",
+		State:   bootstrap.Inactive,
+	}
+
+	channels = []string{"1", "2"}
+)
+
+func TestSave(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	diff := "different"
+
+	duplicateThing := config
+	duplicateThing.ExternalID = diff
+	duplicateThing.MFKey = diff
+	duplicateThing.MFChannels = []bootstrap.Channel{}
+
+	duplicateExternal := config
+	duplicateExternal.MFThing = diff
+	duplicateExternal.MFKey = diff
+	duplicateExternal.MFChannels = []bootstrap.Channel{}
+
+	duplicateChannels := config
+	duplicateChannels.ExternalID = diff
+	duplicateChannels.MFKey = diff
+	duplicateChannels.MFThing = diff
+
+	cases := []struct {
+		desc        string
+		config      bootstrap.Config
+		connections []string
+		err         error
+	}{
+		{
+			desc:        "save a config",
+			config:      config,
+			connections: channels,
+			err:         nil,
+		},
+		{
+			desc:        "save config with same Thing ID",
+			config:      duplicateThing,
+			connections: nil,
+			err:         bootstrap.ErrConflict,
+		},
+		{
+			desc:        "save config with same external ID",
+			config:      duplicateExternal,
+			connections: nil,
+			err:         bootstrap.ErrConflict,
+		},
+		{
+			desc:        "save config with same Channels",
+			config:      duplicateChannels,
+			connections: channels,
+			err:         bootstrap.ErrConflict,
+		},
+	}
+	for _, tc := range cases {
+		_, err := repo.Save(tc.config, tc.connections)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestRetrieveByID(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	id, err := repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	nonexistentConfID, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+
+	cases := []struct {
+		desc  string
+		owner string
+		id    string
+		err   error
+	}{
+		{
+			desc:  "retrieve config",
+			owner: c.Owner,
+			id:    id,
+			err:   nil,
+		},
+		{
+			desc:  "retrieve config with wrong owner",
+			owner: "2",
+			id:    id,
+			err:   bootstrap.ErrNotFound,
+		},
+		{
+			desc:  "retrieve a non-existing config",
+			owner: c.Owner,
+			id:    nonexistentConfID.String(),
+			err:   bootstrap.ErrNotFound,
+		},
+		{
+			desc:  "retrieve a config with invalid ID",
+			owner: c.Owner,
+			id:    "invalid",
+			err:   bootstrap.ErrNotFound,
+		},
+	}
+	for _, tc := range cases {
+		_, err := repo.RetrieveByID(tc.owner, tc.id)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestRetrieveAll(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	for i := 0; i < numConfigs; i++ {
+		c := config
+		// Use UUID to prevent conflict errors.
+
+		uid, err := uuid.NewV4()
+		require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+		c.ExternalID = uid.String()
+		c.Name = fmt.Sprintf("name %d", i)
+		c.MFThing = uid.String()
+		c.MFKey = uid.String()
+
+		if i%2 == 0 {
+			c.State = bootstrap.Active
+		}
+
+		if i > 0 {
+			c.MFChannels = nil
+		}
+
+		_, err = repo.Save(c, channels)
+		require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	}
+
+	cases := []struct {
+		desc   string
+		owner  string
+		offset uint64
+		limit  uint64
+		filter bootstrap.Filter
+		size   int
+	}{
+		{
+			desc:   "retrieve all",
+			owner:  config.Owner,
+			offset: 0,
+			limit:  uint64(numConfigs),
+			size:   numConfigs,
+		},
+		{
+			desc:   "retrieve subset",
+			owner:  config.Owner,
+			offset: 5,
+			limit:  uint64(numConfigs - 5),
+			size:   numConfigs - 5,
+		},
+		{
+			desc:   "retrieve wrong owner",
+			owner:  "2",
+			offset: 0,
+			limit:  uint64(numConfigs),
+			size:   0,
+		},
+		{
+			desc:   "retrieve all active",
+			owner:  config.Owner,
+			offset: 0,
+			limit:  uint64(numConfigs),
+			filter: bootstrap.Filter{FullMatch: map[string]string{"state": bootstrap.Active.String()}},
+			size:   numConfigs / 2,
+		},
+		{
+			desc:   "retrieve search by name",
+			owner:  config.Owner,
+			offset: 0,
+			limit:  uint64(numConfigs),
+			filter: bootstrap.Filter{PartialMatch: map[string]string{"name": "1"}},
+			size:   1,
+		},
+	}
+	for _, tc := range cases {
+		ret := repo.RetrieveAll(tc.owner, tc.filter, tc.offset, tc.limit)
+		size := len(ret.Configs)
+		assert.Equal(t, tc.size, size, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.size, size))
+	}
+}
+
+func TestRetrieveByExternalID(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	_, err = repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc        string
+		externalID  string
+		externalKey string
+		err         error
+	}{
+		{
+			desc:        "retrieve with invalid external ID",
+			externalID:  strconv.Itoa(numConfigs + 1),
+			externalKey: config.ExternalKey,
+			err:         bootstrap.ErrNotFound,
+		},
+		{
+			desc:        "retrieve with invalid external key",
+			externalID:  c.ExternalID,
+			externalKey: "invalid",
+			err:         bootstrap.ErrNotFound,
+		},
+		{
+			desc:        "retrieve with external key",
+			externalID:  c.ExternalID,
+			externalKey: c.ExternalKey,
+			err:         nil,
+		},
+	}
+	for _, tc := range cases {
+		_, err := repo.RetrieveByExternalID(tc.externalKey, tc.externalID)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdate(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	_, err = repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	c.Content = "new content"
+	c.Name = "new name"
+
+	wrongOwner := c
+	wrongOwner.Owner = "3"
+
+	cases := []struct {
+		desc   string
+		id     string
+		config bootstrap.Config
+		err    error
+	}{
+		{
+			desc:   "update with wrong owner",
+			config: wrongOwner,
+			err:    bootstrap.ErrNotFound,
+		},
+		{
+			desc:   "update a config",
+			config: c,
+			err:    nil,
+		},
+	}
+	for _, tc := range cases {
+		err := repo.Update(tc.config)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateCert(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	_, err = repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	c.Content = "new content"
+	c.Name = "new name"
+
+	wrongOwner := c
+	wrongOwner.Owner = "3"
+
+	cases := []struct {
+		desc    string
+		key     string
+		owner   string
+		cert    string
+		certKey string
+		ca      string
+		err     error
+	}{
+		{
+			desc:    "update with wrong owner",
+			key:     "",
+			cert:    "cert",
+			certKey: "certKey",
+			ca:      "",
+			owner:   "wrong",
+			err:     bootstrap.ErrNotFound,
+		},
+		{
+			desc:    "update a config",
+			key:     c.MFKey,
+			cert:    "cert",
+			certKey: "certKey",
+			ca:      "ca",
+			owner:   c.Owner,
+			err:     nil,
+		},
+	}
+	for _, tc := range cases {
+		err := repo.UpdateCert(tc.owner, tc.key, tc.cert, tc.key, tc.ca)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateConnections(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	_, err = repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	// Use UUID to prevent conflicts.
+	uid, err = uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	c.MFChannels = []bootstrap.Channel{}
+	c2, err := repo.Save(c, []string{channels[0]})
+	require.Nil(t, err, fmt.Sprintf("Saving a config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc        string
+		key         string
+		id          string
+		channels    []bootstrap.Channel
+		connections []string
+		err         error
+	}{
+		{
+			desc:        "update connections of non-existing config",
+			key:         config.Owner,
+			id:          "unknown",
+			channels:    nil,
+			connections: []string{channels[1]},
+			err:         bootstrap.ErrNotFound,
+		},
+		{
+			desc:        "update connections",
+			key:         config.Owner,
+			id:          c.MFThing,
+			channels:    nil,
+			connections: []string{channels[1]},
+			err:         nil,
+		},
+		{
+			desc:        "update connections with existing channels",
+			key:         config.Owner,
+			id:          c2,
+			channels:    nil,
+			connections: channels,
+			err:         nil,
+		},
+		{
+			desc:        "update connections no channels",
+			key:         config.Owner,
+			id:          c.MFThing,
+			channels:    nil,
+			connections: nil,
+			err:         nil,
+		},
+	}
+	for _, tc := range cases {
+		err := repo.UpdateConnections(tc.key, tc.id, tc.channels, tc.connections)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestRemove(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	id, err := repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	// Removal works the same for both existing and non-existing
+	// (removed) config
+	for i := 0; i < 2; i++ {
+		err := repo.Remove(c.Owner, id)
+		require.Nil(t, err, fmt.Sprintf("%d: failed to remove config due to: %s", i, err))
+
+		_, err = repo.RetrieveByID(c.Owner, id)
+		require.Equal(t, bootstrap.ErrNotFound, err, fmt.Sprintf("%d: expected %s got %s", i, bootstrap.ErrNotFound, err))
+	}
+}
+
+func TestChangeState(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	saved, err := repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc  string
+		owner string
+		id    string
+		state bootstrap.State
+		err   error
+	}{
+		{
+			desc:  "change state with wrong owner",
+			id:    saved,
+			owner: "2",
+			err:   bootstrap.ErrNotFound,
+		},
+		{
+			desc:  "change state with wrong id",
+			id:    "wrong",
+			owner: c.Owner,
+			err:   bootstrap.ErrNotFound,
+		},
+		{
+			desc:  "change state to Active",
+			id:    saved,
+			owner: c.Owner,
+			state: bootstrap.Active,
+			err:   nil,
+		},
+		{
+			desc:  "change state to Inactive",
+			id:    saved,
+			owner: c.Owner,
+			state: bootstrap.Inactive,
+			err:   nil,
+		},
+	}
+	for _, tc := range cases {
+		err := repo.ChangeState(tc.owner, tc.id, tc.state)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestListExisting(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	_, err = repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	var chs []bootstrap.Channel
+	for _, ch := range config.MFChannels {
+		chs = append(chs, ch)
+	}
+
+	cases := []struct {
+		desc        string
+		key         string
+		connections []string
+		existing    []bootstrap.Channel
+	}{
+		{
+			desc:        "list all existing channels",
+			key:         c.Owner,
+			connections: channels,
+			existing:    chs,
+		},
+		{
+			desc:        "list a subset of existing channels",
+			key:         c.Owner,
+			connections: []string{channels[0], "5"},
+			existing:    []bootstrap.Channel{chs[0]},
+		},
+		{
+			desc:        "list a subset of existing channels empty",
+			key:         c.Owner,
+			connections: []string{"5", "6"},
+			existing:    []bootstrap.Channel{},
+		},
+	}
+	for _, tc := range cases {
+		existing, err := repo.ListExisting(tc.key, tc.connections)
+		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error: %s", tc.desc, err))
+		assert.ElementsMatch(t, tc.existing, existing, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.existing, existing))
+	}
+}
+
+func TestSaveUnknown(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+
+	cases := []struct {
+		desc        string
+		externalID  string
+		externalKey string
+		err         error
+	}{
+		{
+			desc:        "save unknown",
+			externalID:  "unknown",
+			externalKey: "unknown",
+			err:         nil,
+		},
+		{
+			desc:        "save invalid unknown",
+			externalID:  "unknown",
+			externalKey: "",
+			err:         nil,
+		},
+	}
+	for _, tc := range cases {
+		err := repo.SaveUnknown(tc.externalKey, tc.externalID)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestRetrieveUnknown(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+
+	for i := 0; i < numConfigs; i++ {
+		id, err := uuid.NewV4()
+		require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+		repo.SaveUnknown(id.String(), id.String())
+	}
+
+	cases := []struct {
+		desc   string
+		offset uint64
+		limit  uint64
+		size   int
+	}{
+		{
+			desc:   "retrieve all",
+			offset: 0,
+			limit:  uint64(numConfigs),
+			size:   numConfigs,
+		},
+		{
+			desc:   "retrieve a subset",
+			offset: 5,
+			limit:  uint64(numConfigs - 5),
+			size:   numConfigs - 5,
+		},
+	}
+	for _, tc := range cases {
+		ret := repo.RetrieveUnknown(tc.offset, tc.limit)
+		size := len(ret.Configs)
+		assert.Equal(t, tc.size, size, fmt.Sprintf("%s: expected %d got %d\n", tc.desc, tc.size, size))
+	}
+}
+
+func TestRemoveThing(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	saved, err := repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	for i := 0; i < 2; i++ {
+		err := repo.RemoveThing(saved)
+		assert.Nil(t, err, fmt.Sprintf("an unexpected error occured: %s\n", err))
+	}
+}
+
+func TestUpdateChannel(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	_, err = repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	id := c.MFChannels[0].ID
+	update := bootstrap.Channel{
+		ID:       id,
+		Name:     "update name",
+		Metadata: map[string]interface{}{"update": "metadata update"},
+	}
+	err = repo.UpdateChannel(update)
+	assert.Nil(t, err, fmt.Sprintf("updating config expected to succeed: %s.\n", err))
+
+	cfg, err := repo.RetrieveByID(c.Owner, c.MFThing)
+	require.Nil(t, err, fmt.Sprintf("Retrieving config expected to succeed: %s.\n", err))
+	var retreved bootstrap.Channel
+	for _, c := range cfg.MFChannels {
+		if c.ID == id {
+			retreved = c
+			break
+		}
+	}
+
+	assert.Equal(t, update, retreved, fmt.Sprintf("expected %s, go %s", update, retreved))
+}
+
+func TestRemoveChannel(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	_, err = repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	err = repo.RemoveChannel(c.MFChannels[0].ID)
+	require.Nil(t, err, fmt.Sprintf("Retrieving config expected to succeed: %s.\n", err))
+
+	cfg, err := repo.RetrieveByID(c.Owner, c.MFThing)
+	require.Nil(t, err, fmt.Sprintf("Retrieving config expected to succeed: %s.\n", err))
+	assert.NotContains(t, cfg.MFChannels, c.MFChannels[0], fmt.Sprintf("expected to remove channel %s from %s", c.MFChannels[0], cfg.MFChannels))
+}
+
+func TestDisconnectThing(t *testing.T) {
+	repo := postgres.NewConfigRepository(db, testLog)
+	err := deleteChannels(repo)
+	require.Nil(t, err, "Channels cleanup expected to succeed.")
+
+	c := config
+	// Use UUID to prevent conflicts.
+	uid, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.MFKey = uid.String()
+	c.MFThing = uid.String()
+	c.ExternalID = uid.String()
+	c.ExternalKey = uid.String()
+	saved, err := repo.Save(c, channels)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	err = repo.DisconnectThing(c.MFChannels[0].ID, saved)
+	require.Nil(t, err, fmt.Sprintf("Retrieving config expected to succeed: %s.\n", err))
+
+	cfg, err := repo.RetrieveByID(c.Owner, c.MFThing)
+	require.Nil(t, err, fmt.Sprintf("Retrieving config expected to succeed: %s.\n", err))
+	assert.Equal(t, cfg.State, bootstrap.Inactive, fmt.Sprintf("expected ti be inactive when a connection is removed from %s", cfg))
+}
+
+func deleteChannels(repo bootstrap.ConfigRepository) error {
+	for _, ch := range channels {
+		if err := repo.RemoveChannel(ch); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

bootstrap/postgres/doc.go

@@ -1,3 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 // Package postgres contains repository implementations using PostgreSQL as
 // the underlying database.
 package postgres

bootstrap/postgres/init.go

@@ -0,0 +1,104 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package postgres
+
+import (
+	"fmt"
+
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq" // required for SQL access
+	migrate "github.com/rubenv/sql-migrate"
+)
+
+// Config defines the options that are used when connecting to a PostgreSQL instance
+type Config struct {
+	Host        string
+	Port        string
+	User        string
+	Pass        string
+	Name        string
+	SSLMode     string
+	SSLCert     string
+	SSLKey      string
+	SSLRootCert string
+}
+
+// Connect creates a connection to the PostgreSQL instance and applies any
+// unapplied database migrations. A non-nil error is returned to indicate
+// failure.
+func Connect(cfg Config) (*sqlx.DB, error) {
+	url := fmt.Sprintf("host=%s port=%s user=%s dbname=%s password=%s sslmode=%s sslcert=%s sslkey=%s sslrootcert=%s", cfg.Host, cfg.Port, cfg.User, cfg.Name, cfg.Pass, cfg.SSLMode, cfg.SSLCert, cfg.SSLKey, cfg.SSLRootCert)
+
+	db, err := sqlx.Open("postgres", url)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := migrateDB(db); err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+func migrateDB(db *sqlx.DB) error {
+	migrations := &migrate.MemoryMigrationSource{
+		Migrations: []*migrate.Migration{
+			{
+				Id: "configs_1",
+				Up: []string{
+					`CREATE TABLE IF NOT EXISTS configs (
+						mainflux_thing TEXT UNIQUE NOT NULL,
+						owner          VARCHAR(254),
+						name           TEXT,
+						mainflux_key   CHAR(36) UNIQUE NOT NULL,
+						external_id    TEXT UNIQUE NOT NULL,
+						external_key   TEXT NOT NULL,
+						content  	   TEXT,
+						client_cert	   TEXT,
+						client_key 	   TEXT,
+						ca_cert 	   TEXT,
+						state          BIGINT NOT NULL,
+						PRIMARY KEY (mainflux_thing, owner)
+					)`,
+					`CREATE TABLE IF NOT EXISTS unknown_configs (
+						external_id  TEXT UNIQUE NOT NULL,
+						external_key TEXT NOT NULL,
+						PRIMARY KEY (external_id, external_key)
+					)`,
+					`CREATE TABLE IF NOT EXISTS channels (
+						mainflux_channel TEXT UNIQUE NOT NULL,
+						owner    		 VARCHAR(254),
+						name     		 TEXT,
+						metadata 		 JSON,
+						PRIMARY KEY (mainflux_channel, owner)
+					)`,
+					`CREATE TABLE IF NOT EXISTS connections (
+						channel_id    TEXT,
+						channel_owner VARCHAR(256),
+						config_id     TEXT,
+						config_owner  VARCHAR(256),
+						FOREIGN KEY (channel_id, channel_owner) REFERENCES channels (mainflux_channel, owner) ON DELETE CASCADE ON UPDATE CASCADE,
+						FOREIGN KEY (config_id, config_owner) REFERENCES configs (mainflux_thing, owner) ON DELETE CASCADE ON UPDATE CASCADE,
+						PRIMARY KEY (channel_id, channel_owner, config_id, config_owner)
+					)`,
+				},
+				Down: []string{
+					"DROP TABLE connections",
+					"DROP TABLE configs",
+					"DROP TABLE channels",
+					"DROP TABLE unknown_configs",
+				},
+			},
+		},
+	}
+
+	_, err := migrate.Exec(db.DB, "postgres", migrations, migrate.Up)
+
+	return err
+}

bootstrap/postgres/setup_test.go

@@ -0,0 +1,85 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package postgres_test
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/mainflux/mainflux/bootstrap/postgres"
+	"github.com/mainflux/mainflux/logger"
+	dockertest "gopkg.in/ory-am/dockertest.v3"
+)
+
+const (
+	wrongID    = "0"
+	wrongValue = "wrong-value"
+)
+
+var (
+	testLog, _ = logger.New(os.Stdout, logger.Info.String())
+	db         *sqlx.DB
+)
+
+func TestMain(m *testing.M) {
+	pool, err := dockertest.NewPool("")
+	if err != nil {
+		log.Fatalf("Could not connect to docker: %s", err)
+	}
+
+	cfg := []string{
+		"POSTGRES_USER=test",
+		"POSTGRES_PASSWORD=test",
+		"POSTGRES_DB=test",
+	}
+	container, err := pool.Run("postgres", "10.2-alpine", cfg)
+	if err != nil {
+		log.Fatalf("Could not start container: %s", err)
+	}
+
+	port := container.GetPort("5432/tcp")
+
+	if err := pool.Retry(func() error {
+		url := fmt.Sprintf("host=localhost port=%s user=test dbname=test password=test sslmode=disable", port)
+		db, err = sqlx.Open("postgres", url)
+		if err != nil {
+			return err
+		}
+		return db.Ping()
+	}); err != nil {
+		log.Fatalf("Could not connect to docker: %s", err)
+	}
+
+	dbConfig := postgres.Config{
+		Host:        "localhost",
+		Port:        port,
+		User:        "test",
+		Pass:        "test",
+		Name:        "test",
+		SSLMode:     "disable",
+		SSLCert:     "",
+		SSLKey:      "",
+		SSLRootCert: "",
+	}
+
+	if db, err = postgres.Connect(dbConfig); err != nil {
+		log.Fatalf("Could not setup test DB connection: %s", err)
+	}
+	defer db.Close()
+
+	code := m.Run()
+
+	if err := pool.Purge(container); err != nil {
+		log.Fatalf("Could not purge container: %s", err)
+	}
+
+	os.Exit(code)
+}

bootstrap/reader.go

@@ -0,0 +1,72 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package bootstrap
+
+import (
+	"net/http"
+
+	"github.com/mainflux/mainflux"
+)
+
+// bootstrapRes represent Mainflux Response to the Bootatrap request.
+// This is used as a response from ConfigReader and can easily be
+// replace with any other response format.
+type bootstrapRes struct {
+	MFThing    string       `json:"mainflux_id"`
+	MFKey      string       `json:"mainflux_key"`
+	MFChannels []channelRes `json:"mainflux_channels"`
+	ClientCert string       `json:"client_cert,omitempty"`
+	ClientKey  string       `json:"client_key,omitempty"`
+	CaCert     string       `json:"ca_cert,omitempty"`
+	Content    string       `json:"content,omitempty"`
+}
+
+type channelRes struct {
+	ID       string      `json:"id"`
+	Name     string      `json:"name,omitempty"`
+	Metadata interface{} `json:"metadata,omitempty"`
+}
+
+func (res bootstrapRes) Code() int {
+	return http.StatusOK
+}
+
+func (res bootstrapRes) Headers() map[string]string {
+	return map[string]string{}
+}
+
+func (res bootstrapRes) Empty() bool {
+	return false
+}
+
+type reader struct{}
+
+// NewConfigReader return new reader which is used to generate response
+// from the config.
+func NewConfigReader() ConfigReader {
+	return reader{}
+}
+
+func (r reader) ReadConfig(cfg Config) (mainflux.Response, error) {
+	var channels []channelRes
+	for _, ch := range cfg.MFChannels {
+		channels = append(channels, channelRes{ID: ch.ID, Name: ch.Name, Metadata: ch.Metadata})
+	}
+
+	res := bootstrapRes{
+		MFKey:      cfg.MFKey,
+		MFThing:    cfg.MFThing,
+		MFChannels: channels,
+		ClientCert: cfg.ClientCert,
+		ClientKey:  cfg.ClientKey,
+		CaCert:     cfg.CACert,
+		Content:    cfg.Content,
+	}
+
+	return res, nil
+}

bootstrap/redis/consumer/doc.go

@@ -0,0 +1,10 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// Package consumer contains events consumer for events
+// published by Things service.
+package consumer

bootstrap/redis/consumer/events.go

@@ -0,0 +1,24 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package consumer
+
+type removeEvent struct {
+	id string
+}
+
+type updateChannelEvent struct {
+	id       string
+	name     string
+	metadata map[string]interface{}
+}
+
+// Connection event is either connect or disconnect event.
+type disconnectEvent struct {
+	thingID   string
+	channelID string
+}

bootstrap/redis/consumer/streams.go

@@ -0,0 +1,162 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package consumer
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/go-redis/redis"
+	"github.com/mainflux/mainflux/bootstrap"
+	"github.com/mainflux/mainflux/logger"
+)
+
+const (
+	stream = "mainflux.things"
+	group  = "mainflux.bootstrap"
+
+	thingPrefix     = "thing."
+	thingRemove     = thingPrefix + "remove"
+	thingDisconnect = thingPrefix + "disconnect"
+
+	channelPrefix = "channel."
+	channelUpdate = channelPrefix + "update"
+	channelRemove = channelPrefix + "remove"
+
+	exists = "BUSYGROUP Consumer Group name already exists"
+)
+
+// EventStore represents event source for things and channels provisioning.
+type EventStore interface {
+	// Subscribes to given subject and receives events.
+	Subscribe(string) error
+}
+
+type eventStore struct {
+	svc      bootstrap.Service
+	client   *redis.Client
+	consumer string
+	logger   logger.Logger
+}
+
+// NewEventStore returns new event store instance.
+func NewEventStore(svc bootstrap.Service, client *redis.Client, consumer string, log logger.Logger) EventStore {
+	return eventStore{
+		svc:      svc,
+		client:   client,
+		consumer: consumer,
+		logger:   log,
+	}
+}
+
+func (es eventStore) Subscribe(subject string) error {
+	err := es.client.XGroupCreateMkStream(stream, group, "$").Err()
+	if err != nil && err.Error() != exists {
+		return err
+	}
+
+	for {
+		streams, err := es.client.XReadGroup(&redis.XReadGroupArgs{
+			Group:    group,
+			Consumer: es.consumer,
+			Streams:  []string{stream, ">"},
+			Count:    100,
+		}).Result()
+		if err != nil || len(streams) == 0 {
+			continue
+		}
+
+		for _, msg := range streams[0].Messages {
+			event := msg.Values
+
+			var err error
+			switch event["operation"] {
+			case thingRemove:
+				rte := decodeRemoveThing(event)
+				err = es.handleRemoveThing(rte)
+			case thingDisconnect:
+				dte := decodeDisconnectThing(event)
+				err = es.handleDisconnectThing(dte)
+			case channelUpdate:
+				uce := decodeUpdateChannel(event)
+				err = es.handleUpdateChannel(uce)
+			case channelRemove:
+				rce := decodeRemoveChannel(event)
+				err = es.handleRemoveChannel(rce)
+			}
+			if err != nil {
+				es.logger.Warn(fmt.Sprintf("Failed to handle event sourcing: %s", err.Error()))
+				break
+			}
+			es.client.XAck(stream, group, msg.ID)
+		}
+	}
+}
+
+func decodeRemoveThing(event map[string]interface{}) removeEvent {
+	return removeEvent{
+		id: read(event, "id", ""),
+	}
+}
+
+func decodeUpdateChannel(event map[string]interface{}) updateChannelEvent {
+	strmeta := read(event, "metadata", "{}")
+	var metadata map[string]interface{}
+	if err := json.Unmarshal([]byte(strmeta), metadata); err != nil {
+		metadata = map[string]interface{}{}
+	}
+
+	return updateChannelEvent{
+		id:       read(event, "id", ""),
+		name:     read(event, "name", ""),
+		metadata: metadata,
+	}
+}
+
+func decodeRemoveChannel(event map[string]interface{}) removeEvent {
+	return removeEvent{
+		id: read(event, "id", ""),
+	}
+}
+
+func decodeDisconnectThing(event map[string]interface{}) disconnectEvent {
+	return disconnectEvent{
+		channelID: read(event, "chan_id", ""),
+		thingID:   read(event, "thing_id", ""),
+	}
+}
+
+func (es eventStore) handleRemoveThing(rte removeEvent) error {
+	return es.svc.RemoveConfigHandler(rte.id)
+}
+
+func (es eventStore) handleUpdateChannel(uce updateChannelEvent) error {
+	channel := bootstrap.Channel{
+		ID:       uce.id,
+		Name:     uce.name,
+		Metadata: uce.metadata,
+	}
+	return es.svc.UpdateChannelHandler(channel)
+}
+
+func (es eventStore) handleRemoveChannel(rce removeEvent) error {
+	return es.svc.RemoveChannelHandler(rce.id)
+}
+
+func (es eventStore) handleDisconnectThing(dte disconnectEvent) error {
+	return es.svc.DisconnectThingHandler(dte.channelID, dte.thingID)
+}
+
+func read(event map[string]interface{}, key, def string) string {
+	val, ok := event[key].(string)
+	if !ok {
+		return def
+	}
+
+	return val
+}

bootstrap/redis/producer/doc.go

@@ -0,0 +1,10 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// Package producer contains the domain events needed to support
+// event sourcing of Bootstrap service actions.
+package producer

bootstrap/redis/producer/events.go

@@ -0,0 +1,138 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package producer
+
+import (
+	"strings"
+	"time"
+
+	"github.com/mainflux/mainflux/bootstrap"
+)
+
+const (
+	configPrefix = "config."
+	configCreate = configPrefix + "create"
+	configUpdate = configPrefix + "update"
+	configRemove = configPrefix + "remove"
+
+	thingPrefix            = "thing."
+	thingBootstrap         = thingPrefix + "bootstrap"
+	thingStateChange       = thingPrefix + "state_change"
+	thingUpdateConnections = thingPrefix + "update_connections"
+)
+
+type event interface {
+	encode() map[string]interface{}
+}
+
+var (
+	_ event = (*createConfigEvent)(nil)
+	_ event = (*updateConfigEvent)(nil)
+	_ event = (*removeConfigEvent)(nil)
+	_ event = (*bootstrapEvent)(nil)
+	_ event = (*changeStateEvent)(nil)
+	_ event = (*updateConnectionsEvent)(nil)
+)
+
+type createConfigEvent struct {
+	mfThing    string
+	owner      string
+	name       string
+	mfChannels []string
+	externalID string
+	content    string
+	timestamp  time.Time
+}
+
+func (cce createConfigEvent) encode() map[string]interface{} {
+	return map[string]interface{}{
+		"thing_id":    cce.mfThing,
+		"owner":       cce.owner,
+		"name":        cce.name,
+		"channels":    strings.Join(cce.mfChannels, ", "),
+		"external_id": cce.externalID,
+		"content":     cce.content,
+		"timestamp":   cce.timestamp.Unix(),
+		"operation":   configCreate,
+	}
+}
+
+type updateConfigEvent struct {
+	mfThing   string
+	name      string
+	content   string
+	timestamp time.Time
+}
+
+func (uce updateConfigEvent) encode() map[string]interface{} {
+	return map[string]interface{}{
+		"thing_id":  uce.mfThing,
+		"name":      uce.name,
+		"content":   uce.content,
+		"timestamp": uce.timestamp.Unix(),
+		"operation": configUpdate,
+	}
+}
+
+type removeConfigEvent struct {
+	mfThing   string
+	timestamp time.Time
+}
+
+func (rce removeConfigEvent) encode() map[string]interface{} {
+	return map[string]interface{}{
+		"thing_id":  rce.mfThing,
+		"timestamp": rce.timestamp.Unix(),
+		"operation": configRemove,
+	}
+}
+
+type bootstrapEvent struct {
+	externalID string
+	success    bool
+	timestamp  time.Time
+}
+
+func (be bootstrapEvent) encode() map[string]interface{} {
+	return map[string]interface{}{
+		"external_id": be.externalID,
+		"success":     be.success,
+		"timestamp":   be.timestamp.Unix(),
+		"operation":   thingBootstrap,
+	}
+}
+
+type changeStateEvent struct {
+	mfThing   string
+	state     bootstrap.State
+	timestamp time.Time
+}
+
+func (cse changeStateEvent) encode() map[string]interface{} {
+	return map[string]interface{}{
+		"thing_id":  cse.mfThing,
+		"state":     cse.state.String(),
+		"timestamp": cse.timestamp.Unix(),
+		"operation": thingStateChange,
+	}
+}
+
+type updateConnectionsEvent struct {
+	mfThing    string
+	mfChannels []string
+	timestamp  time.Time
+}
+
+func (uce updateConnectionsEvent) encode() map[string]interface{} {
+	return map[string]interface{}{
+		"thing_id":  uce.mfThing,
+		"channels":  strings.Join(uce.mfChannels, ", "),
+		"timestamp": uce.timestamp.Unix(),
+		"operation": thingUpdateConnections,
+	}
+}

bootstrap/redis/producer/setup_test.go

@@ -0,0 +1,57 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package producer_test
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/go-redis/redis"
+	dockertest "gopkg.in/ory-am/dockertest.v3"
+)
+
+const (
+	wrongID    = 0
+	wrongValue = "wrong-value"
+)
+
+var redisClient *redis.Client
+
+func TestMain(m *testing.M) {
+	pool, err := dockertest.NewPool("")
+	if err != nil {
+		log.Fatalf("Could not connect to docker: %s", err)
+	}
+
+	container, err := pool.Run("redis", "5.0-alpine", nil)
+	if err != nil {
+		log.Fatalf("Could not start container: %s", err)
+	}
+
+	if err := pool.Retry(func() error {
+		redisClient = redis.NewClient(&redis.Options{
+			Addr:     fmt.Sprintf("localhost:%s", container.GetPort("6379/tcp")),
+			Password: "",
+			DB:       0,
+		})
+
+		return redisClient.Ping().Err()
+	}); err != nil {
+		log.Fatalf("Could not connect to docker: %s", err)
+	}
+
+	code := m.Run()
+
+	if err := pool.Purge(container); err != nil {
+		log.Fatalf("Could not purge container: %s", err)
+	}
+
+	os.Exit(code)
+}

bootstrap/redis/producer/streams.go

@@ -0,0 +1,182 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package producer
+
+import (
+	"time"
+
+	"github.com/go-redis/redis"
+	"github.com/mainflux/mainflux/bootstrap"
+)
+
+const (
+	streamID  = "mainflux.bootstrap"
+	streamLen = 1000
+)
+
+var _ bootstrap.Service = (*eventStore)(nil)
+
+type eventStore struct {
+	svc    bootstrap.Service
+	client *redis.Client
+}
+
+// NewEventStoreMiddleware returns wrapper around bootstrap service that sends
+// events to event store.
+func NewEventStoreMiddleware(svc bootstrap.Service, client *redis.Client) bootstrap.Service {
+	return eventStore{
+		svc:    svc,
+		client: client,
+	}
+}
+
+func (es eventStore) Add(key string, cfg bootstrap.Config) (bootstrap.Config, error) {
+	saved, err := es.svc.Add(key, cfg)
+	if err != nil {
+		return saved, err
+	}
+
+	var channels []string
+	for _, ch := range saved.MFChannels {
+		channels = append(channels, ch.ID)
+	}
+
+	ev := createConfigEvent{
+		mfThing:    saved.MFThing,
+		owner:      saved.Owner,
+		name:       saved.Name,
+		mfChannels: channels,
+		externalID: saved.ExternalID,
+		content:    saved.Content,
+		timestamp:  time.Now(),
+	}
+
+	es.add(ev)
+
+	return saved, err
+}
+
+func (es eventStore) View(key, id string) (bootstrap.Config, error) {
+	return es.svc.View(key, id)
+}
+
+func (es eventStore) Update(key string, cfg bootstrap.Config) error {
+	if err := es.svc.Update(key, cfg); err != nil {
+		return err
+	}
+
+	ev := updateConfigEvent{
+		mfThing:   cfg.MFThing,
+		name:      cfg.Name,
+		content:   cfg.Content,
+		timestamp: time.Now(),
+	}
+
+	es.add(ev)
+
+	return nil
+}
+
+func (es eventStore) UpdateCert(key, thingKey, clientCert, clientKey, caCert string) error {
+	return es.svc.UpdateCert(key, thingKey, clientCert, clientKey, caCert)
+}
+
+func (es eventStore) UpdateConnections(key, id string, connections []string) error {
+	if err := es.svc.UpdateConnections(key, id, connections); err != nil {
+		return err
+	}
+
+	ev := updateConnectionsEvent{
+		mfThing:    id,
+		mfChannels: connections,
+		timestamp:  time.Now(),
+	}
+
+	es.add(ev)
+
+	return nil
+}
+
+func (es eventStore) List(key string, filter bootstrap.Filter, offset, limit uint64) (bootstrap.ConfigsPage, error) {
+	return es.svc.List(key, filter, offset, limit)
+}
+
+func (es eventStore) Remove(key, id string) error {
+	if err := es.svc.Remove(key, id); err != nil {
+		return err
+	}
+
+	ev := removeConfigEvent{
+		mfThing:   id,
+		timestamp: time.Now(),
+	}
+
+	es.add(ev)
+
+	return nil
+}
+
+func (es eventStore) Bootstrap(externalKey, externalID string) (bootstrap.Config, error) {
+	cfg, err := es.svc.Bootstrap(externalKey, externalID)
+
+	ev := bootstrapEvent{
+		externalID: externalID,
+		timestamp:  time.Now(),
+		success:    true,
+	}
+
+	if err != nil {
+		ev.success = false
+	}
+
+	es.add(ev)
+
+	return cfg, err
+}
+
+func (es eventStore) ChangeState(key, id string, state bootstrap.State) error {
+	if err := es.svc.ChangeState(key, id, state); err != nil {
+		return err
+	}
+
+	ev := changeStateEvent{
+		mfThing:   id,
+		state:     state,
+		timestamp: time.Now(),
+	}
+
+	es.add(ev)
+
+	return nil
+}
+
+func (es eventStore) RemoveConfigHandler(id string) error {
+	return es.svc.RemoveConfigHandler(id)
+}
+
+func (es eventStore) RemoveChannelHandler(id string) error {
+	return es.svc.RemoveChannelHandler(id)
+}
+
+func (es eventStore) UpdateChannelHandler(channel bootstrap.Channel) error {
+	return es.UpdateChannelHandler(channel)
+}
+
+func (es eventStore) DisconnectThingHandler(channelID, thingID string) error {
+	return es.svc.DisconnectThingHandler(channelID, thingID)
+}
+
+func (es eventStore) add(ev event) error {
+	record := &redis.XAddArgs{
+		Stream:       streamID,
+		MaxLenApprox: streamLen,
+		Values:       ev.encode(),
+	}
+
+	return es.client.XAdd(record).Err()
+}

bootstrap/redis/producer/streams_test.go

@@ -0,0 +1,550 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package producer_test
+
+import (
+	"fmt"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis"
+	"github.com/mainflux/mainflux"
+	"github.com/opentracing/opentracing-go/mocktracer"
+
+	"github.com/mainflux/mainflux/bootstrap"
+	"github.com/mainflux/mainflux/bootstrap/mocks"
+	"github.com/mainflux/mainflux/bootstrap/redis/producer"
+	mfsdk "github.com/mainflux/mainflux/sdk/go"
+	"github.com/mainflux/mainflux/things"
+	httpapi "github.com/mainflux/mainflux/things/api/things/http"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	streamID      = "mainflux.bootstrap"
+	email         = "user@example.com"
+	validToken    = "validToken"
+	unknownID     = "1"
+	unknownKey    = "2"
+	channelsNum   = 3
+	defaultTimout = 5
+
+	configPrefix = "config."
+	configCreate = configPrefix + "create"
+	configUpdate = configPrefix + "update"
+	configRemove = configPrefix + "remove"
+
+	thingPrefix            = "thing."
+	thingStateChange       = thingPrefix + "state_change"
+	thingBootstrap         = thingPrefix + "bootstrap"
+	thingUpdateConnections = thingPrefix + "update_connections"
+)
+
+var (
+	channel = bootstrap.Channel{
+		ID:       "1",
+		Name:     "name",
+		Metadata: map[string]interface{}{"name": "value"},
+	}
+
+	config = bootstrap.Config{
+		ExternalID:  "external_id",
+		ExternalKey: "external_key",
+		MFChannels:  []bootstrap.Channel{channel},
+		Content:     "config",
+	}
+)
+
+func newService(users mainflux.UsersServiceClient, url string) bootstrap.Service {
+	configs := mocks.NewConfigsRepository(map[string]string{unknownID: unknownKey})
+	config := mfsdk.Config{
+		BaseURL: url,
+	}
+
+	sdk := mfsdk.NewSDK(config)
+	return bootstrap.New(users, configs, sdk)
+}
+
+func newThingsService(users mainflux.UsersServiceClient) things.Service {
+	channels := make(map[string]things.Channel, channelsNum)
+	for i := 0; i < channelsNum; i++ {
+		id := strconv.Itoa(i + 1)
+		channels[id] = things.Channel{
+			ID:       id,
+			Owner:    email,
+			Metadata: map[string]interface{}{"meta": "data"},
+		}
+	}
+
+	return mocks.NewThingsService(map[string]things.Thing{}, channels, users)
+}
+
+func newThingsServer(svc things.Service) *httptest.Server {
+	mux := httpapi.MakeHandler(mocktracer.New(), svc)
+	return httptest.NewServer(mux)
+}
+func TestAdd(t *testing.T) {
+	redisClient.FlushAll().Err()
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+
+	var channels []string
+	for _, ch := range config.MFChannels {
+		channels = append(channels, ch.ID)
+	}
+
+	invalidConfig := config
+	invalidConfig.MFChannels = []bootstrap.Channel{bootstrap.Channel{ID: "empty"}}
+
+	cases := []struct {
+		desc   string
+		config bootstrap.Config
+		key    string
+		err    error
+		event  map[string]interface{}
+	}{
+		{
+			desc:   "create config successfully",
+			config: config,
+			key:    validToken,
+			err:    nil,
+			event: map[string]interface{}{
+				"thing_id":    "1",
+				"owner":       email,
+				"name":        config.Name,
+				"channels":    strings.Join(channels, ", "),
+				"external_id": config.ExternalID,
+				"content":     config.Content,
+				"timestamp":   time.Now().Unix(),
+				"operation":   configCreate,
+			},
+		},
+		{
+			desc:   "create invalid config",
+			config: invalidConfig,
+			key:    validToken,
+			err:    bootstrap.ErrMalformedEntity,
+			event:  nil,
+		},
+	}
+
+	lastID := "0"
+	for _, tc := range cases {
+		_, err := svc.Add(tc.key, tc.config)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+
+		streams := redisClient.XRead(&redis.XReadArgs{
+			Streams: []string{streamID, lastID},
+			Count:   1,
+			Block:   time.Second,
+		}).Val()
+
+		var event map[string]interface{}
+		if len(streams) > 0 && len(streams[0].Messages) > 0 {
+			msg := streams[0].Messages[0]
+			event = msg.Values
+			lastID = msg.ID
+		}
+
+		test(t, tc.event, event, tc.desc)
+	}
+}
+
+func TestView(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	svcConfig, svcErr := svc.View(validToken, saved.MFThing)
+
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+	esConfig, esErr := svc.View(validToken, saved.MFThing)
+
+	assert.Equal(t, svcConfig, esConfig, fmt.Sprintf("event sourcing changed service behavior: expected %v got %v", svcConfig, esConfig))
+	assert.Equal(t, svcErr, esErr, fmt.Sprintf("event sourcing changed service behavior: expected %v got %v", svcErr, esErr))
+}
+
+func TestUpdate(t *testing.T) {
+	redisClient.FlushAll().Err()
+
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+
+	c := config
+
+	ch := channel
+	ch.ID = "2"
+	c.MFChannels = append(c.MFChannels, ch)
+	saved, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	redisClient.FlushAll().Err()
+
+	modified := saved
+	modified.Content = "new-config"
+	modified.Name = "new name"
+
+	nonExisting := config
+	nonExisting.MFThing = "unknown"
+
+	cases := []struct {
+		desc   string
+		config bootstrap.Config
+		key    string
+		err    error
+		event  map[string]interface{}
+	}{
+		{
+			desc:   "update config successfully",
+			config: modified,
+			key:    validToken,
+			err:    nil,
+			event: map[string]interface{}{
+				"thing_id":  modified.MFThing,
+				"name":      modified.Name,
+				"content":   modified.Content,
+				"timestamp": time.Now().Unix(),
+				"operation": configUpdate,
+			},
+		},
+		{
+			desc:   "update non-existing config",
+			config: nonExisting,
+			key:    validToken,
+			err:    bootstrap.ErrNotFound,
+			event:  nil,
+		},
+	}
+
+	lastID := "0"
+	for _, tc := range cases {
+		err := svc.Update(tc.key, tc.config)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+
+		streams := redisClient.XRead(&redis.XReadArgs{
+			Streams: []string{streamID, lastID},
+			Count:   1,
+			Block:   time.Second,
+		}).Val()
+
+		var event map[string]interface{}
+		if len(streams) > 0 && len(streams[0].Messages) > 0 {
+			msg := streams[0].Messages[0]
+			event = msg.Values
+			lastID = msg.ID
+		}
+
+		test(t, tc.event, event, tc.desc)
+	}
+}
+
+func TestUpdateConnections(t *testing.T) {
+	redisClient.FlushAll().Err()
+
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	redisClient.FlushAll().Err()
+
+	cases := []struct {
+		desc        string
+		id          string
+		key         string
+		connections []string
+		err         error
+		event       map[string]interface{}
+	}{
+		{
+			desc:        "update connections successfully",
+			id:          saved.MFThing,
+			key:         validToken,
+			connections: []string{"2"},
+			err:         nil,
+			event: map[string]interface{}{
+				"thing_id":  saved.MFThing,
+				"channels":  "2",
+				"timestamp": time.Now().Unix(),
+				"operation": thingUpdateConnections,
+			},
+		},
+		{
+			desc:        "update connections unsuccessfully",
+			id:          saved.MFThing,
+			key:         validToken,
+			connections: []string{"256"},
+			err:         bootstrap.ErrMalformedEntity,
+			event:       nil,
+		},
+	}
+
+	lastID := "0"
+	for _, tc := range cases {
+		err := svc.UpdateConnections(tc.key, tc.id, tc.connections)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+
+		streams := redisClient.XRead(&redis.XReadArgs{
+			Streams: []string{streamID, lastID},
+			Count:   1,
+			Block:   time.Second,
+		}).Val()
+
+		var event map[string]interface{}
+		if len(streams) > 0 && len(streams[0].Messages) > 0 {
+			msg := streams[0].Messages[0]
+			event = msg.Values
+			lastID = msg.ID
+		}
+
+		test(t, tc.event, event, tc.desc)
+	}
+}
+func TestList(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	_, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	offset := uint64(0)
+	limit := uint64(10)
+	svcConfigs, svcErr := svc.List(validToken, bootstrap.Filter{}, offset, limit)
+
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+	esConfigs, esErr := svc.List(validToken, bootstrap.Filter{}, offset, limit)
+
+	assert.Equal(t, svcConfigs, esConfigs, fmt.Sprintf("event sourcing changed service behavior: expected %v got %v", svcConfigs, esConfigs))
+	assert.Equal(t, svcErr, esErr, fmt.Sprintf("event sourcing changed service behavior: expected %v got %v", svcErr, esErr))
+}
+
+func TestRemove(t *testing.T) {
+	redisClient.FlushAll().Err()
+
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+
+	c := config
+
+	saved, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	redisClient.FlushAll().Err()
+
+	cases := []struct {
+		desc  string
+		id    string
+		key   string
+		err   error
+		event map[string]interface{}
+	}{
+		{
+			desc: "remove config successfully",
+			id:   saved.MFThing,
+			key:  validToken,
+			err:  nil,
+			event: map[string]interface{}{
+				"thing_id":  saved.MFThing,
+				"timestamp": time.Now().Unix(),
+				"operation": configRemove,
+			},
+		},
+		{
+			desc:  "remove config with invalid credentials",
+			id:    saved.MFThing,
+			key:   "",
+			err:   bootstrap.ErrUnauthorizedAccess,
+			event: nil,
+		},
+	}
+
+	lastID := "0"
+	for _, tc := range cases {
+		err := svc.Remove(tc.key, tc.id)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+
+		streams := redisClient.XRead(&redis.XReadArgs{
+			Streams: []string{streamID, lastID},
+			Count:   1,
+			Block:   time.Second,
+		}).Val()
+
+		var event map[string]interface{}
+		if len(streams) > 0 && len(streams[0].Messages) > 0 {
+			msg := streams[0].Messages[0]
+			event = msg.Values
+			lastID = msg.ID
+		}
+
+		test(t, tc.event, event, tc.desc)
+	}
+}
+
+func TestBootstrap(t *testing.T) {
+	redisClient.FlushAll().Err()
+
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+
+	c := config
+
+	saved, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	redisClient.FlushAll().Err()
+
+	cases := []struct {
+		desc        string
+		externalID  string
+		externalKey string
+		err         error
+		event       map[string]interface{}
+	}{
+		{
+			desc:        "bootstrap successfully",
+			externalID:  saved.ExternalID,
+			externalKey: saved.ExternalKey,
+			err:         nil,
+			event: map[string]interface{}{
+				"external_id": saved.ExternalID,
+				"success":     "1",
+				"timestamp":   time.Now().Unix(),
+				"operation":   thingBootstrap,
+			},
+		},
+		{
+			desc:        "bootstrap with an error",
+			externalID:  saved.ExternalID,
+			externalKey: "external",
+			err:         bootstrap.ErrNotFound,
+			event: map[string]interface{}{
+				"external_id": saved.ExternalID,
+				"success":     "0",
+				"timestamp":   time.Now().Unix(),
+				"operation":   thingBootstrap,
+			},
+		},
+	}
+
+	lastID := "0"
+	for _, tc := range cases {
+		_, err := svc.Bootstrap(tc.externalKey, tc.externalID)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+
+		streams := redisClient.XRead(&redis.XReadArgs{
+			Streams: []string{streamID, lastID},
+			Count:   1,
+			Block:   time.Second,
+		}).Val()
+
+		var event map[string]interface{}
+		if len(streams) > 0 && len(streams[0].Messages) > 0 {
+			msg := streams[0].Messages[0]
+			event = msg.Values
+			lastID = msg.ID
+		}
+
+		test(t, tc.event, event, tc.desc)
+	}
+}
+
+func TestChangeState(t *testing.T) {
+	redisClient.FlushAll().Err()
+
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	svc = producer.NewEventStoreMiddleware(svc, redisClient)
+
+	c := config
+
+	saved, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	redisClient.FlushAll().Err()
+
+	cases := []struct {
+		desc  string
+		id    string
+		key   string
+		state bootstrap.State
+		err   error
+		event map[string]interface{}
+	}{
+		{
+			desc:  "change state to active",
+			id:    saved.MFThing,
+			key:   validToken,
+			state: bootstrap.Active,
+			err:   nil,
+			event: map[string]interface{}{
+				"thing_id":  saved.MFThing,
+				"state":     bootstrap.Active.String(),
+				"timestamp": time.Now().Unix(),
+				"operation": thingStateChange,
+			},
+		},
+		{
+			desc:  "change state invalid credentials",
+			id:    saved.MFThing,
+			key:   "",
+			state: bootstrap.Inactive,
+			err:   bootstrap.ErrUnauthorizedAccess,
+			event: nil,
+		},
+	}
+
+	lastID := "0"
+	for _, tc := range cases {
+		err := svc.ChangeState(tc.key, tc.id, tc.state)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+
+		streams := redisClient.XRead(&redis.XReadArgs{
+			Streams: []string{streamID, lastID},
+			Count:   1,
+			Block:   time.Second,
+		}).Val()
+
+		var event map[string]interface{}
+		if len(streams) > 0 && len(streams[0].Messages) > 0 {
+			msg := streams[0].Messages[0]
+			event = msg.Values
+			lastID = msg.ID
+		}
+
+		test(t, tc.event, event, tc.desc)
+	}
+}
+
+func test(t *testing.T, expected, actual map[string]interface{}, description string) {
+	if expected != nil && actual != nil {
+		ts1 := expected["timestamp"].(int64)
+		ts2, err := strconv.ParseInt(actual["timestamp"].(string), 10, 64)
+		require.Nil(t, err, fmt.Sprintf("%s: expected to get a valid timestamp, got %s", description, err))
+		val := ts1 == ts2 || ts2 <= ts1+defaultTimout
+		assert.True(t, val, fmt.Sprintf("%s: timestamp is not in valid range", description))
+		delete(expected, "timestamp")
+		delete(actual, "timestamp")
+		assert.Equal(t, expected, actual, fmt.Sprintf("%s: expected %v got %v\n", description, expected, actual))
+	}
+}

bootstrap/service.go

@@ -0,0 +1,428 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package bootstrap
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/mainflux/mainflux"
+	mfsdk "github.com/mainflux/mainflux/sdk/go"
+)
+
+var (
+	// ErrNotFound indicates a non-existent entity request.
+	ErrNotFound = errors.New("non-existent entity")
+
+	// ErrMalformedEntity indicates malformed entity specification.
+	ErrMalformedEntity = errors.New("malformed entity specification")
+
+	// ErrUnauthorizedAccess indicates missing or invalid credentials provided
+	// when accessing a protected resource.
+	ErrUnauthorizedAccess = errors.New("missing or invalid credentials provided")
+
+	// ErrConflict indicates that entity with the same ID or external ID already exists.
+	ErrConflict = errors.New("entity already exists")
+
+	// ErrThings indicates failure to communicate with Mainflux Things service.
+	// It can be due to networking error or invalid/unauthorized request.
+	ErrThings = errors.New("error receiving response from Things service")
+)
+
+var _ Service = (*bootstrapService)(nil)
+
+// Service specifies an API that must be fulfilled by the domain service
+// implementation, and all of its decorators (e.g. logging & metrics).
+type Service interface {
+	// Add adds new Thing Config to the user identified by the provided key.
+	Add(string, Config) (Config, error)
+
+	// View returns Thing Config with given ID belonging to the user identified by the given key.
+	View(string, string) (Config, error)
+
+	// Update updates editable fields of the provided Config.
+	Update(string, Config) error
+
+	// UpdateCert updates an existing Config certificate and key.
+	// A non-nil error is returned to indicate operation failure.
+	UpdateCert(string, string, string, string, string) error
+
+	// UpdateConnections updates list of Channels related to given Config.
+	UpdateConnections(string, string, []string) error
+
+	// List returns subset of Configs with given search params that belong to the
+	// user identified by the given key.
+	List(string, Filter, uint64, uint64) (ConfigsPage, error)
+
+	// Remove removes Config with specified key that belongs to the user identified by the given key.
+	Remove(string, string) error
+
+	// Bootstrap returns Config to the Thing with provided external ID using external key.
+	Bootstrap(string, string) (Config, error)
+
+	// ChangeState changes state of the Thing with given ID and owner.
+	ChangeState(string, string, State) error
+
+	// Methods RemoveConfig, UpdateChannel, and RemoveChannel are used as
+	// handlers for events. That's why these methods surpass ownership check.
+
+	// RemoveConfigHandler removes Configuration with id received from an event.
+	RemoveConfigHandler(string) error
+
+	// UpdateChannelHandler updates Channel with data received from an event.
+	UpdateChannelHandler(Channel) error
+
+	// RemoveChannelHandler removes Channel with id received from an event.
+	RemoveChannelHandler(string) error
+
+	// DisconnectHandler changes state of the Config when connect/disconnect event occurs.
+	DisconnectThingHandler(string, string) error
+}
+
+// ConfigReader is used to parse Config into format which will be encoded
+// as a JSON and consumed from the client side. The purpose of this interface
+// is to provide convenient way to generate custom configuration response
+// based on the specific Config which will be consumed by the client.
+type ConfigReader interface {
+	ReadConfig(Config) (mainflux.Response, error)
+}
+
+type bootstrapService struct {
+	users   mainflux.UsersServiceClient
+	configs ConfigRepository
+	sdk     mfsdk.SDK
+}
+
+// New returns new Bootstrap service.
+func New(users mainflux.UsersServiceClient, configs ConfigRepository, sdk mfsdk.SDK) Service {
+	return &bootstrapService{
+		configs: configs,
+		sdk:     sdk,
+		users:   users,
+	}
+}
+
+func (bs bootstrapService) Add(key string, cfg Config) (Config, error) {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return Config{}, err
+	}
+
+	toConnect := bs.toIDList(cfg.MFChannels)
+
+	// Check if channels exist. This is the way to prevent fetching channels that already exist.
+	existing, err := bs.configs.ListExisting(owner, toConnect)
+	if err != nil {
+		return Config{}, err
+	}
+
+	cfg.MFChannels, err = bs.connectionChannels(toConnect, bs.toIDList(existing), key)
+
+	if err != nil {
+		return Config{}, err
+	}
+
+	id := cfg.MFThing
+	mfThing, err := bs.thing(key, id)
+	if err != nil {
+		return Config{}, err
+	}
+
+	cfg.MFThing = mfThing.ID
+	cfg.Owner = owner
+	cfg.State = Inactive
+	cfg.MFKey = mfThing.Key
+	saved, err := bs.configs.Save(cfg, toConnect)
+
+	if err != nil {
+		if id == "" {
+			// Fail silently.
+			bs.sdk.DeleteThing(cfg.MFThing, key)
+		}
+		return Config{}, err
+	}
+
+	cfg.MFThing = saved
+	cfg.MFChannels = append(cfg.MFChannels, existing...)
+
+	return cfg, nil
+}
+
+func (bs bootstrapService) View(key, id string) (Config, error) {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return Config{}, err
+	}
+
+	return bs.configs.RetrieveByID(owner, id)
+}
+
+func (bs bootstrapService) Update(key string, cfg Config) error {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return err
+	}
+
+	cfg.Owner = owner
+
+	return bs.configs.Update(cfg)
+}
+
+func (bs bootstrapService) UpdateCert(key, thingKey, clientCert, clientKey, caCert string) error {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return err
+	}
+	return bs.configs.UpdateCert(owner, thingKey, clientCert, clientKey, caCert)
+}
+
+func (bs bootstrapService) UpdateConnections(key, id string, connections []string) error {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return err
+	}
+
+	cfg, err := bs.configs.RetrieveByID(owner, id)
+	if err != nil {
+		return err
+	}
+
+	add, remove := bs.updateList(cfg, connections)
+
+	// Check if channels exist. This is the way to prevent fetching channels that already exist.
+	existing, err := bs.configs.ListExisting(owner, connections)
+	if err != nil {
+		return err
+	}
+
+	channels, err := bs.connectionChannels(connections, bs.toIDList(existing), key)
+	if err != nil {
+		return err
+	}
+
+	cfg.MFChannels = channels
+	var connect, disconnect []string
+
+	if cfg.State == Active {
+		connect = add
+		disconnect = remove
+	}
+
+	for _, c := range disconnect {
+		if err := bs.sdk.DisconnectThing(id, c, key); err != nil {
+			if err == mfsdk.ErrNotFound {
+				continue
+			}
+			return ErrThings
+		}
+	}
+
+	for _, c := range connect {
+		if err := bs.sdk.ConnectThing(id, c, key); err != nil {
+			if err == mfsdk.ErrNotFound {
+				return ErrMalformedEntity
+			}
+			return ErrThings
+		}
+	}
+
+	return bs.configs.UpdateConnections(owner, id, channels, connections)
+}
+
+func (bs bootstrapService) List(key string, filter Filter, offset, limit uint64) (ConfigsPage, error) {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return ConfigsPage{}, err
+	}
+
+	if filter.Unknown {
+		return bs.configs.RetrieveUnknown(offset, limit), nil
+	}
+
+	return bs.configs.RetrieveAll(owner, filter, offset, limit), nil
+}
+
+func (bs bootstrapService) Remove(key, id string) error {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return err
+	}
+
+	return bs.configs.Remove(owner, id)
+}
+
+func (bs bootstrapService) Bootstrap(externalKey, externalID string) (Config, error) {
+	cfg, err := bs.configs.RetrieveByExternalID(externalKey, externalID)
+	if err != nil {
+		if err == ErrNotFound {
+			bs.configs.SaveUnknown(externalKey, externalID)
+		}
+		return Config{}, ErrNotFound
+	}
+
+	return cfg, nil
+}
+
+func (bs bootstrapService) ChangeState(key, id string, state State) error {
+	owner, err := bs.identify(key)
+	if err != nil {
+		return err
+	}
+
+	cfg, err := bs.configs.RetrieveByID(owner, id)
+	if err != nil {
+		return err
+	}
+
+	if cfg.State == state {
+		return nil
+	}
+
+	switch state {
+	case Active:
+		for _, c := range cfg.MFChannels {
+			if err := bs.sdk.ConnectThing(cfg.MFThing, c.ID, key); err != nil {
+				return ErrThings
+			}
+		}
+	case Inactive:
+		for _, c := range cfg.MFChannels {
+			if err := bs.sdk.DisconnectThing(cfg.MFThing, c.ID, key); err != nil {
+				if err == mfsdk.ErrNotFound {
+					continue
+				}
+				return ErrThings
+			}
+		}
+	}
+
+	return bs.configs.ChangeState(owner, id, state)
+}
+
+func (bs bootstrapService) UpdateChannelHandler(channel Channel) error {
+	return bs.configs.UpdateChannel(channel)
+}
+
+func (bs bootstrapService) RemoveConfigHandler(id string) error {
+	return bs.configs.RemoveThing(id)
+}
+
+func (bs bootstrapService) RemoveChannelHandler(id string) error {
+	return bs.configs.RemoveChannel(id)
+}
+
+func (bs bootstrapService) DisconnectThingHandler(channelID, thingID string) error {
+	return bs.configs.DisconnectThing(channelID, thingID)
+}
+
+func (bs bootstrapService) identify(token string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+
+	res, err := bs.users.Identify(ctx, &mainflux.Token{Value: token})
+	if err != nil {
+		return "", ErrUnauthorizedAccess
+	}
+
+	return res.GetValue(), nil
+}
+
+// Method thing retrieves Mainflux Thing creating one if an empty ID is passed.
+func (bs bootstrapService) thing(key, id string) (mfsdk.Thing, error) {
+	thingID := id
+	var err error
+
+	if id == "" {
+		thingID, err = bs.sdk.CreateThing(mfsdk.Thing{}, key)
+		if err != nil {
+			return mfsdk.Thing{}, err
+		}
+	}
+
+	thing, err := bs.sdk.Thing(thingID, key)
+	if err != nil {
+		if err == mfsdk.ErrNotFound {
+			return mfsdk.Thing{}, ErrNotFound
+		}
+
+		if id != "" {
+			bs.sdk.DeleteThing(thingID, key)
+		}
+
+		return mfsdk.Thing{}, ErrThings
+	}
+
+	return thing, nil
+}
+
+func (bs bootstrapService) connectionChannels(channels, existing []string, key string) ([]Channel, error) {
+	add := make(map[string]bool, len(channels))
+	for _, ch := range channels {
+		add[ch] = true
+	}
+
+	for _, ch := range existing {
+		if add[ch] == true {
+			delete(add, ch)
+		}
+	}
+
+	var ret []Channel
+	for id := range add {
+		ch, err := bs.sdk.Channel(id, key)
+		if err != nil {
+			return nil, ErrMalformedEntity
+		}
+
+		ret = append(ret, Channel{
+			ID:       ch.ID,
+			Name:     ch.Name,
+			Metadata: ch.Metadata,
+		})
+	}
+
+	return ret, nil
+}
+
+// Method updateList accepts config and channel IDs and returns three lists:
+// 1) IDs of Channels to be added
+// 2) IDs of Channels to be removed
+// 3) IDs of common Channels for these two configs
+func (bs bootstrapService) updateList(cfg Config, connections []string) (add, remove []string) {
+	var disconnect map[string]bool
+	disconnect = make(map[string]bool, len(cfg.MFChannels))
+	for _, c := range cfg.MFChannels {
+		disconnect[c.ID] = true
+	}
+
+	for _, c := range connections {
+		if disconnect[c] {
+			// Don't disconnect common elements.
+			delete(disconnect, c)
+			continue
+		}
+		// Connect new elements.
+		add = append(add, c)
+	}
+
+	for v := range disconnect {
+		remove = append(remove, v)
+	}
+
+	return
+}
+
+func (bs bootstrapService) toIDList(channels []Channel) []string {
+	var ret []string
+	for _, ch := range channels {
+		ret = append(ret, ch.ID)
+	}
+
+	return ret
+}

bootstrap/service_test.go

@@ -0,0 +1,773 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package bootstrap_test
+
+import (
+	"fmt"
+	"net/http/httptest"
+	"strconv"
+	"testing"
+
+	"github.com/opentracing/opentracing-go/mocktracer"
+
+	"github.com/gofrs/uuid"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/bootstrap"
+	"github.com/mainflux/mainflux/bootstrap/mocks"
+	mfsdk "github.com/mainflux/mainflux/sdk/go"
+	"github.com/mainflux/mainflux/things"
+	httpapi "github.com/mainflux/mainflux/things/api/things/http"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	validToken   = "validToken"
+	invalidToken = "invalidToken"
+	email        = "test@example.com"
+	unknown      = "unknown"
+	unknownID    = "1"
+	unknownKey   = "2"
+	channelsNum  = 3
+)
+
+var (
+	channel = bootstrap.Channel{
+		ID:       "1",
+		Name:     "name",
+		Metadata: map[string]interface{}{"name": "value"},
+	}
+
+	config = bootstrap.Config{
+		ExternalID:  "external_id",
+		ExternalKey: "external_key",
+		MFChannels:  []bootstrap.Channel{channel},
+		Content:     "config",
+	}
+)
+
+func newService(users mainflux.UsersServiceClient, url string) bootstrap.Service {
+	things := mocks.NewConfigsRepository(map[string]string{unknownID: unknownKey})
+	config := mfsdk.Config{
+		BaseURL: url,
+	}
+
+	sdk := mfsdk.NewSDK(config)
+	return bootstrap.New(users, things, sdk)
+}
+
+func newThingsService(users mainflux.UsersServiceClient) things.Service {
+	channels := make(map[string]things.Channel, channelsNum)
+	for i := 0; i < channelsNum; i++ {
+		id := strconv.Itoa(i + 1)
+		channels[id] = things.Channel{
+			ID:       id,
+			Owner:    email,
+			Metadata: map[string]interface{}{"meta": "data"},
+		}
+	}
+
+	return mocks.NewThingsService(map[string]things.Thing{}, channels, users)
+}
+
+func newThingsServer(svc things.Service) *httptest.Server {
+	mux := httpapi.MakeHandler(mocktracer.New(), svc)
+	return httptest.NewServer(mux)
+}
+
+func TestAdd(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	neID := config
+	neID.MFThing = "non-existent"
+
+	wrongChannels := config
+	ch := channel
+	ch.ID = "invalid"
+	wrongChannels.MFChannels = append(wrongChannels.MFChannels, ch)
+
+	cases := []struct {
+		desc   string
+		config bootstrap.Config
+		key    string
+		err    error
+	}{
+		{
+			desc:   "add a new config",
+			config: config,
+			key:    validToken,
+			err:    nil,
+		},
+		{
+			desc:   "add a config with an invalid ID",
+			config: neID,
+			key:    validToken,
+			err:    bootstrap.ErrNotFound,
+		},
+		{
+			desc:   "add a config with wrong credentials",
+			config: config,
+			key:    invalidToken,
+			err:    bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc:   "add a config with invalid list of channels",
+			config: wrongChannels,
+			key:    validToken,
+			err:    bootstrap.ErrMalformedEntity,
+		},
+	}
+
+	for _, tc := range cases {
+		_, err := svc.Add(tc.key, tc.config)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestView(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc string
+		id   string
+		key  string
+		err  error
+	}{
+		{
+			desc: "view an existing config",
+			id:   saved.MFThing,
+			key:  validToken,
+			err:  nil,
+		},
+		{
+			desc: "view a non-existing config",
+			id:   unknown,
+			key:  validToken,
+			err:  bootstrap.ErrNotFound,
+		},
+		{
+			desc: "view a config with wrong credentials",
+			id:   config.MFThing,
+			key:  invalidToken,
+			err:  bootstrap.ErrUnauthorizedAccess,
+		},
+	}
+
+	for _, tc := range cases {
+		_, err := svc.View(tc.key, tc.id)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdate(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	c := config
+
+	ch := channel
+	ch.ID = "2"
+	c.MFChannels = append(c.MFChannels, ch)
+	saved, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	modifiedCreated := saved
+	modifiedCreated.Content = "new-config"
+	modifiedCreated.Name = "new name"
+
+	nonExisting := config
+	nonExisting.MFThing = unknown
+
+	cases := []struct {
+		desc   string
+		config bootstrap.Config
+		key    string
+		err    error
+	}{
+		{
+			desc:   "update a config with state Created",
+			config: modifiedCreated,
+			key:    validToken,
+			err:    nil,
+		},
+		{
+			desc:   "update a non-existing config",
+			config: nonExisting,
+			key:    validToken,
+			err:    bootstrap.ErrNotFound,
+		},
+		{
+			desc:   "update a config with wrong credentials",
+			config: saved,
+			key:    invalidToken,
+			err:    bootstrap.ErrUnauthorizedAccess,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.Update(tc.key, tc.config)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateCert(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	c := config
+
+	ch := channel
+	ch.ID = "2"
+	c.MFChannels = append(c.MFChannels, ch)
+	saved, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc       string
+		key        string
+		thingKey   string
+		clientCert string
+		clientKey  string
+		caCert     string
+		err        error
+	}{
+		{
+			desc:       "update certs for the valid config",
+			thingKey:   saved.MFKey,
+			clientCert: "newCert",
+			clientKey:  "newKey",
+			caCert:     "newCert",
+			key:        validToken,
+			err:        nil,
+		},
+		{
+			desc:       "update cert for a non-existing config",
+			thingKey:   "empty",
+			clientCert: "newCert",
+			clientKey:  "newKey",
+			caCert:     "newCert",
+
+			key: validToken,
+			err: bootstrap.ErrNotFound,
+		},
+		{
+			desc:       "update config cert with wrong credentials",
+			thingKey:   saved.MFKey,
+			clientCert: "newCert",
+			clientKey:  "newKey",
+			caCert:     "newCert",
+			key:        invalidToken,
+			err:        bootstrap.ErrUnauthorizedAccess,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.UpdateCert(tc.key, tc.thingKey, tc.clientCert, tc.clientKey, tc.caCert)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateConnections(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+	c := config
+
+	ch := channel
+	ch.ID = "2"
+	c.MFChannels = append(c.MFChannels, ch)
+	created, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	externalID, err := uuid.NewV4()
+	require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+	c.ExternalID = externalID.String()
+	active, err := svc.Add(validToken, c)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	err = svc.ChangeState(validToken, active.MFThing, bootstrap.Active)
+	require.Nil(t, err, fmt.Sprintf("Changing state expected to succeed: %s.\n", err))
+
+	nonExisting := config
+	nonExisting.MFThing = unknown
+
+	cases := []struct {
+		desc        string
+		key         string
+		id          string
+		connections []string
+		err         error
+	}{
+		{
+			desc:        "update connections for config with state Inactive",
+			key:         validToken,
+			id:          created.MFThing,
+			connections: []string{"2"},
+			err:         nil,
+		},
+		{
+			desc:        "update connections for config with state Active",
+			key:         validToken,
+			id:          active.MFThing,
+			connections: []string{"3"},
+			err:         nil,
+		},
+		{
+			desc:        "update connections for non-existing config",
+			key:         validToken,
+			id:          "",
+			connections: []string{"3"},
+			err:         bootstrap.ErrNotFound,
+		},
+		{
+			desc:        "update connections with invalid channels",
+			key:         validToken,
+			id:          created.MFThing,
+			connections: []string{"wrong"},
+			err:         bootstrap.ErrMalformedEntity,
+		},
+		{
+			desc:        "update connections a config with wrong credentials",
+			key:         invalidToken,
+			id:          created.MFKey,
+			connections: []string{"2", "3"},
+			err:         bootstrap.ErrUnauthorizedAccess,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.UpdateConnections(tc.key, tc.id, tc.connections)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestList(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	numThings := 101
+	var saved []bootstrap.Config
+	for i := 0; i < numThings; i++ {
+		c := config
+		id, err := uuid.NewV4()
+		require.Nil(t, err, fmt.Sprintf("Got unexpected error: %s.\n", err))
+		c.ExternalID = id.String()
+		c.ExternalKey = id.String()
+		c.Name = fmt.Sprintf("%s-%d", config.Name, i)
+		s, err := svc.Add(validToken, c)
+		saved = append(saved, s)
+		require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	}
+	// Set one Thing to the different state
+	err := svc.ChangeState(validToken, "42", bootstrap.Active)
+	require.Nil(t, err, fmt.Sprintf("Changing config state expected to succeed: %s.\n", err))
+	saved[41].State = bootstrap.Active
+
+	unknownConfig := bootstrap.Config{
+		ExternalID:  unknownID,
+		ExternalKey: unknownKey,
+	}
+
+	cases := []struct {
+		desc   string
+		config bootstrap.ConfigsPage
+		filter bootstrap.Filter
+		offset uint64
+		limit  uint64
+		key    string
+		err    error
+	}{
+		{
+			desc: "list configs",
+			config: bootstrap.ConfigsPage{
+				Total:   uint64(len(saved)),
+				Offset:  0,
+				Limit:   10,
+				Configs: saved[0:10],
+			},
+			filter: bootstrap.Filter{},
+			key:    validToken,
+			offset: 0,
+			limit:  10,
+			err:    nil,
+		},
+		{
+			desc: "list configs with specified name",
+			config: bootstrap.ConfigsPage{
+				Total:   1,
+				Offset:  0,
+				Limit:   100,
+				Configs: saved[95:96],
+			},
+			filter: bootstrap.Filter{PartialMatch: map[string]string{"name": "95"}},
+			key:    validToken,
+			offset: 0,
+			limit:  100,
+			err:    nil,
+		},
+		{
+			desc:   "list configs unauthorized",
+			config: bootstrap.ConfigsPage{},
+			filter: bootstrap.Filter{},
+			key:    invalidToken,
+			offset: 0,
+			limit:  10,
+			err:    bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc: "list last page",
+			config: bootstrap.ConfigsPage{
+				Total:   uint64(len(saved)),
+				Offset:  95,
+				Limit:   10,
+				Configs: saved[95:],
+			},
+			filter: bootstrap.Filter{},
+			key:    validToken,
+			offset: 95,
+			limit:  10,
+			err:    nil,
+		},
+		{
+			desc: "list configs with Active state",
+			config: bootstrap.ConfigsPage{
+				Total:   1,
+				Offset:  35,
+				Limit:   20,
+				Configs: []bootstrap.Config{saved[41]},
+			},
+			filter: bootstrap.Filter{FullMatch: map[string]string{"state": bootstrap.Active.String()}},
+			key:    validToken,
+			offset: 35,
+			limit:  20,
+			err:    nil,
+		},
+		{
+			desc: "list unknown configs",
+			config: bootstrap.ConfigsPage{
+				Total:   1,
+				Offset:  0,
+				Limit:   20,
+				Configs: []bootstrap.Config{unknownConfig},
+			},
+			filter: bootstrap.Filter{Unknown: true},
+			key:    validToken,
+			offset: 0,
+			limit:  20,
+			err:    nil,
+		},
+	}
+
+	for _, tc := range cases {
+		result, err := svc.List(tc.key, tc.filter, tc.offset, tc.limit)
+		assert.ElementsMatch(t, tc.config.Configs, result.Configs, fmt.Sprintf("%s: expected %v got %v", tc.desc, tc.config.Configs, result.Configs))
+		assert.Equal(t, tc.config.Total, result.Total, fmt.Sprintf("%s: expected %v got %v", tc.desc, tc.config.Total, result.Total))
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestRemove(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc string
+		id   string
+		key  string
+		err  error
+	}{
+		{
+			desc: "view a config with wrong credentials",
+			id:   saved.MFThing,
+			key:  invalidToken,
+			err:  bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc: "remove an existing config",
+			id:   saved.MFThing,
+			key:  validToken,
+			err:  nil,
+		},
+		{
+			desc: "remove removed config",
+			id:   saved.MFThing,
+			key:  validToken,
+			err:  nil,
+		},
+		{
+			desc: "remove non-existing config",
+			id:   unknown,
+			key:  validToken,
+			err:  nil,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.Remove(tc.key, tc.id)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestBootstrap(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc        string
+		config      bootstrap.Config
+		externalKey string
+		externalID  string
+		err         error
+	}{
+		{
+			desc:        "bootstrap using invalid external id",
+			config:      bootstrap.Config{},
+			externalID:  "invalid",
+			externalKey: saved.ExternalKey,
+			err:         bootstrap.ErrNotFound,
+		},
+		{
+			desc:        "bootstrap using invalid external key",
+			config:      bootstrap.Config{},
+			externalID:  saved.ExternalID,
+			externalKey: "invalid",
+			err:         bootstrap.ErrNotFound,
+		},
+		{
+			desc:        "bootstrap an existing config",
+			config:      saved,
+			externalID:  saved.ExternalID,
+			externalKey: saved.ExternalKey,
+			err:         nil,
+		},
+	}
+
+	for _, tc := range cases {
+		config, err := svc.Bootstrap(tc.externalKey, tc.externalID)
+		assert.Equal(t, tc.config, config, fmt.Sprintf("%s: expected %v got %v\n", tc.desc, tc.config, config))
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestChangeState(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc  string
+		state bootstrap.State
+		id    string
+		key   string
+		err   error
+	}{
+		{
+			desc:  "change state with wrong credentials",
+			state: bootstrap.Active,
+			id:    saved.MFThing,
+			key:   invalidToken,
+			err:   bootstrap.ErrUnauthorizedAccess,
+		},
+		{
+			desc:  "change state of non-existing config",
+			state: bootstrap.Active,
+			id:    unknown,
+			key:   validToken,
+			err:   bootstrap.ErrNotFound,
+		},
+		{
+			desc:  "change state to Active",
+			state: bootstrap.Active,
+			id:    saved.MFThing,
+			key:   validToken,
+			err:   nil,
+		},
+		{
+			desc:  "change state to current state",
+			state: bootstrap.Active,
+			id:    saved.MFThing,
+			key:   validToken,
+			err:   nil,
+		},
+		{
+			desc:  "change state to Inactive",
+			state: bootstrap.Inactive,
+			id:    saved.MFThing,
+			key:   validToken,
+			err:   nil,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.ChangeState(tc.key, tc.id, tc.state)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestUpdateChannelHandler(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	_, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+	ch := bootstrap.Channel{
+		ID:       channel.ID,
+		Name:     "new name",
+		Metadata: map[string]interface{}{"meta": "new"},
+	}
+
+	cases := []struct {
+		desc    string
+		channel bootstrap.Channel
+		err     error
+	}{
+		{
+			desc:    "update an existing channel",
+			channel: ch,
+			err:     nil,
+		},
+		{
+			desc:    "update a non-existing channel",
+			channel: bootstrap.Channel{ID: ""},
+			err:     nil,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.UpdateChannelHandler(tc.channel)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestRemoveChannelHandler(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	_, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc string
+		id   string
+		err  error
+	}{
+		{
+			desc: "remove an existing channel",
+			id:   channel.ID,
+			err:  nil,
+		},
+		{
+			desc: "remove a non-existing channel",
+			id:   "unknown",
+			err:  nil,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.RemoveChannelHandler(tc.id)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestRemoveCoinfigHandler(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc string
+		id   string
+		err  error
+	}{
+		{
+			desc: "remove an existing conifg",
+			id:   saved.MFThing,
+			err:  nil,
+		},
+		{
+			desc: "remove a non-existing channel",
+			id:   "unknown",
+			err:  nil,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.RemoveConfigHandler(tc.id)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}
+
+func TestDisconnectThingsHandler(t *testing.T) {
+	users := mocks.NewUsersService(map[string]string{validToken: email})
+
+	server := newThingsServer(newThingsService(users))
+	svc := newService(users, server.URL)
+
+	saved, err := svc.Add(validToken, config)
+	require.Nil(t, err, fmt.Sprintf("Saving config expected to succeed: %s.\n", err))
+
+	cases := []struct {
+		desc      string
+		thingID   string
+		channelID string
+		err       error
+	}{
+		{
+			desc:      "disconnect",
+			channelID: channel.ID,
+			thingID:   saved.MFThing,
+			err:       nil,
+		},
+		{
+			desc:      "disconnect dicsonnected",
+			channelID: channel.ID,
+			thingID:   saved.MFThing,
+			err:       nil,
+		},
+	}
+
+	for _, tc := range cases {
+		err := svc.DisconnectThingHandler(tc.channelID, tc.thingID)
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
+	}
+}

bootstrap/state.go

@@ -0,0 +1,30 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package bootstrap
+
+import "strconv"
+
+const (
+	// Inactive Thing is created, but not able to exchange messages using Mainflux.
+	Inactive State = iota
+	// Active Thing is created, configured, and whitelisted.
+	Active
+)
+
+// State represents corresponding Mainflux Thing state. The possible Config States
+// as well as description of what that State represents are given in the table:
+// | State    | What it means 		                                                           |
+// |----------+--------------------------------------------------------------------------------|
+// | Inactive | Thing is created, but isn't able to communicate over Mainflux 				   |
+// | Active   | Thing is able to communicate using Mainflux                                    |
+type State int
+
+// String returns string representation of State.
+func (s State) String() string {
+	return strconv.Itoa(int(s))
+}

bootstrap/swagger.yml

@@ -0,0 +1,483 @@
+swagger: "2.0"
+info:
+  title: Mainflux Bootstrap service
+  description: HTTP API for managing platform things configuration.
+  version: "1.0.0"
+consumes:
+  - "application/json"
+produces:
+  - "application/json"
+paths:
+  /things/configs:
+    post:
+      summary: Adds new config
+      description: |
+        Adds new config to the list of config owned by user identified using
+        the provided access token.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - name: config
+          description: JSON-formatted document describing the new config.
+          in: body
+          schema:
+            $ref: "#/definitions/ConfigReq"
+          required: true
+      responses:
+        201:
+          description: Config registered.
+          headers:
+            Location:
+              type: string
+              description: Created config's relative URL (i.e. /things/configs/{configId}).
+        400:
+          description: Failed due to malformed JSON.
+        403:
+          description: Missing or invalid access token provided.
+        415:
+          description: Missing or invalid content type.
+        500:
+          $ref: "#/responses/ServiceError"
+    get:
+      summary: Retrieves managed configs
+      description: |
+        Retrieves a list of managed configs. Due to performance concerns, data
+        is retrieved in subsets. The API configs must ensure that the entire
+        dataset is consumed either by making subsequent requests, or by
+        increasing the subset size of the initial request.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/Limit"
+        - $ref: "#/parameters/Offset"
+        - $ref: "#/parameters/State"
+        - $ref: "#/parameters/Name"
+      responses:
+        200:
+          description: |
+            Data retrieved. Configs from this list don't contain channels.
+          schema:
+            $ref: "#/definitions/ConfigList"
+        400:
+          description: Failed due to malformed query parameters.
+        403:
+          description: Missing or invalid access token provided.
+        500:
+          $ref: "#/responses/ServiceError"
+  /things/bootstrap/{externalId}:
+    get:
+      summary: Retrieves configuration
+      description: |
+        Retrieves a configuration with given external ID and external key.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/ConfigAuthorization"
+        - $ref: "#/parameters/ExternalId"
+      responses:
+        200:
+          description: Data retrieved.
+          schema:
+            $ref: "#/definitions/BootstrapRes"
+        404:
+          description: |
+            Failed to retrieve corresponding config. Thing which attempted
+            to bootstrap is saved as an unknown Thing and can be listed and
+            added to the service later.
+        500:
+          $ref: "#/responses/ServiceError"
+  /things/configs/{configId}:
+    get:
+      summary: Retrieves config info (with channels)
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/ConfigId"
+      responses:
+        200:
+          description: Data retrieved.
+          schema:
+            $ref: "#/definitions/ConfigRes"
+        403:
+          description: Missing or invalid access token provided.
+        404:
+          description: Config does not exist.
+        500:
+          $ref: "#/responses/ServiceError"
+    put:
+      summary: Updates config info
+      description: |
+        Update is performed by replacing the current resource data with values
+        provided in a request payload. Note that the owner, ID, external ID,
+        external key, Mainflux Thing ID and key cannot be changed.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/ConfigId"
+        - name: config
+          description: JSON-formatted document describing the updated thing.
+          in: body
+          schema:
+            $ref: "#/definitions/ConfigUpdateReq"
+          required: true
+      responses:
+        200:
+          description: Config updated.
+        400:
+          description: Failed due to malformed JSON.
+        403:
+          description: Missing or invalid access token provided.
+        404:
+          description: Config does not exist.
+        415:
+          description: Missing or invalid content type.
+        500:
+          $ref: "#/responses/ServiceError"
+    delete:
+      summary: Removes a Config
+      description: |
+        Removes a Config. In case of successfull removal the service will ensure
+        that the removed config is disconnected from all of the Maifnlux channels.
+      tags:
+        - confgis
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/ConfigId"
+      responses:
+        204:
+          description: Config removed.
+        400:
+          description: Failed due to malformed config's ID.
+        403:
+          description: Missing or invalid access token provided.
+        500:
+          $ref: "#/responses/ServiceError"
+  /things/configs/certs/{thingKey}:
+    put:
+      summary: Updates certs
+      description: |
+        Update is performed by replacing the current certificate data with values
+        provided in a request payload.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/ThingKey"
+        - name: config
+          description: JSON-formatted document describing the updated thing.
+          in: body
+          schema:
+            $ref: "#/definitions/ConfigUpdateCertReq"
+          required: true
+      responses:
+        200:
+          description: Config updated.
+        400:
+          description: Failed due to malformed JSON.
+        403:
+          description: Missing or invalid access token provided.
+        404:
+          description: Config does not exist.
+        415:
+          description: Missing or invalid content type.
+        500:
+          $ref: "#/responses/ServiceError"
+  /things/configs/connections/{configId}:
+    put:
+      summary: Updates channels the thing is connected to
+      description: |
+        Update connections performs update of the channel list corresponding
+        Thing is connected to.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/ConfigId"
+        - name: channels
+          description: Array if IDs the thing is be connected to.
+          in: body
+          schema:
+            $ref: "#/definitions/ConfigUpdateConnReq"
+          required: true
+      responses:
+        200:
+          description: Config updated.
+        400:
+          description: Failed due to malformed JSON.
+        403:
+          description: Missing or invalid access token provided.
+        404:
+          description: Config does not exist.
+        415:
+          description: Missing or invalid content type.
+        500:
+          $ref: "#/responses/ServiceError"
+  /things/state/{configId}:
+    put:
+      summary: Updates Config state.
+      description: |
+        Updating state represents enabling/disabling Config, i.e. connecting
+        and disconnecting corresponding Mainflux Thing to the list of Channels.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/ConfigId"
+        - name: state
+          description: New state of the Config.
+          in: body
+          schema:
+            type: object
+            properties:
+              state:
+                type: integer
+                enum:
+                  - inactive
+                  - active
+      responses:
+        204:
+          description: Config removed.
+        400:
+          description: Failed due to malformed config's ID.
+        403:
+          description: Missing or invalid access token provided.
+        500:
+          $ref: "#/responses/ServiceError"
+  /things/unknown/configs:
+    get:
+      summary: Get a list of unsucessfully bootstrapped Things
+      description: |
+        Retrieves a list of unknown configs. Due to performance concerns, data
+        is retrieved in subsets. The API configs must ensure that the entire
+        dataset is consumed either by making subsequent requests, or by
+        increasing the subset size of the initial request.
+      tags:
+        - configs
+      parameters:
+        - $ref: "#/parameters/Authorization"
+        - $ref: "#/parameters/Limit"
+        - $ref: "#/parameters/Offset"
+      responses:
+        200:
+          description: Data retrieved.
+          schema:
+            $ref: "#/definitions/ConfigList"
+        400:
+          description: Failed due to malformed query parameters.
+        403:
+          description: Missing or invalid access token provided.
+        500:
+          $ref: "#/responses/ServiceError"
+
+parameters:
+  Authorization:
+    name: Authorization
+    description: User's access token.
+    in: header
+    type: string
+    required: true
+  ConfigAuthorization:
+    name: configAuthorization
+    description: Configuration external key.
+    in: header
+    type: string
+    required: true
+  ConfigId:
+    name: configId
+    description: Unique Config identifier. It's the ID of the corresponding Thing.
+    in: path
+    type: string
+    required: true
+  ThingKey:
+    name: thingKey
+    description: Unique Thing key.
+    in: path
+    type: string
+    required: true
+  ExternalId:
+    name: externalId
+    description: Unique Config identifier provided by external entity.
+    in: path
+    type: string
+    required: true
+  Limit:
+    name: limit
+    description: Size of the subset to retrieve.
+    in: query
+    type: integer
+    default: 10
+    maximum: 100
+    minimum: 1
+    required: false
+  Offset:
+    name: offset
+    description: Number of items to skip during retrieval.
+    in: query
+    type: integer
+    default: 0
+    minimum: 0
+    required: false
+  State:
+    name: state
+    description: A state of items
+    in: query
+    type: integer
+    enum:
+      - inactive
+      - active
+    required: false
+  Name:
+    name: name
+    description: Name of the config. Search by name is partial-match and case-insensitive.
+    in: query
+    type: string
+    required: false
+
+responses:
+  ServiceError:
+    description: Unexpected server-side error occured.
+
+definitions:
+  ConfigList:
+    type: object
+    properties:
+      total:
+        type: integer
+        description: Total number of results.
+        minimum: 0
+      offset:
+        type: integer
+        description: Number of items to skip during retrieval.
+        minimum: 0
+        default: 0
+      limit:
+        type: integer
+        description: Size of the subset to retrieve.
+        maximum: 100
+        default: 10
+      configs:
+        type: array
+        minItems: 0
+        uniqueItems: true
+        items:
+          $ref: "#/definitions/ConfigRes"
+    required:
+      - confgis
+  State:
+    type: integer
+    enum:
+      - active
+      - inactive
+  ConfigRes:
+    type: object
+    properties:
+      mainflux_id:
+        type: string
+        description: Corresponding Mainflux Thing ID.
+      mainflux_key:
+        type: string
+        description: Corresponding Mainflux Thing key.
+      mainflux_channels:
+        type: array
+        minItems: 0
+        items:
+          type: object
+          properties:
+            id:
+              type: string
+              description: ID of the Channel.
+            name:
+              type: string
+              description: Name of the Channel.
+            metadata:
+              type: object
+              description: Custom metadata related to the Channel.
+      external_id:
+        type: string
+        description: External ID (MAC address or some uinque identifier).
+      external_key:
+        type: string
+        description: External key.
+      content:
+        type: string
+        description: Free-form custom configuration.
+      state:
+        $ref: '#/definitions/State'
+    required:
+      - external_id
+      - external_key
+  BootstrapRes:
+      type: object
+      properties:
+        mainflux_id:
+          type: string
+          description: Corresponding Mainflux Thing ID.
+        mainflux_key:
+          type: string
+          description: Corresponding Mainflux Thing key.
+        mainflux_channels:
+          type: array
+          minItems: 0
+          items:
+            type: string
+        content:
+          type: string
+          description: Free-form custom configuration.
+      required:
+        - mainflux_id
+        - mainflux_key
+        - mainflux_channels
+        - content
+  ConfigReq:
+    type: object
+    properties:
+      external_id:
+        type: string
+        description: External ID (MAC address or some uinque identifier).
+      external_key:
+        type: string
+        description: External key.
+      thing_id:
+        type: string
+        description: ID of the corresponding Mainflux Thing.
+      channels:
+        type: array
+        minItems: 0
+        items:
+          type: string
+      content:
+        type: string
+    required:
+      - external_id
+      - external_key
+  ConfigUpdateReq:
+    type: object
+    properties:
+      content:
+        type: string
+      name:
+        type: string
+    required:
+      - content
+      - name
+  ConfigUpdateConnReq:
+    type: object
+    properties:
+      channels:
+        type: array
+        minItems: 0
+        items:
+          type: string
+  ConfigUpdateCertReq:
+    type: object
+    properties:
+      client_cert:
+        type: string
+      client_key:
+        type: string
+      ca_cert:
+        type: string

cli/README.md

@@ -0,0 +1,108 @@
+# Mainflux CLI
+## Build
+From the project root:
+```
+make cli
+```
+
+## Usage
+### Service
+#### Get the version of Mainflux services
+```
+mainflux-cli version
+```
+
+### Users 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
+#### Create Thing (type Device)
+```
+mainflux-cli things create '{"name":"myDevice"}' <user_auth_token>
+```
+
+#### Create Thing (type Application)
+```
+mainflux-cli things create '{"name":"myDevice"}' <user_auth_token>
+```
+
+#### Update Thing
+```
+mainflux-cli things update '{"id":"<thing_id>", "name":"myNewName"}' <user_auth_token>
+```
+
+#### Remove Thing
+```
+mainflux-cli things delete <thing_id> <user_auth_token>
+```
+
+#### Retrieve a subset list of provisioned Things
+```
+mainflux-cli things get all --offset=1 --limit=5 <user_auth_token>
+```
+
+#### Retrieve Thing By ID
+```
+mainflux-cli things get <thing_id> <user_auth_token>
+```
+
+#### Create Channel
+```
+mainflux-cli channels create '{"name":"myChannel"}' <user_auth_token>
+```
+
+#### Update Channel
+```
+mainflux-cli channels update '{"id":"<channel_id>","name":"myNewName"}' <user_auth_token>
+
+```
+#### Remove Channel
+```
+mainflux-cli channels delete <channel_id> <user_auth_token>
+```
+
+#### Retrieve a subset list of provisioned Channels
+```
+mainflux-cli channels get all --offset=1 --limit=5 <user_auth_token>
+```
+
+#### Retrieve Channel By ID
+```
+mainflux-cli channels get <channel_id> <user_auth_token>
+```
+
+### Access control
+#### Connect Thing to Channel
+```
+mainflux-cli things connect <thing_id> <channel_id> <user_auth_token>
+```
+
+#### Disconnect Thing from Channel
+```
+mainflux-cli things disconnect <thing_id> <channel_id> <user_auth_token>
+
+```
+
+#### Retrieve a subset list of Channels connected to Thing
+```
+mainflux-cli things connections <thing_id> <user_auth_token>
+```
+
+#### Retrieve a subset list of Things connected to Channel
+```
+mainflux-cli channels connections <channel_id> <user_auth_token>
+```
+
+### Messaging
+#### Send a message over HTTP
+```
+mainflux-cli messages send <channel_id> '[{"bn":"Dev1","n":"temp","v":20}, {"n":"hum","v":40}, {"bn":"Dev2", "n":"temp","v":20}, {"n":"hum","v":40}]' <thing_auth_token>
+```

cli/channels.go

@@ -0,0 +1,152 @@
+//
+// 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
+			}
+
+			logCreated(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), Name)
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				logJSON(l)
+				return
+			}
+
+			c, err := sdk.Channel(args[0], args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(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) != 2 {
+				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()
+		},
+	},
+	cobra.Command{
+		Use:   "connections",
+		Short: "connections <channel_id> <user_auth_token>",
+		Long:  `List of Things connected to Channel`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			cl, err := sdk.ThingsByChannel(args[1], args[0], uint64(Offset), uint64(Limit))
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(cl)
+		},
+	},
+}
+
+// NewChannelsCmd returns channels command.
+func NewChannelsCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "channels",
+		Short: "Channels management",
+		Long:  `Channels management: create, get, update or delete Channel and get list of Things connected to Channel`,
+		Run: func(cmd *cobra.Command, args []string) {
+			logUsage("channels [create | get | update | delete | connections]")
+		},
+	}
+
+	for i := range cmdChannels {
+		cmd.AddCommand(&cmdChannels[i])
+	}
+
+	return &cmd
+}

cli/message.go

@@ -0,0 +1,70 @@
+//
+// 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>[.<subtopic>...] <JSON_string> <thing_key>",
+		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()
+		},
+	},
+	cobra.Command{
+		Use:   "read",
+		Short: "read <channel_id>[.<subtopic>...] <thing_key>",
+		Long:  `Reads all channel messages`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			m, err := sdk.ReadMessages(args[0], args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(m)
+		},
+	},
+}
+
+// NewMessagesCmd returns messages command.
+func NewMessagesCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "messages",
+		Short: "Send or read messages",
+		Long:  `Send or read messages using the http-adapter and the configured database reader`,
+		Run: func(cmd *cobra.Command, args []string) {
+			logUsage("messages [send | read]")
+		},
+	}
+
+	for i := range cmdMessages {
+		cmd.AddCommand(&cmdMessages[i])
+	}
+
+	return &cmd
+}

cli/provision.go

@@ -0,0 +1,246 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import (
+	"bufio"
+	"encoding/csv"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/docker/docker/pkg/namesgenerator"
+	mfxsdk "github.com/mainflux/mainflux/sdk/go"
+	"github.com/spf13/cobra"
+)
+
+var errMalformedCSV = errors.New("malformed CSV")
+
+func createThing(name, token string) (mfxsdk.Thing, error) {
+	id, err := sdk.CreateThing(mfxsdk.Thing{Name: name}, token)
+	if err != nil {
+		return mfxsdk.Thing{}, err
+	}
+
+	t, err := sdk.Thing(id, token)
+	if err != nil {
+		return mfxsdk.Thing{}, err
+	}
+
+	m := mfxsdk.Thing{
+		ID:   id,
+		Name: name,
+		Key:  t.Key,
+	}
+
+	return m, nil
+}
+
+func createChannel(name, token string) (mfxsdk.Channel, error) {
+	id, err := sdk.CreateChannel(mfxsdk.Channel{Name: name}, token)
+	if err != nil {
+		return mfxsdk.Channel{}, nil
+	}
+
+	c := mfxsdk.Channel{
+		ID:   id,
+		Name: name,
+	}
+
+	return c, nil
+}
+
+var cmdProvision = []cobra.Command{
+	cobra.Command{
+		Use:   "things",
+		Short: "things <things_csv> <user_token>",
+		Long:  `Provisions things`,
+		Run: func(cmd *cobra.Command, args []string) {
+			things := []mfxsdk.Thing{}
+
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			c, err := os.Open(args[0])
+			if err != nil {
+				logError(err)
+				return
+			}
+			reader := csv.NewReader(bufio.NewReader(c))
+
+			for {
+				l, err := reader.Read()
+				if err == io.EOF {
+					break
+				}
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				if len(l) < 1 {
+					logError(errMalformedCSV)
+					return
+				}
+
+				m, err := createThing(l[0], args[1])
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				things = append(things, m)
+			}
+
+			logJSON(things)
+		},
+	},
+	cobra.Command{
+		Use:   "channels",
+		Short: "channels <channels_csv> <user_token>",
+		Long:  `Provisions channels`,
+		Run: func(cmd *cobra.Command, args []string) {
+			channels := []mfxsdk.Channel{}
+
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			c, err := os.Open(args[0])
+			if err != nil {
+				logError(err)
+				return
+			}
+			reader := csv.NewReader(bufio.NewReader(c))
+
+			for {
+				l, err := reader.Read()
+				if err == io.EOF {
+					break
+				}
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				if len(l) < 1 {
+					logError(errMalformedCSV)
+					return
+				}
+
+				c, err := createChannel(l[0], args[1])
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				channels = append(channels, c)
+			}
+
+			logJSON(channels)
+		},
+	},
+	cobra.Command{
+		Use:   "test",
+		Short: "test",
+		Long: `Provisions test setup: one test user, two things and two channels. \
+						Connect both things to one of the channels, \
+						and only on thing to other channel.`,
+		Run: func(cmd *cobra.Command, args []string) {
+			numThings := 2
+			numChan := 2
+			things := []mfxsdk.Thing{}
+			channels := []mfxsdk.Channel{}
+
+			if len(args) != 0 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			un := fmt.Sprintf("%s@email.com", namesgenerator.GetRandomName(0))
+			// Create test user
+			user := mfxsdk.User{
+				Email:    un,
+				Password: "123",
+			}
+			if err := sdk.CreateUser(user); err != nil {
+				logError(err)
+				return
+			}
+
+			ut, err := sdk.CreateToken(user)
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			// Create things
+			for i := 0; i < numThings; i++ {
+				n := fmt.Sprintf("d%d", i)
+
+				m, err := createThing(n, ut)
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				things = append(things, m)
+			}
+			// Create channels
+			for i := 0; i < numChan; i++ {
+				n := fmt.Sprintf("c%d", i)
+				c, err := createChannel(n, ut)
+				if err != nil {
+					logError(err)
+					return
+				}
+
+				channels = append(channels, c)
+			}
+
+			// Connect things to channels - first thing to both channels, second only to first
+			for i := 0; i < numThings; i++ {
+				if err := sdk.ConnectThing(things[i].ID, channels[i].ID, ut); err != nil {
+					logError(err)
+					return
+				}
+
+				if i%2 == 0 {
+					if i+1 >= len(channels) {
+						break
+					}
+					if err := sdk.ConnectThing(things[i].ID, channels[i+1].ID, ut); err != nil {
+						logError(err)
+						return
+					}
+				}
+			}
+
+			logJSON(user, ut, things, channels)
+		},
+	},
+}
+
+// NewProvisionCmd returns provision command.
+func NewProvisionCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "provision",
+		Short: "Provision things and channels from config file",
+		Long:  `Provision things and channels: use csv config file to provision things and channels`,
+	}
+
+	for i := range cmdProvision {
+		cmd.AddCommand(&cmdProvision[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,189 @@
+//
+// 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
+			}
+
+			logCreated(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), Name)
+				if err != nil {
+					logError(err)
+					return
+				}
+				logJSON(l)
+				return
+			}
+
+			t, err := sdk.Thing(args[0], args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(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) != 2 {
+				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()
+		},
+	},
+	cobra.Command{
+		Use:   "connections",
+		Short: "connections <thing_id> <user_auth_token>",
+		Long:  `List of Channels connected to Thing`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Short)
+				return
+			}
+
+			cl, err := sdk.ChannelsByThing(args[1], args[0], uint64(Offset), uint64(Limit))
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(cl)
+		},
+	},
+}
+
+// NewThingsCmd returns things command.
+func NewThingsCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "things",
+		Short: "Things management",
+		Long:  `Things management: create, get, update or delete Thing, connect or disconnect Thing from Channel and get the list of Channels connected to Thing`,
+		Run: func(cmd *cobra.Command, args []string) {
+			logUsage("things [create | get | update | delete | connect | disconnect | connections]")
+		},
+	}
+
+	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
+			}
+
+			logCreated(token)
+		},
+	},
+}
+
+// NewUsersCmd returns users command.
+func NewUsersCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "users",
+		Short: "Users management",
+		Long:  `Users management: create accounts and tokens"`,
+		Run: func(cmd *cobra.Command, args []string) {
+			logUsage("Usage: users [create | token]")
+		},
+	}
+
+	for i := range cmdUsers {
+		cmd.AddCommand(&cmdUsers[i])
+	}
+
+	return &cmd
+}

cli/utils.go

@@ -0,0 +1,59 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/fatih/color"
+	prettyjson "github.com/hokaccha/go-prettyjson"
+)
+
+var (
+	// Limit query parameter
+	Limit uint = 10
+	// Offset query parameter
+	Offset uint = 0
+	// Name query parameter
+	Name string = ""
+)
+
+func logJSON(iList ...interface{}) {
+	for _, i := range iList {
+		m, err := json.Marshal(i)
+		if err != nil {
+			logError(err)
+			return
+		}
+
+		pj, err := prettyjson.Format(m)
+		if err != nil {
+			logError(err)
+			return
+		}
+
+		fmt.Printf("\n%s\n\n", string(pj))
+	}
+}
+
+func logUsage(u string) {
+	fmt.Printf(color.YellowString("\nusage: %s\n\n"), u)
+}
+
+func logError(err error) {
+	fmt.Printf("\n%s\n\n", color.RedString(err.Error()))
+}
+
+func logOK() {
+	fmt.Printf("\n%s\n\n", color.BlueString("ok"))
+}
+
+func logCreated(e string) {
+	fmt.Printf(color.BlueString("\ncreated: %s\n\n"), e)
+}

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: "Mainflux services version",
+		Long:  `Mainflux services version: get version of Mainflux Things Service`,
+		Run: func(cmd *cobra.Command, args []string) {
+			v, err := sdk.Version()
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(v)
+		},
+	}
+}

clients/README.md

@@ -1,81 +0,0 @@
-# Clients
-
-Clients service provides an HTTP API for managing platform resources: devices,
-applications and channels. Through this API clients are able to do the following
-actions:
-
-- provision new clients (i.e. devices & applications)
-- create new channels
-- "connect" clients into the channels
-
-For in-depth explanation of the aforementioned scenarios, as well as thorough
-understanding of Mainflux, please check out the [official documentation][doc].
-
-## 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_CLIENTS_DB_HOST     | Database host address                    | localhost      |
-| MF_CLIENTS_DB_PORT     | Database host port                       | 5432           |
-| MF_CLIENTS_DB_USER     | Database user                            | mainflux       |
-| MF_CLIENTS_DB_PASSWORD | Database password                        | mainflux       |
-| MF_CLIENTS_DB          | Name of the database used by the service | clients        |
-| MF_CLIENTS_HTTP_PORT   | Clients service HTTP port                | 8180           |
-| MF_CLIENTS_GRPC_PORT   | Clients service gRPC port                | 8181           |
-| MF_USERS_URL           | Users service URL                        | localhost:8181 |
-| MF_CLIENTS_SECRET      | String used for signing tokens           | clients        |
-
-## Deployment
-
-The service itself 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:
-  clients:
-    image: mainflux/clients:[version]
-    container_name: [instance name]
-    ports:
-      - [host machine port]:[configured HTTP port]
-    environment:
-      MF_CLIENTS_DB_HOST: [Database host address]
-      MF_CLIENTS_DB_PORT: [Database host port]
-      MF_CLIENTS_DB_USER: [Database user]
-      MF_CLIENTS_DB_PASS: [Database password]
-      MF_CLIENTS_DB: [Name of the database used by the service]
-      MF_CLIENTS_HTTP_PORT: [Service HTTP port]
-      MF_CLIENTS_GRPC_PORT: [Service gRPC port]
-      MF_USERS_URL: [Users service URL]
-      MF_CLIENTS_SECRET: [String used for signing tokens]
-```
-
-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 clients
-make clients
-
-# copy binary to bin
-make install
-
-# set the environment variables and run the service
-MF_CLIENTS_DB_HOST=[Database host address] MF_CLIENTS_DB_PORT=[Database host port] MF_CLIENTS_DB_USER=[Database user] MF_CLIENTS_DB_PASS=[Database password] MF_CLIENTS_DB=[Name of the database used by the service] MF_CLIENTS_HTTP_PORT=[Service HTTP port] MF_CLIENTS_GRPC_PORT=[Service gRPC port] MF_USERS_URL=[Users service URL] MF_CLIENTS_SECRET=[String used for signing tokens] $GOBIN/mainflux-clients
-```
-
-## Usage
-
-For more information about service capabilities and its usage, please check out
-the [API documentation](swagger.yaml).
-
-[doc]: http://mainflux.readthedocs.io

clients/api/grpc/client.go

@@ -1,49 +0,0 @@
-package grpc
-
-import (
-	"github.com/go-kit/kit/endpoint"
-	kitgrpc "github.com/go-kit/kit/transport/grpc"
-	"github.com/mainflux/mainflux"
-	"golang.org/x/net/context"
-	"google.golang.org/grpc"
-)
-
-var _ mainflux.ClientsServiceClient = (*grpcClient)(nil)
-
-type grpcClient struct {
-	canAccess endpoint.Endpoint
-}
-
-// NewClient returns new gRPC client instance.
-func NewClient(conn *grpc.ClientConn) mainflux.ClientsServiceClient {
-	endpoint := kitgrpc.NewClient(
-		conn,
-		"mainflux.ClientsService",
-		"CanAccess",
-		encodeCanAccessRequest,
-		decodeCanAccessResponse,
-		mainflux.Identity{},
-	).Endpoint()
-
-	return &grpcClient{endpoint}
-}
-
-func (client grpcClient) CanAccess(ctx context.Context, req *mainflux.AccessReq, _ ...grpc.CallOption) (*mainflux.Identity, error) {
-	res, err := client.canAccess(ctx, accessReq{req.GetToken(), req.GetChanID()})
-	if err != nil {
-		return nil, err
-	}
-
-	ar := res.(accessRes)
-	return &mainflux.Identity{Value: ar.id}, ar.err
-}
-
-func encodeCanAccessRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	req := grpcReq.(accessReq)
-	return &mainflux.AccessReq{Token: req.clientKey, ChanID: req.chanID}, nil
-}
-
-func decodeCanAccessResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
-	res := grpcRes.(*mainflux.Identity)
-	return accessRes{res.GetValue(), nil}, nil
-}

clients/api/grpc/doc.go

@@ -1,2 +0,0 @@
-// Package grpc contains implementation of clients service gRPC API.
-package grpc

clients/api/grpc/endpoint.go

@@ -1,22 +0,0 @@
-package grpc
-
-import (
-	"github.com/go-kit/kit/endpoint"
-	"github.com/mainflux/mainflux/clients"
-	context "golang.org/x/net/context"
-)
-
-func canAccessEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(accessReq)
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		id, err := svc.CanAccess(req.clientKey, req.chanID)
-		if err != nil {
-			return accessRes{"", err}, err
-		}
-		return accessRes{id, nil}, nil
-	}
-}

clients/api/grpc/endpoint_test.go

@@ -1,87 +0,0 @@
-package grpc_test
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"testing"
-	"time"
-
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/clients"
-	grpcapi "github.com/mainflux/mainflux/clients/api/grpc"
-	"github.com/mainflux/mainflux/clients/mocks"
-	"github.com/stretchr/testify/assert"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-)
-
-const (
-	port  = 8080
-	token = "token"
-	wrong = "wrong"
-	email = "john.doe@email.com"
-)
-
-var (
-	client  = clients.Client{Type: "app", Name: "test_app", Payload: "test_payload"}
-	channel = clients.Channel{Name: "test"}
-)
-
-func newService(tokens map[string]string) clients.Service {
-	users := mocks.NewUsersService(tokens)
-	clientsRepo := mocks.NewClientRepository()
-	channelsRepo := mocks.NewChannelRepository(clientsRepo)
-	hasher := mocks.NewHasher()
-	idp := mocks.NewIdentityProvider()
-
-	return clients.New(users, clientsRepo, channelsRepo, hasher, idp)
-}
-
-func startGRPCServer(svc clients.Service, port int) {
-	listener, _ := net.Listen("tcp", fmt.Sprintf(":%d", port))
-	server := grpc.NewServer()
-	mainflux.RegisterClientsServiceServer(server, grpcapi.NewServer(svc))
-	go server.Serve(listener)
-}
-
-func TestCanAccess(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	startGRPCServer(svc, port)
-
-	connectedClientID, _ := svc.AddClient(token, client)
-	connectedClient, _ := svc.ViewClient(token, connectedClientID)
-
-	clientID, _ := svc.AddClient(token, client)
-	client, _ := svc.ViewClient(token, clientID)
-
-	chanID, _ := svc.CreateChannel(token, channel)
-	svc.Connect(token, chanID, connectedClientID)
-
-	usersAddr := fmt.Sprintf("localhost:%d", port)
-	conn, _ := grpc.Dial(usersAddr, grpc.WithInsecure())
-	cli := grpcapi.NewClient(conn)
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	cases := map[string]struct {
-		clientKey string
-		chanID    string
-		id        string
-		code      codes.Code
-	}{
-		"check if connected client can access existing channel":     {connectedClient.Key, chanID, connectedClientID, codes.OK},
-		"check if unconnected client can access existing channel":   {client.Key, chanID, "", codes.PermissionDenied},
-		"check if wrong client can access existing channel":         {wrong, chanID, "", codes.PermissionDenied},
-		"check if connected client can access non-existent channel": {connectedClient.Key, "1", "", codes.InvalidArgument},
-	}
-
-	for desc, tc := range cases {
-		id, err := cli.CanAccess(ctx, &mainflux.AccessReq{tc.clientKey, tc.chanID})
-		e, ok := status.FromError(err)
-		assert.True(t, ok, "OK expected to be true")
-		assert.Equal(t, tc.id, id.GetValue(), fmt.Sprintf("%s: expected %s got %s", desc, tc.id, id.GetValue()))
-		assert.Equal(t, tc.code, e.Code(), fmt.Sprintf("%s: expected %s got %s", desc, tc.code, e.Code()))
-	}
-}

clients/api/grpc/requests.go

@@ -1,18 +0,0 @@
-package grpc
-
-import (
-	"github.com/asaskevich/govalidator"
-	"github.com/mainflux/mainflux/clients"
-)
-
-type accessReq struct {
-	clientKey string
-	chanID    string
-}
-
-func (req accessReq) validate() error {
-	if !govalidator.IsUUID(req.chanID) || req.clientKey == "" {
-		return clients.ErrMalformedEntity
-	}
-	return nil
-}

clients/api/grpc/responses.go

@@ -1,6 +0,0 @@
-package grpc
-
-type accessRes struct {
-	id  string
-	err error
-}

clients/api/grpc/server.go

@@ -1,59 +0,0 @@
-package grpc
-
-import (
-	kitgrpc "github.com/go-kit/kit/transport/grpc"
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/clients"
-	"golang.org/x/net/context"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-)
-
-var _ mainflux.ClientsServiceServer = (*grpcServer)(nil)
-
-type grpcServer struct {
-	handler kitgrpc.Handler
-}
-
-// NewServer returns new ClientsServiceServer instance.
-func NewServer(svc clients.Service) mainflux.ClientsServiceServer {
-	handler := kitgrpc.NewServer(
-		canAccessEndpoint(svc),
-		decodeCanAccessRequest,
-		encodeCanAccessResponse,
-	)
-	return &grpcServer{handler}
-}
-
-func (s *grpcServer) CanAccess(ctx context.Context, req *mainflux.AccessReq) (*mainflux.Identity, error) {
-	_, res, err := s.handler.ServeGRPC(ctx, req)
-	if err != nil {
-		return nil, encodeError(err)
-	}
-	return res.(*mainflux.Identity), nil
-}
-
-func decodeCanAccessRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	req := grpcReq.(*mainflux.AccessReq)
-	return accessReq{req.GetToken(), req.GetChanID()}, nil
-}
-
-func encodeCanAccessResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
-	res := grpcRes.(accessRes)
-	return &mainflux.Identity{Value: res.id}, encodeError(res.err)
-}
-
-func encodeError(err error) error {
-	if err == nil {
-		return nil
-	}
-
-	switch err {
-	case clients.ErrMalformedEntity:
-		return status.Error(codes.InvalidArgument, "received invalid can access request")
-	case clients.ErrUnauthorizedAccess:
-		return status.Error(codes.PermissionDenied, "missing or invalid credentials provided")
-	default:
-		return status.Error(codes.Internal, "internal server error")
-	}
-}

clients/api/http/doc.go

@@ -1,2 +0,0 @@
-// Package http contains implementation of clients service HTTP API.
-package http

clients/api/http/endpoint.go

@@ -1,217 +0,0 @@
-package http
-
-import (
-	"context"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/mainflux/mainflux/clients"
-)
-
-func addClientEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(addClientReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		id, err := svc.AddClient(req.key, req.client)
-		if err != nil {
-			return nil, err
-		}
-
-		return clientRes{id: id, created: true}, nil
-	}
-}
-
-func updateClientEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(updateClientReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		req.client.ID = req.id
-
-		if err := svc.UpdateClient(req.key, req.client); err != nil {
-			return nil, err
-		}
-
-		return clientRes{id: req.id, created: false}, nil
-	}
-}
-
-func viewClientEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewResourceReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		client, err := svc.ViewClient(req.key, req.id)
-		if err != nil {
-			return nil, err
-		}
-
-		return viewClientRes{client}, nil
-	}
-}
-
-func listClientsEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(listResourcesReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		clients, err := svc.ListClients(req.key, req.offset, req.limit)
-		if err != nil {
-			return nil, err
-		}
-
-		return listClientsRes{clients}, nil
-	}
-}
-
-func removeClientEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewResourceReq)
-
-		err := req.validate()
-		if err == clients.ErrNotFound {
-			return removeRes{}, nil
-		}
-
-		if err != nil {
-			return nil, err
-		}
-
-		if err = svc.RemoveClient(req.key, req.id); err != nil {
-			return nil, err
-		}
-
-		return removeRes{}, nil
-	}
-}
-
-func createChannelEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(createChannelReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		id, err := svc.CreateChannel(req.key, req.channel)
-		if err != nil {
-			return nil, err
-		}
-
-		return channelRes{id: id, created: true}, nil
-	}
-}
-
-func updateChannelEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(updateChannelReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		req.channel.ID = req.id
-
-		if err := svc.UpdateChannel(req.key, req.channel); err != nil {
-			return nil, err
-		}
-
-		return channelRes{id: req.id, created: false}, nil
-	}
-}
-
-func viewChannelEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewResourceReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		channel, err := svc.ViewChannel(req.key, req.id)
-		if err != nil {
-			return nil, err
-		}
-
-		return viewChannelRes{channel}, nil
-	}
-}
-
-func listChannelsEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(listResourcesReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		channels, err := svc.ListChannels(req.key, req.offset, req.limit)
-		if err != nil {
-			return nil, err
-		}
-
-		return listChannelsRes{channels}, nil
-	}
-}
-
-func removeChannelEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewResourceReq)
-
-		if err := req.validate(); err != nil {
-			if err == clients.ErrNotFound {
-				return removeRes{}, nil
-			}
-			return nil, err
-		}
-
-		if err := svc.RemoveChannel(req.key, req.id); err != nil {
-			return nil, err
-		}
-
-		return removeRes{}, nil
-	}
-}
-func connectEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		cr := request.(connectionReq)
-
-		if err := cr.validate(); err != nil {
-			return nil, err
-		}
-
-		if err := svc.Connect(cr.key, cr.chanID, cr.clientID); err != nil {
-			return nil, err
-		}
-
-		return connectionRes{}, nil
-	}
-}
-
-func disconnectEndpoint(svc clients.Service) endpoint.Endpoint {
-	return func(_ context.Context, request interface{}) (interface{}, error) {
-		cr := request.(connectionReq)
-
-		if err := cr.validate(); err != nil {
-			return nil, err
-		}
-
-		if err := svc.Disconnect(cr.key, cr.chanID, cr.clientID); err != nil {
-			return nil, err
-		}
-
-		return disconnectionRes{}, nil
-	}
-}

clients/api/http/endpoint_test.go

@@ -1,610 +0,0 @@
-package http_test
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/mainflux/mainflux/clients"
-	httpapi "github.com/mainflux/mainflux/clients/api/http"
-	"github.com/mainflux/mainflux/clients/mocks"
-	"github.com/stretchr/testify/assert"
-)
-
-const (
-	contentType  = "application/json"
-	invalidEmail = "userexample.com"
-	email        = "user@example.com"
-	token        = "token"
-	invalidToken = "invalid_token"
-	wrongID      = "123e4567-e89b-12d3-a456-000000000042"
-	id           = "123e4567-e89b-12d3-a456-000000000001"
-)
-
-var (
-	client  = clients.Client{Type: "app", Name: "test_app", Payload: "test_payload"}
-	channel = clients.Channel{Name: "test"}
-)
-
-type testRequest struct {
-	client      *http.Client
-	method      string
-	url         string
-	contentType string
-	token       string
-	body        io.Reader
-}
-
-func (tr testRequest) make() (*http.Response, error) {
-	req, err := http.NewRequest(tr.method, tr.url, tr.body)
-	if err != nil {
-		return nil, err
-	}
-	if tr.token != "" {
-		req.Header.Set("Authorization", tr.token)
-	}
-	if tr.contentType != "" {
-		req.Header.Set("Content-Type", tr.contentType)
-	}
-	return tr.client.Do(req)
-}
-
-func newService(tokens map[string]string) clients.Service {
-	users := mocks.NewUsersService(tokens)
-	clientsRepo := mocks.NewClientRepository()
-	channelsRepo := mocks.NewChannelRepository(clientsRepo)
-	hasher := mocks.NewHasher()
-	idp := mocks.NewIdentityProvider()
-
-	return clients.New(users, clientsRepo, channelsRepo, hasher, idp)
-}
-
-func newServer(svc clients.Service) *httptest.Server {
-	mux := httpapi.MakeHandler(svc)
-	return httptest.NewServer(mux)
-}
-
-func toJSON(data interface{}) string {
-	jsonData, _ := json.Marshal(data)
-	return string(jsonData)
-}
-
-func TestAddClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	cli := ts.Client()
-
-	data := toJSON(client)
-	invalidData := toJSON(clients.Client{
-		Type:    "foo",
-		Name:    "invalid_client",
-		Payload: "some_payload",
-	})
-
-	cases := []struct {
-		desc        string
-		req         string
-		contentType string
-		auth        string
-		status      int
-		location    string
-	}{
-		{"add valid client", data, contentType, token, http.StatusCreated, fmt.Sprintf("/clients/%s", id)},
-		{"add client with invalid data", invalidData, contentType, token, http.StatusBadRequest, ""},
-		{"add client with invalid auth token", data, contentType, invalidToken, http.StatusForbidden, ""},
-		{"add client with invalid request format", "}", contentType, token, http.StatusBadRequest, ""},
-		{"add client with empty JSON request", "{}", contentType, token, http.StatusBadRequest, ""},
-		{"add client with empty request", "", contentType, token, http.StatusBadRequest, ""},
-		{"add client with missing content type", data, "", token, http.StatusUnsupportedMediaType, ""},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client:      cli,
-			method:      http.MethodPost,
-			url:         fmt.Sprintf("%s/clients", ts.URL),
-			contentType: tc.contentType,
-			token:       tc.auth,
-			body:        strings.NewReader(tc.req),
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-
-		location := res.Header.Get("Location")
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		assert.Equal(t, tc.location, location, fmt.Sprintf("%s: expected location %s got %s", tc.desc, tc.location, location))
-	}
-}
-
-func TestUpdateClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	cli := ts.Client()
-
-	data := toJSON(client)
-	invalidData := toJSON(clients.Client{
-		Type:    "foo",
-		Name:    client.Name,
-		Payload: client.Payload,
-	})
-	id, _ := svc.AddClient(token, client)
-
-	cases := []struct {
-		desc        string
-		req         string
-		id          string
-		contentType string
-		auth        string
-		status      int
-	}{
-		{"update existing client", data, id, contentType, token, http.StatusOK},
-		{"update non-existent client", data, wrongID, contentType, token, http.StatusNotFound},
-		{"update client with invalid id", data, "1", contentType, token, http.StatusNotFound},
-		{"update client with invalid data", invalidData, id, contentType, token, http.StatusBadRequest},
-		{"update client with invalid user token", data, id, contentType, invalidToken, http.StatusForbidden},
-		{"update client with invalid data format", "{", id, contentType, token, http.StatusBadRequest},
-		{"update client with empty JSON request", "{}", id, contentType, token, http.StatusBadRequest},
-		{"update client with empty request", "", id, contentType, token, http.StatusBadRequest},
-		{"update client with missing content type", data, id, "", token, http.StatusUnsupportedMediaType},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client:      cli,
-			method:      http.MethodPut,
-			url:         fmt.Sprintf("%s/clients/%s", ts.URL, tc.id),
-			contentType: tc.contentType,
-			token:       tc.auth,
-			body:        strings.NewReader(tc.req),
-		}
-		fmt.Println(req.url)
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-	}
-}
-
-func TestViewClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	cli := ts.Client()
-
-	id, _ := svc.AddClient(token, client)
-
-	client.ID = id
-	client.Key = id
-	data := toJSON(client)
-
-	cases := []struct {
-		desc   string
-		id     string
-		auth   string
-		status int
-		res    string
-	}{
-		{"view existing client", id, token, http.StatusOK, data},
-		{"view non-existent client", wrongID, token, http.StatusNotFound, ""},
-		{"view client by passing invalid id", "1", token, http.StatusNotFound, ""},
-		{"view client by passing invalid token", id, invalidToken, http.StatusForbidden, ""},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: cli,
-			method: http.MethodGet,
-			url:    fmt.Sprintf("%s/clients/%s", ts.URL, tc.id),
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		body, err := ioutil.ReadAll(res.Body)
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		data := strings.Trim(string(body), "\n")
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		assert.Equal(t, tc.res, data, fmt.Sprintf("%s: expected body %s got %s", tc.desc, tc.res, data))
-	}
-}
-
-func TestListClients(t *testing.T) {
-	noClientsToken := "no_clients_token"
-	svc := newService(map[string]string{
-		token:          email,
-		noClientsToken: "no_clients_user@example.com",
-	})
-	ts := newServer(svc)
-	defer ts.Close()
-	cli := ts.Client()
-
-	data := []clients.Client{}
-	for i := 0; i < 101; i++ {
-		id, _ := svc.AddClient(token, client)
-		client.ID = id
-		client.Key = id
-		data = append(data, client)
-	}
-	clientURL := fmt.Sprintf("%s/clients", ts.URL)
-	cases := []struct {
-		desc   string
-		auth   string
-		status int
-		url    string
-		res    []clients.Client
-	}{
-		{"get a list of clients", token, http.StatusOK, fmt.Sprintf("%s?offset=%d&limit=%d", clientURL, 0, 5), data[0:5]},
-		{"get a list of clients with invalid token", invalidToken, http.StatusForbidden, fmt.Sprintf("%s?offset=%d&limit=%d", clientURL, 0, 1), nil},
-		{"get a list of clients with invalid offset", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", clientURL, -1, 5), nil},
-		{"get a list of clients with invalid limit", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", clientURL, 1, -5), nil},
-		{"get a list of clients with zero limit", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", clientURL, 1, 0), nil},
-		{"get a list of clients with no offset provided", token, http.StatusOK, fmt.Sprintf("%s?limit=%d", clientURL, 5), data[0:5]},
-		{"get a list of clients with no limit provided", token, http.StatusOK, fmt.Sprintf("%s?offset=%d", clientURL, 1), data[1:11]},
-		{"get a list of clients with redundant query params", token, http.StatusOK, fmt.Sprintf("%s?offset=%d&limit=%d&value=something", clientURL, 0, 5), data[0:5]},
-		{"get a list of clients with limit greater than max", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", clientURL, 0, 110), nil},
-		{"get a list of clients with default URL", token, http.StatusOK, fmt.Sprintf("%s%s", clientURL, ""), data[0:10]},
-		{"get a list of clients with invalid URL", token, http.StatusBadRequest, fmt.Sprintf("%s%s", clientURL, "?%%"), nil},
-		{"get a list of clients with invalid number of params", token, http.StatusBadRequest, fmt.Sprintf("%s%s", clientURL, "?offset=4&limit=4&limit=5&offset=5"), nil},
-		{"get a list of clients with invalid offset", token, http.StatusBadRequest, fmt.Sprintf("%s%s", clientURL, "?offset=e&limit=5"), nil},
-		{"get a list of clients with invalid limit", token, http.StatusBadRequest, fmt.Sprintf("%s%s", clientURL, "?offset=5&limit=e"), nil},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: cli,
-			method: http.MethodGet,
-			url:    tc.url,
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		var data map[string][]clients.Client
-		json.NewDecoder(res.Body).Decode(&data)
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		assert.ElementsMatch(t, tc.res, data["clients"], fmt.Sprintf("%s: expected body %s got %s", tc.desc, tc.res, data["clients"]))
-	}
-}
-
-func TestRemoveClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	cli := ts.Client()
-
-	id, _ := svc.AddClient(token, client)
-
-	cases := []struct {
-		desc   string
-		id     string
-		auth   string
-		status int
-	}{
-		{"delete existing client", id, token, http.StatusNoContent},
-		{"delete non-existent client", wrongID, token, http.StatusNoContent},
-		{"delete client with invalid id", "1", token, http.StatusNoContent},
-		{"delete client with invalid token", id, invalidToken, http.StatusForbidden},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: cli,
-			method: http.MethodDelete,
-			url:    fmt.Sprintf("%s/clients/%s", ts.URL, tc.id),
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-	}
-}
-
-func TestCreateChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	client := ts.Client()
-
-	data := toJSON(channel)
-
-	cases := []struct {
-		desc        string
-		req         string
-		contentType string
-		auth        string
-		status      int
-		location    string
-	}{
-		{"create new channel", data, contentType, token, http.StatusCreated, fmt.Sprintf("/channels/%s", id)},
-		{"create new channel with invalid token", data, contentType, invalidToken, http.StatusForbidden, ""},
-		{"create new channel with invalid data format", "{", contentType, token, http.StatusBadRequest, ""},
-		{"create new channel with empty JSON request", "{}", contentType, token, http.StatusCreated, "/channels/123e4567-e89b-12d3-a456-000000000002"},
-		{"create new channel with empty request", "", contentType, token, http.StatusBadRequest, ""},
-		{"create new channel with missing content type", data, "", token, http.StatusUnsupportedMediaType, ""},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client:      client,
-			method:      http.MethodPost,
-			url:         fmt.Sprintf("%s/channels", ts.URL),
-			contentType: tc.contentType,
-			token:       tc.auth,
-			body:        strings.NewReader(tc.req),
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-
-		location := res.Header.Get("Location")
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		assert.Equal(t, tc.location, location, fmt.Sprintf("%s: expected location %s got %s", tc.desc, tc.location, location))
-	}
-}
-
-func TestUpdateChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	client := ts.Client()
-
-	updateData := toJSON(map[string]string{
-		"name": "updated_channel",
-	})
-	id, _ := svc.CreateChannel(token, channel)
-
-	cases := []struct {
-		desc        string
-		req         string
-		id          string
-		contentType string
-		auth        string
-		status      int
-	}{
-		{"update existing channel", updateData, id, contentType, token, http.StatusOK},
-		{"update non-existing channel", updateData, wrongID, contentType, token, http.StatusNotFound},
-		{"update channel with invalid token", updateData, id, contentType, invalidToken, http.StatusForbidden},
-		{"update channel with invalid id", updateData, "1", contentType, token, http.StatusNotFound},
-		{"update channel with invalid data format", "}", id, contentType, token, http.StatusBadRequest},
-		{"update channel with empty JSON object", "{}", id, contentType, token, http.StatusOK},
-		{"update channel with empty request", "", id, contentType, token, http.StatusBadRequest},
-		{"update channel with missing content type", updateData, id, "", token, http.StatusUnsupportedMediaType},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client:      client,
-			method:      http.MethodPut,
-			url:         fmt.Sprintf("%s/channels/%s", ts.URL, tc.id),
-			contentType: tc.contentType,
-			token:       tc.auth,
-			body:        strings.NewReader(tc.req),
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-	}
-}
-
-func TestViewChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	client := ts.Client()
-
-	id, _ := svc.CreateChannel(token, channel)
-	channel.ID = id
-	data := toJSON(channel)
-
-	cases := []struct {
-		desc   string
-		id     string
-		auth   string
-		status int
-		res    string
-	}{
-		{"view existing channel", id, token, http.StatusOK, data},
-		{"view non-existent channel", wrongID, token, http.StatusNotFound, ""},
-		{"view channel with invalid id", "1", token, http.StatusNotFound, ""},
-		{"view channel with invalid token", id, invalidToken, http.StatusForbidden, ""},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: client,
-			method: http.MethodGet,
-			url:    fmt.Sprintf("%s/channels/%s", ts.URL, tc.id),
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		data, err := ioutil.ReadAll(res.Body)
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		body := strings.Trim(string(data), "\n")
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		assert.Equal(t, tc.res, body, fmt.Sprintf("%s: expected body %s got %s", tc.desc, tc.res, body))
-	}
-}
-
-func TestListChannels(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	client := ts.Client()
-
-	channels := []clients.Channel{}
-	for i := 0; i < 101; i++ {
-		id, _ := svc.CreateChannel(token, channel)
-		channel.ID = id
-		channels = append(channels, channel)
-	}
-	channelURL := fmt.Sprintf("%s/channels", ts.URL)
-
-	cases := []struct {
-		desc   string
-		auth   string
-		status int
-		url    string
-		res    []clients.Channel
-	}{
-		{"get a list of channels", token, http.StatusOK, fmt.Sprintf("%s?offset=%d&limit=%d", channelURL, 0, 6), channels[0:6]},
-		{"get a list of channels with invalid token", invalidToken, http.StatusForbidden, fmt.Sprintf("%s?offset=%d&limit=%d", channelURL, 0, 1), nil},
-		{"get a list of channels with invalid offset", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", channelURL, -1, 5), nil},
-		{"get a list of channels with invalid limit", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", channelURL, -1, 5), nil},
-		{"get a list of channels with zero limit", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", channelURL, 1, 0), nil},
-		{"get a list of channels with no offset provided", token, http.StatusOK, fmt.Sprintf("%s?limit=%d", channelURL, 5), channels[0:5]},
-		{"get a list of channels with no limit provided", token, http.StatusOK, fmt.Sprintf("%s?offset=%d", channelURL, 1), channels[1:11]},
-		{"get a list of channels with redundant query params", token, http.StatusOK, fmt.Sprintf("%s?offset=%d&limit=%d&value=something", channelURL, 0, 5), channels[0:5]},
-		{"get a list of channels with limit greater than max", token, http.StatusBadRequest, fmt.Sprintf("%s?offset=%d&limit=%d", channelURL, 0, 110), nil},
-		{"get a list of channels with default URL", token, http.StatusOK, fmt.Sprintf("%s%s", channelURL, ""), channels[0:10]},
-		{"get a list of channels with invalid URL", token, http.StatusBadRequest, fmt.Sprintf("%s%s", channelURL, "?%%"), nil},
-		{"get a list of channels with invalid number of params", token, http.StatusBadRequest, fmt.Sprintf("%s%s", channelURL, "?offset=4&limit=4&limit=5&offset=5"), nil},
-		{"get a list of channels with invalid offset", token, http.StatusBadRequest, fmt.Sprintf("%s%s", channelURL, "?offset=e&limit=5"), nil},
-		{"get a list of channels with invalid limit", token, http.StatusBadRequest, fmt.Sprintf("%s%s", channelURL, "?offset=5&limit=e"), nil},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: client,
-			method: http.MethodGet,
-			url:    tc.url,
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		var body map[string][]clients.Channel
-		json.NewDecoder(res.Body).Decode(&body)
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-		assert.ElementsMatch(t, tc.res, body["channels"], fmt.Sprintf("%s: expected body %s got %s", tc.desc, tc.res, body["channels"]))
-	}
-}
-
-func TestRemoveChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	ts := newServer(svc)
-	defer ts.Close()
-	client := ts.Client()
-
-	id, _ := svc.CreateChannel(token, channel)
-	channel.ID = id
-
-	cases := []struct {
-		desc   string
-		id     string
-		auth   string
-		status int
-	}{
-		{"remove existing channel", channel.ID, token, http.StatusNoContent},
-		{"remove non-existent channel", channel.ID, token, http.StatusNoContent},
-		{"remove channel with invalid id", wrongID, token, http.StatusNoContent},
-		{"remove channel with invalid token", channel.ID, "invalidToken", http.StatusForbidden},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: client,
-			method: http.MethodDelete,
-			url:    fmt.Sprintf("%s/channels/%s", ts.URL, tc.id),
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-	}
-}
-
-func TestConnect(t *testing.T) {
-	otherToken := "other_token"
-	otherEmail := "other_user@example.com"
-	svc := newService(map[string]string{
-		token:      email,
-		otherToken: otherEmail,
-	})
-	ts := newServer(svc)
-	defer ts.Close()
-	cli := ts.Client()
-
-	clientID, _ := svc.AddClient(token, client)
-	chanID, _ := svc.CreateChannel(token, channel)
-
-	otherClientID, _ := svc.AddClient(otherToken, client)
-	otherChanID, _ := svc.CreateChannel(otherToken, channel)
-
-	cases := []struct {
-		desc     string
-		chanID   string
-		clientID string
-		auth     string
-		status   int
-	}{
-		{"connect existing client to existing channel", chanID, clientID, token, http.StatusOK},
-		{"connect existing client to non-existent channel", wrongID, clientID, token, http.StatusNotFound},
-		{"connect client with invalid id to channel", chanID, "1", token, http.StatusNotFound},
-		{"connect client to channel with invalid id", "1", clientID, token, http.StatusNotFound},
-		{"connect existing client to existing channel with invalid token", chanID, clientID, invalidToken, http.StatusForbidden},
-		{"connect client from owner to channel of other user", otherChanID, clientID, token, http.StatusNotFound},
-		{"connect client from other user to owner's channel", chanID, otherClientID, token, http.StatusNotFound},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: cli,
-			method: http.MethodPut,
-			url:    fmt.Sprintf("%s/channels/%s/clients/%s", ts.URL, tc.chanID, tc.clientID),
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-	}
-}
-
-func TestDisconnnect(t *testing.T) {
-	otherToken := "other_token"
-	otherEmail := "other_user@example.com"
-	svc := newService(map[string]string{
-		token:      email,
-		otherToken: otherEmail,
-	})
-	ts := newServer(svc)
-	defer ts.Close()
-	cli := ts.Client()
-
-	clientID, _ := svc.AddClient(token, client)
-	chanID, _ := svc.CreateChannel(token, channel)
-	svc.Connect(token, chanID, clientID)
-	otherClientID, _ := svc.AddClient(otherToken, client)
-	otherChanID, _ := svc.CreateChannel(otherToken, channel)
-	svc.Connect(otherToken, otherChanID, otherClientID)
-
-	cases := []struct {
-		desc     string
-		chanID   string
-		clientID string
-		auth     string
-		status   int
-	}{
-		{"disconnect connected client from channel", chanID, clientID, token, http.StatusNoContent},
-		{"disconnect non-connected client from channel", chanID, clientID, token, http.StatusNotFound},
-		{"disconnect non-existent client from channel", chanID, "1", token, http.StatusNotFound},
-		{"disconnect client from non-existent channel", "1", clientID, token, http.StatusNotFound},
-		{"disconnect client from channel with invalid token", chanID, clientID, invalidToken, http.StatusForbidden},
-		{"disconnect owner's client from someone elses channel", otherChanID, clientID, token, http.StatusNotFound},
-		{"disconnect other's client from owner's channel", chanID, otherClientID, token, http.StatusNotFound},
-	}
-
-	for _, tc := range cases {
-		req := testRequest{
-			client: cli,
-			method: http.MethodDelete,
-			url:    fmt.Sprintf("%s/channels/%s/clients/%s", ts.URL, tc.chanID, tc.clientID),
-			token:  tc.auth,
-		}
-		res, err := req.make()
-		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err))
-		assert.Equal(t, tc.status, res.StatusCode, fmt.Sprintf("%s: expected status code %d got %d", tc.desc, tc.status, res.StatusCode))
-	}
-}

clients/api/http/requests.go

@@ -1,139 +0,0 @@
-package http
-
-import (
-	"github.com/asaskevich/govalidator"
-	"github.com/mainflux/mainflux/clients"
-)
-
-const maxLimitSize = 100
-
-type apiReq interface {
-	validate() error
-}
-
-type identityReq struct {
-	key string
-}
-
-func (req identityReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	return nil
-}
-
-type addClientReq struct {
-	key    string
-	client clients.Client
-}
-
-func (req addClientReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	return req.client.Validate()
-}
-
-type updateClientReq struct {
-	key    string
-	id     string
-	client clients.Client
-}
-
-func (req updateClientReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	if !govalidator.IsUUID(req.id) {
-		return clients.ErrNotFound
-	}
-
-	return req.client.Validate()
-}
-
-type createChannelReq struct {
-	key     string
-	channel clients.Channel
-}
-
-func (req createChannelReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	return nil
-}
-
-type updateChannelReq struct {
-	key     string
-	id      string
-	channel clients.Channel
-}
-
-func (req updateChannelReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	if !govalidator.IsUUID(req.id) {
-		return clients.ErrNotFound
-	}
-
-	return nil
-}
-
-type viewResourceReq struct {
-	key string
-	id  string
-}
-
-func (req viewResourceReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	if !govalidator.IsUUID(req.id) {
-		return clients.ErrNotFound
-	}
-
-	return nil
-}
-
-type listResourcesReq struct {
-	key    string
-	offset int
-	limit  int
-}
-
-func (req *listResourcesReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	if req.offset >= 0 && req.limit > 0 && req.limit <= maxLimitSize {
-		return nil
-	}
-
-	return clients.ErrMalformedEntity
-}
-
-type connectionReq struct {
-	key      string
-	chanID   string
-	clientID string
-}
-
-func (req connectionReq) validate() error {
-	if req.key == "" {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	if !govalidator.IsUUID(req.chanID) || !govalidator.IsUUID(req.clientID) {
-		return clients.ErrNotFound
-	}
-
-	return nil
-}

clients/api/http/requests_test.go

@@ -1,186 +0,0 @@
-package http
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/mainflux/mainflux/clients"
-	uuid "github.com/satori/go.uuid"
-	"github.com/stretchr/testify/assert"
-)
-
-const wrong string = "?"
-
-var (
-	client  = clients.Client{Type: "app"}
-	channel = clients.Channel{}
-)
-
-func TestIdentityReqValidation(t *testing.T) {
-	cases := map[string]struct {
-		key string
-		err error
-	}{
-		"non-empty token": {uuid.NewV4().String(), nil},
-		"empty token":     {"", clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		req := identityReq{tc.key}
-		err := req.validate()
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestAddClientReqValidation(t *testing.T) {
-	key := uuid.NewV4().String()
-
-	cases := map[string]struct {
-		client clients.Client
-		key    string
-		err    error
-	}{
-		"valid client addition request": {client, key, nil},
-		"missing token":                 {client, "", clients.ErrUnauthorizedAccess},
-		"wrong client type":             {clients.Client{Type: wrong}, key, clients.ErrMalformedEntity},
-	}
-
-	for desc, tc := range cases {
-		req := addClientReq{
-			key:    tc.key,
-			client: tc.client,
-		}
-
-		err := req.validate()
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestUpdateClientReqValidation(t *testing.T) {
-	key := uuid.NewV4().String()
-	id := uuid.NewV4().String()
-
-	cases := map[string]struct {
-		client clients.Client
-		id     string
-		key    string
-		err    error
-	}{
-		"valid client update request": {client, id, key, nil},
-		"non-uuid client ID":          {client, wrong, key, clients.ErrNotFound},
-		"missing token":               {client, id, "", clients.ErrUnauthorizedAccess},
-		"wrong client type":           {clients.Client{Type: "invalid"}, id, key, clients.ErrMalformedEntity},
-	}
-
-	for desc, tc := range cases {
-		req := updateClientReq{
-			key:    tc.key,
-			id:     tc.id,
-			client: tc.client,
-		}
-
-		err := req.validate()
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestCreateChannelReqValidation(t *testing.T) {
-	key := uuid.NewV4().String()
-
-	cases := map[string]struct {
-		channel clients.Channel
-		key     string
-		err     error
-	}{
-		"valid channel creation request": {channel, key, nil},
-		"missing token":                  {channel, "", clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		req := createChannelReq{
-			key:     tc.key,
-			channel: tc.channel,
-		}
-
-		err := req.validate()
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestUpdateChannelReqValidation(t *testing.T) {
-	key := uuid.NewV4().String()
-	id := uuid.NewV4().String()
-
-	cases := map[string]struct {
-		channel clients.Channel
-		id      string
-		key     string
-		err     error
-	}{
-		"valid channel update request": {channel, id, key, nil},
-		"non-uuid channel ID":          {channel, wrong, key, clients.ErrNotFound},
-		"missing token":                {channel, id, "", clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		req := updateChannelReq{
-			key:     tc.key,
-			id:      tc.id,
-			channel: tc.channel,
-		}
-
-		err := req.validate()
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestViewResourceReqValidation(t *testing.T) {
-	key := uuid.NewV4().String()
-	id := uuid.NewV4().String()
-
-	cases := map[string]struct {
-		id  string
-		key string
-		err error
-	}{
-		"valid resource viewing request": {id, key, nil},
-		"missing token":                  {id, "", clients.ErrUnauthorizedAccess},
-		"non-uuid resource ID":           {wrong, key, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		req := viewResourceReq{tc.key, tc.id}
-		err := req.validate()
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestListResourcesReqValidation(t *testing.T) {
-	key := uuid.NewV4().String()
-	value := 10
-
-	cases := map[string]struct {
-		key    string
-		offset int
-		limit  int
-		err    error
-	}{
-		"valid listing request": {key, value, value, nil},
-		"missing token":         {"", value, value, clients.ErrUnauthorizedAccess},
-		"negative offset":       {key, -value, value, clients.ErrMalformedEntity},
-		"zero limit":            {key, value, 0, clients.ErrMalformedEntity},
-		"negative limit":        {key, value, -value, clients.ErrMalformedEntity},
-		"too big limit":         {key, value, 20 * value, clients.ErrMalformedEntity},
-	}
-
-	for desc, tc := range cases {
-		req := listResourcesReq{
-			key:    tc.key,
-			offset: tc.offset,
-			limit:  tc.limit,
-		}
-
-		err := req.validate()
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}

clients/api/http/transport.go

@@ -1,301 +0,0 @@
-package http
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-
-	kithttp "github.com/go-kit/kit/transport/http"
-	"github.com/go-zoo/bone"
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/clients"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-)
-
-const contentType = "application/json"
-
-var (
-	errUnsupportedContentType = errors.New("unsupported content type")
-	errInvalidQueryParams     = errors.New("invalid query params")
-)
-
-// MakeHandler returns a HTTP handler for API endpoints.
-func MakeHandler(svc clients.Service) http.Handler {
-	opts := []kithttp.ServerOption{
-		kithttp.ServerErrorEncoder(encodeError),
-	}
-
-	r := bone.New()
-
-	r.Post("/clients", kithttp.NewServer(
-		addClientEndpoint(svc),
-		decodeClientCreation,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Put("/clients/:id", kithttp.NewServer(
-		updateClientEndpoint(svc),
-		decodeClientUpdate,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Delete("/clients/:id", kithttp.NewServer(
-		removeClientEndpoint(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Get("/clients/:id", kithttp.NewServer(
-		viewClientEndpoint(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Get("/clients", kithttp.NewServer(
-		listClientsEndpoint(svc),
-		decodeList,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Post("/channels", kithttp.NewServer(
-		createChannelEndpoint(svc),
-		decodeChannelCreation,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Put("/channels/:id", kithttp.NewServer(
-		updateChannelEndpoint(svc),
-		decodeChannelUpdate,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Delete("/channels/:id", kithttp.NewServer(
-		removeChannelEndpoint(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Get("/channels/:id", kithttp.NewServer(
-		viewChannelEndpoint(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Get("/channels", kithttp.NewServer(
-		listChannelsEndpoint(svc),
-		decodeList,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Put("/channels/:chanId/clients/:clientId", kithttp.NewServer(
-		connectEndpoint(svc),
-		decodeConnection,
-		encodeResponse,
-		opts...,
-	))
-
-	r.Delete("/channels/:chanId/clients/:clientId", kithttp.NewServer(
-		disconnectEndpoint(svc),
-		decodeConnection,
-		encodeResponse,
-		opts...,
-	))
-
-	r.GetFunc("/version", mainflux.Version("clients"))
-	r.Handle("/metrics", promhttp.Handler())
-
-	return r
-}
-
-func decodeClientCreation(_ context.Context, r *http.Request) (interface{}, error) {
-	if r.Header.Get("Content-Type") != contentType {
-		return nil, errUnsupportedContentType
-	}
-
-	var client clients.Client
-	if err := json.NewDecoder(r.Body).Decode(&client); err != nil {
-		return nil, err
-	}
-
-	req := addClientReq{
-		key:    r.Header.Get("Authorization"),
-		client: client,
-	}
-
-	return req, nil
-}
-
-func decodeClientUpdate(_ context.Context, r *http.Request) (interface{}, error) {
-	if r.Header.Get("Content-Type") != contentType {
-		return nil, errUnsupportedContentType
-	}
-
-	var client clients.Client
-	if err := json.NewDecoder(r.Body).Decode(&client); err != nil {
-		return nil, err
-	}
-
-	req := updateClientReq{
-		key:    r.Header.Get("Authorization"),
-		id:     bone.GetValue(r, "id"),
-		client: client,
-	}
-
-	return req, nil
-}
-
-func decodeChannelCreation(_ context.Context, r *http.Request) (interface{}, error) {
-	if r.Header.Get("Content-Type") != contentType {
-		return nil, errUnsupportedContentType
-	}
-
-	var channel clients.Channel
-	if err := json.NewDecoder(r.Body).Decode(&channel); err != nil {
-		return nil, err
-	}
-
-	req := createChannelReq{
-		key:     r.Header.Get("Authorization"),
-		channel: channel,
-	}
-
-	return req, nil
-}
-
-func decodeChannelUpdate(_ context.Context, r *http.Request) (interface{}, error) {
-	if r.Header.Get("Content-Type") != contentType {
-		return nil, errUnsupportedContentType
-	}
-
-	var channel clients.Channel
-	if err := json.NewDecoder(r.Body).Decode(&channel); err != nil {
-		return nil, err
-	}
-
-	req := updateChannelReq{
-		key:     r.Header.Get("Authorization"),
-		id:      bone.GetValue(r, "id"),
-		channel: channel,
-	}
-
-	return req, nil
-}
-
-func decodeView(_ context.Context, r *http.Request) (interface{}, error) {
-	req := viewResourceReq{
-		key: r.Header.Get("Authorization"),
-		id:  bone.GetValue(r, "id"),
-	}
-
-	return req, nil
-}
-
-func decodeList(_ context.Context, r *http.Request) (interface{}, error) {
-	q, err := url.ParseQuery(r.URL.RawQuery)
-	if err != nil {
-		return nil, errInvalidQueryParams
-	}
-	offset := 0
-	limit := 10
-
-	off, lmt := q["offset"], q["limit"]
-
-	if len(off) > 1 || len(lmt) > 1 {
-		return nil, errInvalidQueryParams
-	}
-
-	if len(off) == 1 {
-		offset, err = strconv.Atoi(off[0])
-		if err != nil {
-			return nil, errInvalidQueryParams
-		}
-	}
-
-	if len(lmt) == 1 {
-		limit, err = strconv.Atoi(lmt[0])
-		if err != nil {
-			return nil, errInvalidQueryParams
-		}
-	}
-	req := listResourcesReq{
-		key:    r.Header.Get("Authorization"),
-		offset: offset,
-		limit:  limit,
-	}
-
-	return req, nil
-}
-
-func decodeConnection(_ context.Context, r *http.Request) (interface{}, error) {
-	req := connectionReq{
-		key:      r.Header.Get("Authorization"),
-		chanID:   bone.GetValue(r, "chanId"),
-		clientID: bone.GetValue(r, "clientId"),
-	}
-
-	return req, nil
-}
-
-func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
-	w.Header().Set("Content-Type", contentType)
-
-	if ar, ok := response.(mainflux.Response); ok {
-		for k, v := range ar.Headers() {
-			w.Header().Set(k, v)
-		}
-
-		w.WriteHeader(ar.Code())
-
-		if ar.Empty() {
-			return nil
-		}
-	}
-
-	return json.NewEncoder(w).Encode(response)
-}
-
-func encodeError(_ context.Context, err error, w http.ResponseWriter) {
-	w.Header().Set("Content-Type", contentType)
-
-	switch err {
-	case clients.ErrMalformedEntity:
-		w.WriteHeader(http.StatusBadRequest)
-	case clients.ErrUnauthorizedAccess:
-		w.WriteHeader(http.StatusForbidden)
-	case clients.ErrNotFound:
-		w.WriteHeader(http.StatusNotFound)
-	case clients.ErrConflict:
-		w.WriteHeader(http.StatusConflict)
-	case errUnsupportedContentType:
-		w.WriteHeader(http.StatusUnsupportedMediaType)
-	case errInvalidQueryParams:
-		w.WriteHeader(http.StatusBadRequest)
-	case io.ErrUnexpectedEOF:
-		w.WriteHeader(http.StatusBadRequest)
-	case io.EOF:
-		w.WriteHeader(http.StatusBadRequest)
-	default:
-		switch err.(type) {
-		case *json.SyntaxError:
-			w.WriteHeader(http.StatusBadRequest)
-		case *json.UnmarshalTypeError:
-			w.WriteHeader(http.StatusBadRequest)
-		default:
-			w.WriteHeader(http.StatusInternalServerError)
-		}
-	}
-}

clients/api/logging.go

@@ -1,192 +0,0 @@
-// +build !test
-
-package api
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/mainflux/mainflux/clients"
-	log "github.com/mainflux/mainflux/logger"
-)
-
-var _ clients.Service = (*loggingMiddleware)(nil)
-
-type loggingMiddleware struct {
-	logger log.Logger
-	svc    clients.Service
-}
-
-// LoggingMiddleware adds logging facilities to the core service.
-func LoggingMiddleware(svc clients.Service, logger log.Logger) clients.Service {
-	return &loggingMiddleware{logger, svc}
-}
-
-func (lm *loggingMiddleware) AddClient(key string, client clients.Client) (id string, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method add_client for key %s and client %s took %s to complete", key, id, 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.AddClient(key, client)
-}
-
-func (lm *loggingMiddleware) UpdateClient(key string, client clients.Client) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method update_client for key %s and client %s took %s to complete", key, client.ID, 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.UpdateClient(key, client)
-}
-
-func (lm *loggingMiddleware) ViewClient(key string, id string) (client clients.Client, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method view_client for key %s and client %s took %s to complete", key, id, 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.ViewClient(key, id)
-}
-
-func (lm *loggingMiddleware) ListClients(key string, offset, limit int) (clients []clients.Client, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method list_clients for key %s took %s to complete", key, 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.ListClients(key, offset, limit)
-}
-
-func (lm *loggingMiddleware) RemoveClient(key string, id string) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method remove_client for key %s and client %s took %s to complete", key, id, 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.RemoveClient(key, id)
-}
-
-func (lm *loggingMiddleware) CreateChannel(key string, channel clients.Channel) (id string, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method create_channel for key %s and channel %s took %s to complete", key, id, 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.CreateChannel(key, channel)
-}
-
-func (lm *loggingMiddleware) UpdateChannel(key string, channel clients.Channel) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method update_channel for key %s and channel %s took %s to complete", key, channel.ID, 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.UpdateChannel(key, channel)
-}
-
-func (lm *loggingMiddleware) ViewChannel(key string, id string) (channel clients.Channel, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method view_channel for key %s and channel %s took %s to complete", key, id, 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.ViewChannel(key, id)
-}
-
-func (lm *loggingMiddleware) ListChannels(key string, offset, limit int) (channels []clients.Channel, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method list_channels for key %s took %s to complete", key, 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.ListChannels(key, offset, limit)
-}
-
-func (lm *loggingMiddleware) RemoveChannel(key string, id string) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method remove_channel for key %s and channel %s took %s to complete", key, id, 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.RemoveChannel(key, id)
-}
-
-func (lm *loggingMiddleware) Connect(key, chanID, clientID string) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method connect for key %s, channel %s, client %s took %s to complete", key, chanID, clientID, 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.Connect(key, chanID, clientID)
-}
-
-func (lm *loggingMiddleware) Disconnect(key, chanID, clientID string) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method disconnect for key %s, channel %s, client %s took %s to complete", key, chanID, clientID, 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.Disconnect(key, chanID, clientID)
-}
-
-func (lm *loggingMiddleware) CanAccess(key string, id string) (pub string, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method can_access for key %s, channel %s and publisher %s took %s to complete", key, id, pub, 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.CanAccess(key, id)
-}

clients/api/metrics.go

@@ -1,145 +0,0 @@
-// +build !test
-
-package api
-
-import (
-	"time"
-
-	"github.com/go-kit/kit/metrics"
-	"github.com/mainflux/mainflux/clients"
-)
-
-var _ clients.Service = (*metricsMiddleware)(nil)
-
-type metricsMiddleware struct {
-	counter metrics.Counter
-	latency metrics.Histogram
-	svc     clients.Service
-}
-
-// MetricsMiddleware instruments core service by tracking request count and
-// latency.
-func MetricsMiddleware(svc clients.Service, counter metrics.Counter, latency metrics.Histogram) clients.Service {
-	return &metricsMiddleware{
-		counter: counter,
-		latency: latency,
-		svc:     svc,
-	}
-}
-
-func (ms *metricsMiddleware) AddClient(key string, client clients.Client) (string, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "add_client").Add(1)
-		ms.latency.With("method", "add_client").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.AddClient(key, client)
-}
-
-func (ms *metricsMiddleware) UpdateClient(key string, client clients.Client) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "update_client").Add(1)
-		ms.latency.With("method", "update_client").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.UpdateClient(key, client)
-}
-
-func (ms *metricsMiddleware) ViewClient(key string, id string) (clients.Client, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "view_client").Add(1)
-		ms.latency.With("method", "view_client").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.ViewClient(key, id)
-}
-
-func (ms *metricsMiddleware) ListClients(key string, offset, limit int) ([]clients.Client, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "list_clients").Add(1)
-		ms.latency.With("method", "list_clients").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.ListClients(key, offset, limit)
-}
-
-func (ms *metricsMiddleware) RemoveClient(key string, id string) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "remove_client").Add(1)
-		ms.latency.With("method", "remove_client").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.RemoveClient(key, id)
-}
-
-func (ms *metricsMiddleware) CreateChannel(key string, channel clients.Channel) (string, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "create_channel").Add(1)
-		ms.latency.With("method", "create_channel").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.CreateChannel(key, channel)
-}
-
-func (ms *metricsMiddleware) UpdateChannel(key string, channel clients.Channel) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "update_channel").Add(1)
-		ms.latency.With("method", "update_channel").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.UpdateChannel(key, channel)
-}
-
-func (ms *metricsMiddleware) ViewChannel(key string, id string) (clients.Channel, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "view_channel").Add(1)
-		ms.latency.With("method", "view_channel").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.ViewChannel(key, id)
-}
-
-func (ms *metricsMiddleware) ListChannels(key string, offset, limit int) ([]clients.Channel, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "list_channels").Add(1)
-		ms.latency.With("method", "list_channels").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.ListChannels(key, offset, limit)
-}
-
-func (ms *metricsMiddleware) RemoveChannel(key string, id string) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "remove_channel").Add(1)
-		ms.latency.With("method", "remove_channel").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.RemoveChannel(key, id)
-}
-
-func (ms *metricsMiddleware) Connect(key, chanID, clientID string) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "connect").Add(1)
-		ms.latency.With("method", "connect").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.Connect(key, chanID, clientID)
-}
-
-func (ms *metricsMiddleware) Disconnect(key, chanID, clientID string) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "disconnect").Add(1)
-		ms.latency.With("method", "disconnect").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.Disconnect(key, chanID, clientID)
-}
-
-func (ms *metricsMiddleware) CanAccess(key string, id string) (string, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "can_access").Add(1)
-		ms.latency.With("method", "can_access").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.CanAccess(key, id)
-}

clients/bcrypt/hasher.go

@@ -1,31 +0,0 @@
-// Package bcrypt provides a hasher implementation utilising bcrypt.
-package bcrypt
-
-import (
-	"github.com/mainflux/mainflux/clients"
-	"golang.org/x/crypto/bcrypt"
-)
-
-const cost int = 10
-
-var _ clients.Hasher = (*bcryptHasher)(nil)
-
-type bcryptHasher struct{}
-
-// New instantiates a bcrypt-based hasher implementation.
-func New() clients.Hasher {
-	return &bcryptHasher{}
-}
-
-func (bh *bcryptHasher) Hash(pwd string) (string, error) {
-	hash, err := bcrypt.GenerateFromPassword([]byte(pwd), cost)
-	if err != nil {
-		return "", err
-	}
-
-	return string(hash), nil
-}
-
-func (bh *bcryptHasher) Compare(plain, hashed string) error {
-	return bcrypt.CompareHashAndPassword([]byte(hashed), []byte(plain))
-}

clients/channels.go

@@ -1,44 +0,0 @@
-package clients
-
-// Channel represents a Mainflux "communication group". This group contains the
-// clients that can exchange messages between eachother.
-type Channel struct {
-	ID      string   `json:"id"`
-	Owner   string   `json:"-"`
-	Name    string   `json:"name,omitempty"`
-	Clients []Client `json:"connected,omitempty"`
-}
-
-// ChannelRepository specifies a channel persistence API.
-type ChannelRepository interface {
-	// Save persists the channel. Successful operation is indicated by unique
-	// identifier accompanied by nil error response. A non-nil error is
-	// returned to indicate operation failure.
-	Save(Channel) (string, error)
-
-	// Update performs an update to the existing channel. A non-nil error is
-	// returned to indicate operation failure.
-	Update(Channel) error
-
-	// One retrieves the channel having the provided identifier, that is owned
-	// by the specified user.
-	One(string, string) (Channel, error)
-
-	// All retrieves the subset of channels owned by the specified user.
-	All(string, int, int) []Channel
-
-	// Remove removes the channel having the provided identifier, that is owned
-	// by the specified user.
-	Remove(string, string) error
-
-	// Connect adds client to the channel's list of connected clients.
-	Connect(string, string, string) error
-
-	// Disconnect removes client from the channel's list of connected
-	// clients.
-	Disconnect(string, string, string) error
-
-	// HasClient determines whether the client with the provided identifier, is
-	// "connected" to the specified channel.
-	HasClient(string, string) bool
-}

clients/clients.go

@@ -1,53 +0,0 @@
-package clients
-
-import "strings"
-
-// Client represents a Mainflux client. Each client is owned by one user, and
-// it is assigned with the unique identifier and (temporary) access key.
-type Client struct {
-	ID      string `json:"id"`
-	Owner   string `json:"-"`
-	Type    string `json:"type"`
-	Name    string `json:"name,omitempty"`
-	Key     string `json:"key"`
-	Payload string `json:"payload,omitempty"`
-}
-
-var clientTypes = map[string]bool{
-	"app":    true,
-	"device": true,
-}
-
-// Validate returns an error if client representation is invalid.
-func (c *Client) Validate() error {
-	if c.Type = strings.ToLower(c.Type); !clientTypes[c.Type] {
-		return ErrMalformedEntity
-	}
-
-	return nil
-}
-
-// ClientRepository specifies a client persistence API.
-type ClientRepository interface {
-	// ID generates new resource identifier.
-	ID() string
-
-	// Save persists the client. Successful operation is indicated by non-nil
-	// error response.
-	Save(Client) error
-
-	// Update performs an update to the existing client. A non-nil error is
-	// returned to indicate operation failure.
-	Update(Client) error
-
-	// One retrieves the client having the provided identifier, that is owned
-	// by the specified user.
-	One(string, string) (Client, error)
-
-	// All retrieves the subset of clients owned by the specified user.
-	All(string, int, int) []Client
-
-	// Remove removes the client having the provided identifier, that is owned
-	// by the specified user.
-	Remove(string, string) error
-}

clients/doc.go

@@ -1,3 +0,0 @@
-// Package clients contains the domain concept definitions needed to support
-// Mainflux clients service functionality.
-package clients

clients/jwt/idp.go

@@ -1,74 +0,0 @@
-// Package jwt provides a JWT identity provider.
-package jwt
-
-import (
-	"time"
-
-	jwt "github.com/dgrijalva/jwt-go"
-	"github.com/mainflux/mainflux/clients"
-)
-
-const (
-	issuer   string        = "mainflux"
-	duration time.Duration = 10 * time.Hour
-)
-
-var _ clients.IdentityProvider = (*jwtIdentityProvider)(nil)
-
-type jwtIdentityProvider struct {
-	secret string
-}
-
-// New instantiates a JWT identity provider.
-func New(secret string) clients.IdentityProvider {
-	return &jwtIdentityProvider{secret}
-}
-
-func (idp *jwtIdentityProvider) TemporaryKey(id string) (string, error) {
-	now := time.Now().UTC()
-	exp := now.Add(duration)
-
-	claims := jwt.StandardClaims{
-		Subject:   id,
-		Issuer:    issuer,
-		IssuedAt:  now.Unix(),
-		ExpiresAt: exp.Unix(),
-	}
-
-	return idp.jwt(claims)
-}
-
-func (idp *jwtIdentityProvider) PermanentKey(id string) (string, error) {
-	claims := jwt.StandardClaims{
-		Subject:  id,
-		Issuer:   issuer,
-		IssuedAt: time.Now().UTC().Unix(),
-	}
-
-	return idp.jwt(claims)
-}
-
-func (idp *jwtIdentityProvider) jwt(claims jwt.StandardClaims) (string, error) {
-	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	return token.SignedString([]byte(idp.secret))
-}
-
-func (idp *jwtIdentityProvider) Identity(key string) (string, error) {
-	token, err := jwt.Parse(key, func(token *jwt.Token) (interface{}, error) {
-		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, clients.ErrUnauthorizedAccess
-		}
-
-		return []byte(idp.secret), nil
-	})
-
-	if err != nil {
-		return "", clients.ErrUnauthorizedAccess
-	}
-
-	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
-		return claims["sub"].(string), nil
-	}
-
-	return "", clients.ErrUnauthorizedAccess
-}

clients/mocks/channels.go

@@ -1,144 +0,0 @@
-package mocks
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/mainflux/mainflux/clients"
-)
-
-var _ clients.ChannelRepository = (*channelRepositoryMock)(nil)
-
-const chanID = "123e4567-e89b-12d3-a456-"
-
-type channelRepositoryMock struct {
-	mu       sync.Mutex
-	counter  int
-	channels map[string]clients.Channel
-	clients  clients.ClientRepository
-}
-
-// NewChannelRepository creates in-memory channel repository.
-func NewChannelRepository(repo clients.ClientRepository) clients.ChannelRepository {
-	return &channelRepositoryMock{
-		channels: make(map[string]clients.Channel),
-		clients:  repo,
-	}
-}
-
-func (crm *channelRepositoryMock) Save(channel clients.Channel) (string, error) {
-	crm.mu.Lock()
-	defer crm.mu.Unlock()
-
-	crm.counter++
-	channel.ID = fmt.Sprintf("%s%012d", chanID, crm.counter)
-
-	crm.channels[key(channel.Owner, channel.ID)] = channel
-
-	return channel.ID, nil
-}
-
-func (crm *channelRepositoryMock) Update(channel clients.Channel) error {
-	crm.mu.Lock()
-	defer crm.mu.Unlock()
-
-	dbKey := key(channel.Owner, channel.ID)
-
-	if _, ok := crm.channels[dbKey]; !ok {
-		return clients.ErrNotFound
-	}
-
-	crm.channels[dbKey] = channel
-	return nil
-}
-
-func (crm *channelRepositoryMock) One(owner, id string) (clients.Channel, error) {
-	if c, ok := crm.channels[key(owner, id)]; ok {
-		return c, nil
-	}
-
-	return clients.Channel{}, clients.ErrNotFound
-}
-
-func (crm *channelRepositoryMock) All(owner string, offset, limit int) []clients.Channel {
-	// This obscure way to examine map keys is enforced by the key structure
-	// itself (see mocks/commons.go).
-	prefix := fmt.Sprintf("%s-", owner)
-	channels := make([]clients.Channel, 0)
-
-	if offset < 0 || limit <= 0 {
-		return channels
-	}
-
-	// Since IDs starts from 1, shift everything by one.
-	first := fmt.Sprintf("%s%012d", chanID, offset+1)
-	last := fmt.Sprintf("%s%012d", chanID, offset+limit+1)
-
-	for k, v := range crm.channels {
-		if strings.HasPrefix(k, prefix) && v.ID >= first && v.ID < last {
-			channels = append(channels, v)
-		}
-	}
-
-	return channels
-}
-
-func (crm *channelRepositoryMock) Remove(owner, id string) error {
-	delete(crm.channels, key(owner, id))
-	return nil
-}
-
-func (crm *channelRepositoryMock) Connect(owner, chanID, clientID string) error {
-	channel, err := crm.One(owner, chanID)
-	if err != nil {
-		return err
-	}
-
-	client, err := crm.clients.One(owner, clientID)
-	if err != nil {
-		return err
-	}
-	channel.Clients = append(channel.Clients, client)
-	return crm.Update(channel)
-}
-
-func (crm *channelRepositoryMock) Disconnect(owner, chanID, clientID string) error {
-	channel, err := crm.One(owner, chanID)
-	if err != nil {
-		return err
-	}
-
-	if !crm.HasClient(chanID, clientID) {
-		return clients.ErrNotFound
-	}
-
-	connected := make([]clients.Client, len(channel.Clients)-1)
-	for _, client := range channel.Clients {
-		if client.ID != clientID {
-			connected = append(connected, client)
-		}
-	}
-
-	channel.Clients = connected
-	return crm.Update(channel)
-}
-
-func (crm *channelRepositoryMock) HasClient(channel, client string) bool {
-	// This obscure way to examine map keys is enforced by the key structure
-	// itself (see mocks/commons.go).
-	suffix := fmt.Sprintf("-%s", channel)
-
-	for k, v := range crm.channels {
-		if strings.HasSuffix(k, suffix) {
-			for _, c := range v.Clients {
-				if c.ID == client {
-					return true
-				}
-			}
-			break
-		}
-	}
-
-	return false
-}

clients/mocks/clients.go

@@ -1,94 +0,0 @@
-package mocks
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/mainflux/mainflux/clients"
-)
-
-var _ clients.ClientRepository = (*clientRepositoryMock)(nil)
-
-const cliID = "123e4567-e89b-12d3-a456-"
-
-type clientRepositoryMock struct {
-	mu      sync.Mutex
-	counter int
-	clients map[string]clients.Client
-}
-
-// NewClientRepository creates in-memory client repository.
-func NewClientRepository() clients.ClientRepository {
-	return &clientRepositoryMock{
-		clients: make(map[string]clients.Client),
-	}
-}
-
-func (crm *clientRepositoryMock) ID() string {
-	crm.mu.Lock()
-	defer crm.mu.Unlock()
-
-	crm.counter++
-	return fmt.Sprintf("%s%012d", cliID, crm.counter)
-}
-
-func (crm *clientRepositoryMock) Save(client clients.Client) error {
-	crm.mu.Lock()
-	defer crm.mu.Unlock()
-
-	crm.clients[key(client.Owner, client.ID)] = client
-
-	return nil
-}
-
-func (crm *clientRepositoryMock) Update(client clients.Client) error {
-	crm.mu.Lock()
-	defer crm.mu.Unlock()
-
-	dbKey := key(client.Owner, client.ID)
-
-	if _, ok := crm.clients[dbKey]; !ok {
-		return clients.ErrNotFound
-	}
-
-	crm.clients[dbKey] = client
-
-	return nil
-}
-
-func (crm *clientRepositoryMock) One(owner, id string) (clients.Client, error) {
-	if c, ok := crm.clients[key(owner, id)]; ok {
-		return c, nil
-	}
-
-	return clients.Client{}, clients.ErrNotFound
-}
-
-func (crm *clientRepositoryMock) All(owner string, offset, limit int) []clients.Client {
-	// This obscure way to examine map keys is enforced by the key structure
-	// itself (see mocks/commons.go).
-	prefix := fmt.Sprintf("%s-", owner)
-	clients := make([]clients.Client, 0)
-
-	if offset < 0 || limit <= 0 {
-		return clients
-	}
-
-	// Since IDs start from 1, shift everything by one.
-	first := fmt.Sprintf("%s%012d", cliID, offset+1)
-	last := fmt.Sprintf("%s%012d", cliID, offset+limit+1)
-
-	for k, v := range crm.clients {
-		if strings.HasPrefix(k, prefix) && v.ID >= first && v.ID < last {
-			clients = append(clients, v)
-		}
-	}
-
-	return clients
-}
-
-func (crm *clientRepositoryMock) Remove(owner, id string) error {
-	delete(crm.clients, key(owner, id))
-	return nil
-}

clients/mocks/security.go

@@ -1,54 +0,0 @@
-package mocks
-
-import (
-	"github.com/mainflux/mainflux/clients"
-)
-
-var (
-	_ clients.Hasher           = (*hasherMock)(nil)
-	_ clients.IdentityProvider = (*identityProviderMock)(nil)
-)
-
-type hasherMock struct{}
-
-func (hm *hasherMock) Hash(pwd string) (string, error) {
-	return pwd, nil
-}
-
-func (hm *hasherMock) Compare(plain, hashed string) error {
-	if plain != hashed {
-		return clients.ErrUnauthorizedAccess
-	}
-
-	return nil
-}
-
-type identityProviderMock struct{}
-
-func (idp *identityProviderMock) TemporaryKey(id string) (string, error) {
-	if id == "" {
-		return "", clients.ErrUnauthorizedAccess
-	}
-
-	return id, nil
-}
-
-func (idp *identityProviderMock) PermanentKey(id string) (string, error) {
-	return idp.TemporaryKey(id)
-}
-
-func (idp *identityProviderMock) Identity(key string) (string, error) {
-	return idp.TemporaryKey(key)
-}
-
-// NewHasher creates "no-op" hasher for test purposes. This implementation will
-// return secrets without changing them.
-func NewHasher() clients.Hasher {
-	return &hasherMock{}
-}
-
-// NewIdentityProvider creates "mirror" identity provider, i.e. generated
-// token will hold value provided by the caller.
-func NewIdentityProvider() clients.IdentityProvider {
-	return &identityProviderMock{}
-}

clients/postgres/channels.go

@@ -1,179 +0,0 @@
-package postgres
-
-import (
-	"database/sql"
-	"fmt"
-
-	"github.com/lib/pq"
-	"github.com/mainflux/mainflux/clients"
-	"github.com/mainflux/mainflux/logger"
-	uuid "github.com/satori/go.uuid"
-)
-
-var _ clients.ChannelRepository = (*channelRepository)(nil)
-
-const (
-	errDuplicate = "unique_violation"
-	errFK        = "foreign_key_violation"
-)
-
-type channelRepository struct {
-	db  *sql.DB
-	log logger.Logger
-}
-
-// NewChannelRepository instantiates a PostgreSQL implementation of channel
-// repository.
-func NewChannelRepository(db *sql.DB, log logger.Logger) clients.ChannelRepository {
-	return &channelRepository{db: db, log: log}
-}
-
-func (cr channelRepository) Save(channel clients.Channel) (string, error) {
-	channel.ID = uuid.NewV4().String()
-
-	q := `INSERT INTO channels (id, owner, name) VALUES ($1, $2, $3)`
-
-	_, err := cr.db.Exec(q, channel.ID, channel.Owner, channel.Name)
-	if err != nil {
-		return "", err
-	}
-
-	return channel.ID, nil
-}
-
-func (cr channelRepository) Update(channel clients.Channel) error {
-	q := `UPDATE channels SET name = $1 WHERE owner = $2 AND id = $3;`
-
-	res, err := cr.db.Exec(q, channel.Name, channel.Owner, channel.ID)
-	if err != nil {
-		return err
-	}
-
-	cnt, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-
-	if cnt == 0 {
-		return clients.ErrNotFound
-	}
-
-	return nil
-}
-
-func (cr channelRepository) One(owner, id string) (clients.Channel, error) {
-	q := `SELECT name FROM channels WHERE id = $1 AND owner = $2`
-	channel := clients.Channel{ID: id, Owner: owner}
-	if err := cr.db.QueryRow(q, id, owner).Scan(&channel.Name); err != nil {
-		empty := clients.Channel{}
-		if err == sql.ErrNoRows {
-			return empty, clients.ErrNotFound
-		}
-		return empty, err
-	}
-
-	qr := `SELECT id, type, name, key, payload FROM clients cli
-	INNER JOIN connections conn
-	ON cli.id = conn.client_id AND cli.owner = conn.client_owner
-	WHERE conn.channel_id = $1 AND conn.channel_owner = $2`
-
-	rows, err := cr.db.Query(qr, id, owner)
-	if err != nil {
-		cr.log.Error(fmt.Sprintf("Failed to retrieve connected due to %s", err))
-		return clients.Channel{}, err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		c := clients.Client{Owner: owner}
-		if err = rows.Scan(&c.ID, &c.Name, &c.Type, &c.Key, &c.Payload); err != nil {
-			cr.log.Error(fmt.Sprintf("Failed to read connected client due to %s", err))
-			return clients.Channel{}, err
-		}
-		channel.Clients = append(channel.Clients, c)
-	}
-
-	return channel, nil
-}
-
-func (cr channelRepository) All(owner string, offset, limit int) []clients.Channel {
-	q := `SELECT id, name FROM channels WHERE owner = $1 LIMIT $2 OFFSET $3`
-	items := []clients.Channel{}
-
-	rows, err := cr.db.Query(q, owner, limit, offset)
-	if err != nil {
-		cr.log.Error(fmt.Sprintf("Failed to retrieve channels due to %s", err))
-		return []clients.Channel{}
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		c := clients.Channel{Owner: owner}
-		if err = rows.Scan(&c.ID, &c.Name); err != nil {
-			cr.log.Error(fmt.Sprintf("Failed to read retrieved channel due to %s", err))
-			return []clients.Channel{}
-		}
-		items = append(items, c)
-	}
-
-	return items
-}
-
-func (cr channelRepository) Remove(owner, id string) error {
-	q := `DELETE FROM channels WHERE id = $1 AND owner = $2`
-	cr.db.Exec(q, id, owner)
-	return nil
-}
-
-func (cr channelRepository) Connect(owner, chanID, clientID string) error {
-	q := `INSERT INTO connections (channel_id, channel_owner, client_id, client_owner) VALUES ($1, $2, $3, $2)`
-
-	if _, err := cr.db.Exec(q, chanID, owner, clientID); err != nil {
-		pqErr, ok := err.(*pq.Error)
-
-		if ok && errFK == pqErr.Code.Name() {
-			return clients.ErrNotFound
-		}
-
-		// connect is idempotent
-		if ok && errDuplicate == pqErr.Code.Name() {
-			return nil
-		}
-
-		return err
-	}
-
-	return nil
-}
-
-func (cr channelRepository) Disconnect(owner, chanID, clientID string) error {
-	q := `DELETE FROM connections
-	WHERE channel_id = $1 AND channel_owner = $2
-	AND client_id = $3 AND client_owner = $2`
-
-	res, err := cr.db.Exec(q, chanID, owner, clientID)
-	if err != nil {
-		return err
-	}
-
-	cnt, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-
-	if cnt == 0 {
-		return clients.ErrNotFound
-	}
-
-	return nil
-}
-
-func (cr channelRepository) HasClient(chanID, clientID string) bool {
-	q := "SELECT EXISTS (SELECT 1 FROM connections WHERE channel_id = $1 AND client_id = $2);"
-
-	exists := false
-	if err := cr.db.QueryRow(q, chanID, clientID).Scan(&exists); err != nil {
-		cr.log.Error(fmt.Sprintf("Failed to check client existence due to %s", err))
-	}
-	return exists
-}

clients/postgres/channels_test.go

@@ -1,215 +0,0 @@
-package postgres_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/mainflux/mainflux/clients"
-	"github.com/mainflux/mainflux/clients/postgres"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestChannelSave(t *testing.T) {
-	email := "channel-save@example.com"
-	channel := clients.Channel{Owner: email}
-
-	channelRepo := postgres.NewChannelRepository(db, testLog)
-
-	_, err := channelRepo.Save(channel)
-	hasErr := err != nil
-	assert.False(t, hasErr, fmt.Sprintf("create new channel: expected false got %t", hasErr))
-}
-
-func TestChannelUpdate(t *testing.T) {
-	email := "channel-update@example.com"
-
-	chanRepo := postgres.NewChannelRepository(db, testLog)
-
-	c := clients.Channel{Owner: email}
-	id, _ := chanRepo.Save(c)
-	c.ID = id
-
-	cases := map[string]struct {
-		channel clients.Channel
-		err     error
-	}{
-		"existing channel":                            {c, nil},
-		"non-existing channel with existing user":     {clients.Channel{ID: wrong, Owner: email}, clients.ErrNotFound},
-		"non-existing channel with non-existing user": {clients.Channel{ID: wrong, Owner: wrong}, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		err := chanRepo.Update(tc.channel)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestSingleChannelRetrieval(t *testing.T) {
-	email := "channel-single-retrieval@example.com"
-
-	chanRepo := postgres.NewChannelRepository(db, testLog)
-
-	c := clients.Channel{Owner: email}
-	id, _ := chanRepo.Save(c)
-
-	cases := map[string]struct {
-		owner string
-		ID    string
-		err   error
-	}{
-		"existing user":                       {c.Owner, id, nil},
-		"existing user, non-existing channel": {c.Owner, wrong, clients.ErrNotFound},
-		"non-existing owner":                  {wrong, id, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		_, err := chanRepo.One(tc.owner, tc.ID)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestMultiChannelRetrieval(t *testing.T) {
-	email := "channel-multi-retrieval@example.com"
-
-	chanRepo := postgres.NewChannelRepository(db, testLog)
-
-	n := 10
-
-	for i := 0; i < n; i++ {
-		c := clients.Channel{Owner: email}
-		chanRepo.Save(c)
-	}
-
-	cases := map[string]struct {
-		owner  string
-		offset int
-		limit  int
-		size   int
-	}{
-		"existing owner":     {email, 0, n, n},
-		"non-existing owner": {wrong, 1, 6, 0},
-	}
-
-	for desc, tc := range cases {
-		size := len(chanRepo.All(tc.owner, tc.offset, tc.limit))
-		assert.Equal(t, tc.size, size, fmt.Sprintf("%s: expected %d got %d\n", desc, tc.size, size))
-	}
-}
-
-func TestChannelRemoval(t *testing.T) {
-	email := "channel-removal@example.com"
-
-	chanRepo := postgres.NewChannelRepository(db, testLog)
-	chanID, _ := chanRepo.Save(clients.Channel{Owner: email})
-
-	// show that the removal works the same for both existing and non-existing
-	// (removed) channel
-	for i := 0; i < 2; i++ {
-		if err := chanRepo.Remove(email, chanID); err != nil {
-			t.Fatalf("#%d: failed to remove channel due to: %s", i, err)
-		}
-
-		if _, err := chanRepo.One(email, chanID); err != clients.ErrNotFound {
-			t.Fatalf("#%d: expected %s got %s", i, clients.ErrNotFound, err)
-		}
-	}
-}
-
-func TestChannelConnect(t *testing.T) {
-	email := "channel-connect@example.com"
-
-	clientRepo := postgres.NewClientRepository(db, testLog)
-	client := clients.Client{
-		ID:    clientRepo.ID(),
-		Owner: email,
-	}
-	clientRepo.Save(client)
-
-	chanRepo := postgres.NewChannelRepository(db, testLog)
-	chanID, _ := chanRepo.Save(clients.Channel{Owner: email})
-
-	cases := []struct {
-		desc     string
-		owner    string
-		chanID   string
-		clientID string
-		err      error
-	}{
-		{"existing user, channel and client", email, chanID, client.ID, nil},
-		{"connected channel and client", email, chanID, client.ID, nil},
-		{"with non-existing user", wrong, chanID, client.ID, clients.ErrNotFound},
-		{"non-existing channel", email, wrong, client.ID, clients.ErrNotFound},
-		{"non-existing client", email, chanID, wrong, clients.ErrNotFound},
-	}
-
-	for _, tc := range cases {
-		err := chanRepo.Connect(tc.owner, tc.chanID, tc.clientID)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
-	}
-}
-
-func TestChannelDisconnect(t *testing.T) {
-	email := "channel-disconnect@example.com"
-
-	clientRepo := postgres.NewClientRepository(db, testLog)
-	client := clients.Client{
-		ID:    clientRepo.ID(),
-		Owner: email,
-	}
-	clientRepo.Save(client)
-
-	chanRepo := postgres.NewChannelRepository(db, testLog)
-	chanID, _ := chanRepo.Save(clients.Channel{Owner: email})
-
-	chanRepo.Connect(email, chanID, client.ID)
-
-	cases := []struct {
-		desc     string
-		owner    string
-		chanID   string
-		clientID string
-		err      error
-	}{
-		{"connected client", email, chanID, client.ID, nil},
-		{"non-connected client", email, chanID, client.ID, clients.ErrNotFound},
-		{"non-existing user", wrong, chanID, client.ID, clients.ErrNotFound},
-		{"non-existing channel", email, wrong, client.ID, clients.ErrNotFound},
-		{"non-existing client", email, chanID, wrong, clients.ErrNotFound},
-	}
-
-	for _, tc := range cases {
-		err := chanRepo.Disconnect(tc.owner, tc.chanID, tc.clientID)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
-	}
-}
-
-func TestChannelAccessCheck(t *testing.T) {
-	email := "channel-access-check@example.com"
-
-	clientRepo := postgres.NewClientRepository(db, testLog)
-	client := clients.Client{
-		ID:    clientRepo.ID(),
-		Owner: email,
-	}
-	clientRepo.Save(client)
-
-	chanRepo := postgres.NewChannelRepository(db, testLog)
-	chanID, _ := chanRepo.Save(clients.Channel{Owner: email})
-
-	chanRepo.Connect(email, chanID, client.ID)
-
-	cases := map[string]struct {
-		chanID    string
-		clientID  string
-		hasAccess bool
-	}{
-		"client that has access":               {chanID, client.ID, true},
-		"client without access":                {chanID, wrong, false},
-		"check access to non-existing channel": {wrong, client.ID, false},
-	}
-
-	for desc, tc := range cases {
-		hasAccess := chanRepo.HasClient(tc.chanID, tc.clientID)
-		assert.Equal(t, tc.hasAccess, hasAccess, fmt.Sprintf("%s: expected %t got %t\n", desc, tc.hasAccess, hasAccess))
-	}
-}

clients/postgres/clients.go

@@ -1,101 +0,0 @@
-package postgres
-
-import (
-	"database/sql"
-	"fmt"
-
-	_ "github.com/lib/pq" // required for DB access
-	"github.com/mainflux/mainflux/clients"
-	"github.com/mainflux/mainflux/logger"
-	uuid "github.com/satori/go.uuid"
-)
-
-var _ clients.ClientRepository = (*clientRepository)(nil)
-
-type clientRepository struct {
-	db  *sql.DB
-	log logger.Logger
-}
-
-// NewClientRepository instantiates a PostgreSQL implementation of client
-// repository.
-func NewClientRepository(db *sql.DB, log logger.Logger) clients.ClientRepository {
-	return &clientRepository{db: db, log: log}
-}
-
-func (cr clientRepository) ID() string {
-	return uuid.NewV4().String()
-}
-
-func (cr clientRepository) Save(client clients.Client) error {
-	q := `INSERT INTO clients (id, owner, type, name, key, payload) VALUES ($1, $2, $3, $4, $5, $6)`
-	_, err := cr.db.Exec(q, client.ID, client.Owner, client.Type, client.Name, client.Key, client.Payload)
-	return err
-}
-
-func (cr clientRepository) Update(client clients.Client) error {
-	q := `UPDATE clients SET name = $1, payload = $2 WHERE owner = $3 AND id = $4;`
-
-	res, err := cr.db.Exec(q, client.Name, client.Payload, client.Owner, client.ID)
-	if err != nil {
-		return err
-	}
-
-	cnt, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-
-	if cnt == 0 {
-		return clients.ErrNotFound
-	}
-
-	return nil
-}
-
-func (cr clientRepository) One(owner, id string) (clients.Client, error) {
-	q := `SELECT name, type, key, payload FROM clients WHERE id = $1 AND owner = $2`
-	client := clients.Client{ID: id, Owner: owner}
-	err := cr.db.
-		QueryRow(q, id, owner).
-		Scan(&client.Name, &client.Type, &client.Key, &client.Payload)
-
-	if err != nil {
-		empty := clients.Client{}
-		if err == sql.ErrNoRows {
-			return empty, clients.ErrNotFound
-		}
-		return empty, err
-	}
-
-	return client, nil
-}
-
-func (cr clientRepository) All(owner string, offset, limit int) []clients.Client {
-	q := `SELECT id, name, type, key, payload FROM clients WHERE owner = $1 LIMIT $2 OFFSET $3`
-	items := []clients.Client{}
-
-	rows, err := cr.db.Query(q, owner, limit, offset)
-	if err != nil {
-		cr.log.Error(fmt.Sprintf("Failed to retrieve clients due to %s", err))
-		return []clients.Client{}
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		c := clients.Client{Owner: owner}
-		if err = rows.Scan(&c.ID, &c.Name, &c.Type, &c.Key, &c.Payload); err != nil {
-			cr.log.Error(fmt.Sprintf("Failed to read retrieved client due to %s", err))
-			return []clients.Client{}
-		}
-		items = append(items, c)
-	}
-
-	return items
-}
-
-func (cr clientRepository) Remove(owner, id string) error {
-	q := `DELETE FROM clients WHERE id = $1 AND owner = $2`
-	cr.db.Exec(q, id, owner)
-	return nil
-}

clients/postgres/clients_test.go

@@ -1,133 +0,0 @@
-package postgres_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/mainflux/mainflux/clients"
-	"github.com/mainflux/mainflux/clients/postgres"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestClientSave(t *testing.T) {
-	email := "client-save@example.com"
-	clientRepo := postgres.NewClientRepository(db, testLog)
-	client := clients.Client{
-		ID:    clientRepo.ID(),
-		Owner: email,
-	}
-
-	hasErr := clientRepo.Save(client) != nil
-	assert.False(t, hasErr, fmt.Sprintf("create new client: expected false got %t\n", hasErr))
-}
-
-func TestClientUpdate(t *testing.T) {
-	email := "client-update@example.com"
-
-	clientRepo := postgres.NewClientRepository(db, testLog)
-
-	c := clients.Client{
-		ID:    clientRepo.ID(),
-		Owner: email,
-	}
-
-	clientRepo.Save(c)
-
-	cases := map[string]struct {
-		client clients.Client
-		err    error
-	}{
-		"existing client":                            {c, nil},
-		"non-existing client with existing user":     {clients.Client{ID: wrong, Owner: email}, clients.ErrNotFound},
-		"non-existing client with non-existing user": {clients.Client{ID: wrong, Owner: wrong}, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		err := clientRepo.Update(tc.client)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestSingleClientRetrieval(t *testing.T) {
-	email := "client-single-retrieval@example.com"
-
-	clientRepo := postgres.NewClientRepository(db, testLog)
-
-	c := clients.Client{
-		ID:    clientRepo.ID(),
-		Owner: email,
-	}
-
-	clientRepo.Save(c)
-
-	cases := map[string]struct {
-		owner string
-		ID    string
-		err   error
-	}{
-		"existing user":                      {c.Owner, c.ID, nil},
-		"existing user, non-existing client": {c.Owner, wrong, clients.ErrNotFound},
-		"non-existing owner":                 {wrong, c.ID, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		_, err := clientRepo.One(tc.owner, tc.ID)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestMultiClientRetrieval(t *testing.T) {
-	email := "client-multi-retrieval@example.com"
-
-	clientRepo := postgres.NewClientRepository(db, testLog)
-
-	n := 10
-
-	for i := 0; i < n; i++ {
-		c := clients.Client{
-			ID:    clientRepo.ID(),
-			Owner: email,
-		}
-
-		clientRepo.Save(c)
-	}
-
-	cases := map[string]struct {
-		owner  string
-		offset int
-		limit  int
-		size   int
-	}{
-		"existing owner, retrieve all":    {email, 0, n, n},
-		"existing owner, retrieve subset": {email, 1, 6, 6},
-		"non-existing owner":              {wrong, 1, 6, 0},
-	}
-
-	for desc, tc := range cases {
-		n := len(clientRepo.All(tc.owner, tc.offset, tc.limit))
-		assert.Equal(t, tc.size, n, fmt.Sprintf("%s: expected %d got %d\n", desc, tc.size, n))
-	}
-}
-
-func TestClientRemoval(t *testing.T) {
-	email := "client-removal@example.com"
-
-	clientRepo := postgres.NewClientRepository(db, testLog)
-	client := clients.Client{
-		ID:    clientRepo.ID(),
-		Owner: email,
-	}
-	clientRepo.Save(client)
-
-	// show that the removal works the same for both existing and non-existing
-	// (removed) client
-	for i := 0; i < 2; i++ {
-		if err := clientRepo.Remove(email, client.ID); err != nil {
-			t.Fatalf("#%d: failed to remove client due to: %s", i, err)
-		}
-
-		if _, err := clientRepo.One(email, client.ID); err != clients.ErrNotFound {
-			t.Fatalf("#%d: expected %s got %s", i, clients.ErrNotFound, err)
-		}
-	}
-}

clients/postgres/init.go

@@ -1,72 +0,0 @@
-package postgres
-
-import (
-	"database/sql"
-	"fmt"
-
-	_ "github.com/lib/pq" // required for SQL access
-	migrate "github.com/rubenv/sql-migrate"
-)
-
-// Connect creates a connection to the PostgreSQL instance and applies any
-// unapplied database migrations. A non-nil error is returned to indicate
-// failure.
-func Connect(host, port, name, user, pass string) (*sql.DB, error) {
-	t := "host=%s port=%s user=%s dbname=%s password=%s sslmode=disable"
-	url := fmt.Sprintf(t, host, port, user, name, pass)
-
-	db, err := sql.Open("postgres", url)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := migrateDB(db); err != nil {
-		return nil, err
-	}
-
-	return db, nil
-}
-
-func migrateDB(db *sql.DB) error {
-	migrations := &migrate.MemoryMigrationSource{
-		Migrations: []*migrate.Migration{
-			&migrate.Migration{
-				Id: "clients_1",
-				Up: []string{
-					`CREATE TABLE clients (
-						id      CHAR(36),
-						owner   VARCHAR(254),
-						type    VARCHAR(10) NOT NULL,
-						name    TEXT,
-						key     TEXT,
-						payload TEXT,
-						PRIMARY KEY (id, owner)
-					)`,
-					`CREATE TABLE channels (
-						id    CHAR(36),
-						owner VARCHAR(254),
-						name  TEXT,
-						PRIMARY KEY (id, owner)
-					)`,
-					`CREATE TABLE connections (
-						channel_id    CHAR(36),
-						channel_owner VARCHAR(254),
-						client_id     CHAR(36),
-						client_owner  VARCHAR(254),
-						FOREIGN KEY (channel_id, channel_owner) REFERENCES channels (id, owner) ON DELETE CASCADE ON UPDATE CASCADE,
-						FOREIGN KEY (client_id, client_owner) REFERENCES clients (id, owner) ON DELETE CASCADE ON UPDATE CASCADE,
-						PRIMARY KEY (channel_id, channel_owner, client_id, client_owner)
-					)`,
-				},
-				Down: []string{
-					"DROP TABLE connections",
-					"DROP TABLE clients",
-					"DROP TABLE channels",
-				},
-			},
-		},
-	}
-
-	_, err := migrate.Exec(db, "postgres", migrations, migrate.Up)
-	return err
-}

clients/security.go

@@ -1,25 +0,0 @@
-package clients
-
-// Hasher specifies an API for generating hashes of an arbitrary textual
-// content.
-type Hasher interface {
-	// Hash generates the hashed string from plain-text.
-	Hash(string) (string, error)
-
-	// Compare compares plain-text version to the hashed one. An error should
-	// indicate failed comparison.
-	Compare(string, string) error
-}
-
-// IdentityProvider specifies an API for identity management via security
-// tokens.
-type IdentityProvider interface {
-	// TemporaryKey generates the temporary access token.
-	TemporaryKey(string) (string, error)
-
-	// PermanentKey generates the non-expiring access token.
-	PermanentKey(string) (string, error)
-
-	// Identity extracts the entity identifier given its secret key.
-	Identity(string) (string, error)
-}

clients/service.go

@@ -1,265 +0,0 @@
-package clients
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	"github.com/mainflux/mainflux"
-)
-
-var (
-	// ErrConflict indicates usage of the existing email during account
-	// registration.
-	ErrConflict = errors.New("email already taken")
-
-	// ErrMalformedEntity indicates malformed entity specification (e.g.
-	// invalid username or password).
-	ErrMalformedEntity = errors.New("malformed entity specification")
-
-	// ErrUnauthorizedAccess indicates missing or invalid credentials provided
-	// when accessing a protected resource.
-	ErrUnauthorizedAccess = errors.New("missing or invalid credentials provided")
-
-	// ErrNotFound indicates a non-existent entity request.
-	ErrNotFound = errors.New("non-existent entity")
-)
-
-// Service specifies an API that must be fullfiled by the domain service
-// implementation, and all of its decorators (e.g. logging & metrics).
-type Service interface {
-	// AddClient adds new client to the user identified by the provided key.
-	AddClient(string, Client) (string, error)
-
-	// UpdateClient updates the client identified by the provided ID, that
-	// belongs to the user identified by the provided key.
-	UpdateClient(string, Client) error
-
-	// ViewClient retrieves data about the client identified with the provided
-	// ID, that belongs to the user identified by the provided key.
-	ViewClient(string, string) (Client, error)
-
-	// ListClients retrieves data about subset of clients that belongs to the
-	// user identified by the provided key.
-	ListClients(string, int, int) ([]Client, error)
-
-	// RemoveClient removes the client identified with the provided ID, that
-	// belongs to the user identified by the provided key.
-	RemoveClient(string, string) error
-
-	// CreateChannel adds new channel to the user identified by the provided key.
-	CreateChannel(string, Channel) (string, error)
-
-	// UpdateChannel updates the channel identified by the provided ID, that
-	// belongs to the user identified by the provided key.
-	UpdateChannel(string, Channel) error
-
-	// ViewChannel retrieves data about the channel identified by the provided
-	// ID, that belongs to the user identified by the provided key.
-	ViewChannel(string, string) (Channel, error)
-
-	// ListChannels retrieves data about subset of channels that belongs to the
-	// user identified by the provided key.
-	ListChannels(string, int, int) ([]Channel, error)
-
-	// RemoveChannel removes the client identified by the provided ID, that
-	// belongs to the user identified by the provided key.
-	RemoveChannel(string, string) error
-
-	// Connect adds client to the channel's list of connected clients.
-	Connect(string, string, string) error
-
-	// Disconnect removes client from the channel's list of connected
-	// clients.
-	Disconnect(string, string, string) error
-
-	// CanAccess determines whether the channel can be accessed using the
-	// provided key and returns client's id.
-	CanAccess(string, string) (string, error)
-}
-
-var _ Service = (*clientsService)(nil)
-
-type clientsService struct {
-	users    mainflux.UsersServiceClient
-	clients  ClientRepository
-	channels ChannelRepository
-	hasher   Hasher
-	idp      IdentityProvider
-}
-
-// New instantiates the clients service implementation.
-func New(users mainflux.UsersServiceClient, clients ClientRepository, channels ChannelRepository, hasher Hasher, idp IdentityProvider) Service {
-	return &clientsService{
-		users:    users,
-		clients:  clients,
-		channels: channels,
-		hasher:   hasher,
-		idp:      idp,
-	}
-}
-
-func (ms *clientsService) AddClient(key string, client Client) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return "", ErrUnauthorizedAccess
-	}
-
-	client.ID = ms.clients.ID()
-	client.Owner = res.GetValue()
-	client.Key, _ = ms.idp.PermanentKey(client.ID)
-
-	return client.ID, ms.clients.Save(client)
-}
-
-func (ms *clientsService) UpdateClient(key string, client Client) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return ErrUnauthorizedAccess
-	}
-
-	client.Owner = res.GetValue()
-
-	return ms.clients.Update(client)
-}
-
-func (ms *clientsService) ViewClient(key, id string) (Client, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return Client{}, ErrUnauthorizedAccess
-	}
-
-	return ms.clients.One(res.GetValue(), id)
-}
-
-func (ms *clientsService) ListClients(key string, offset, limit int) ([]Client, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return nil, ErrUnauthorizedAccess
-	}
-
-	return ms.clients.All(res.GetValue(), offset, limit), nil
-}
-
-func (ms *clientsService) RemoveClient(key, id string) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return ErrUnauthorizedAccess
-	}
-
-	return ms.clients.Remove(res.GetValue(), id)
-}
-
-func (ms *clientsService) CreateChannel(key string, channel Channel) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return "", ErrUnauthorizedAccess
-	}
-
-	channel.Owner = res.GetValue()
-	return ms.channels.Save(channel)
-}
-
-func (ms *clientsService) UpdateChannel(key string, channel Channel) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return ErrUnauthorizedAccess
-	}
-
-	channel.Owner = res.GetValue()
-	return ms.channels.Update(channel)
-}
-
-func (ms *clientsService) ViewChannel(key, id string) (Channel, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return Channel{}, ErrUnauthorizedAccess
-	}
-
-	return ms.channels.One(res.GetValue(), id)
-}
-
-func (ms *clientsService) ListChannels(key string, offset, limit int) ([]Channel, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return nil, ErrUnauthorizedAccess
-	}
-
-	return ms.channels.All(res.GetValue(), offset, limit), nil
-}
-
-func (ms *clientsService) RemoveChannel(key, id string) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return ErrUnauthorizedAccess
-	}
-
-	return ms.channels.Remove(res.GetValue(), id)
-}
-
-func (ms *clientsService) Connect(key, chanID, clientID string) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return ErrUnauthorizedAccess
-	}
-
-	return ms.channels.Connect(res.GetValue(), chanID, clientID)
-}
-
-func (ms *clientsService) Disconnect(key, chanID, clientID string) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-
-	res, err := ms.users.Identify(ctx, &mainflux.Token{Value: key})
-	if err != nil {
-		return ErrUnauthorizedAccess
-	}
-
-	return ms.channels.Disconnect(res.GetValue(), chanID, clientID)
-}
-
-func (ms *clientsService) CanAccess(key, channel string) (string, error) {
-	client, err := ms.idp.Identity(key)
-	if err != nil {
-		return "", err
-	}
-
-	if !ms.channels.HasClient(channel, client) {
-		return "", ErrUnauthorizedAccess
-	}
-
-	return client, nil
-}

clients/service_test.go

@@ -1,342 +0,0 @@
-package clients_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/mainflux/mainflux/clients"
-	"github.com/mainflux/mainflux/clients/mocks"
-	"github.com/stretchr/testify/assert"
-)
-
-const (
-	wrong = "wrong-value"
-	email = "user@example.com"
-	token = "token"
-)
-
-var (
-	client  = clients.Client{Type: "app", Name: "test"}
-	channel = clients.Channel{Name: "test", Clients: []clients.Client{}}
-)
-
-func newService(tokens map[string]string) clients.Service {
-	users := mocks.NewUsersService(tokens)
-	clientsRepo := mocks.NewClientRepository()
-	channelsRepo := mocks.NewChannelRepository(clientsRepo)
-	hasher := mocks.NewHasher()
-	idp := mocks.NewIdentityProvider()
-
-	return clients.New(users, clientsRepo, channelsRepo, hasher, idp)
-}
-
-func TestAddClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-
-	cases := map[string]struct {
-		client clients.Client
-		key    string
-		err    error
-	}{
-		"add new app":                       {clients.Client{Type: "app", Name: "a"}, token, nil},
-		"add new device":                    {clients.Client{Type: "device", Name: "b"}, token, nil},
-		"add client with wrong credentials": {clients.Client{Type: "app", Name: "d"}, wrong, clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		_, err := svc.AddClient(tc.key, tc.client)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestUpdateClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	clientID, _ := svc.AddClient(token, client)
-	client.ID = clientID
-
-	cases := map[string]struct {
-		client clients.Client
-		key    string
-		err    error
-	}{
-		"update existing client":               {client, token, nil},
-		"update client with wrong credentials": {client, wrong, clients.ErrUnauthorizedAccess},
-		"update non-existing client":           {clients.Client{ID: "2", Type: "app", Name: "d"}, token, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		err := svc.UpdateClient(tc.key, tc.client)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestViewClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	clientID, _ := svc.AddClient(token, client)
-	client.ID = clientID
-
-	cases := map[string]struct {
-		id  string
-		key string
-		err error
-	}{
-		"view existing client":               {client.ID, token, nil},
-		"view client with wrong credentials": {client.ID, wrong, clients.ErrUnauthorizedAccess},
-		"view non-existing client":           {wrong, token, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		_, err := svc.ViewClient(tc.key, tc.id)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestListClients(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-
-	n := 10
-	for i := 0; i < n; i++ {
-		svc.AddClient(token, client)
-	}
-	cases := map[string]struct {
-		key    string
-		offset int
-		limit  int
-		size   int
-		err    error
-	}{
-		"list clients":                        {token, 0, 5, 5, nil},
-		"list clients 5-10":                   {token, 5, 10, 5, nil},
-		"list last client":                    {token, 9, 10, 1, nil},
-		"list empty response":                 {token, 11, 10, 0, nil},
-		"list offset < 0":                     {token, -1, 10, 0, nil},
-		"list limit < 0":                      {token, 1, -10, 0, nil},
-		"list limit = 0":                      {token, 1, 0, 0, nil},
-		"list clients with wrong credentials": {wrong, 0, 0, 0, clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		cl, err := svc.ListClients(tc.key, tc.offset, tc.limit)
-		size := len(cl)
-		assert.Equal(t, tc.size, size, fmt.Sprintf("%s: expected %d got %d\n", desc, tc.size, size))
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestRemoveClient(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	clientID, _ := svc.AddClient(token, client)
-	client.ID = clientID
-
-	cases := map[string]struct {
-		id  string
-		key string
-		err error
-	}{
-		"remove client with wrong credentials": {client.ID, "?", clients.ErrUnauthorizedAccess},
-		"remove existing client":               {client.ID, token, nil},
-		"remove removed client":                {client.ID, token, nil},
-		"remove non-existing client":           {"?", token, nil},
-	}
-
-	for desc, tc := range cases {
-		err := svc.RemoveClient(tc.key, tc.id)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestCreateChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-
-	cases := map[string]struct {
-		channel clients.Channel
-		key     string
-		err     error
-	}{
-		"create channel":                        {clients.Channel{}, token, nil},
-		"create channel with wrong credentials": {clients.Channel{}, wrong, clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		_, err := svc.CreateChannel(tc.key, tc.channel)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestUpdateChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	chanID, _ := svc.CreateChannel(token, channel)
-	channel.ID = chanID
-
-	cases := map[string]struct {
-		channel clients.Channel
-		key     string
-		err     error
-	}{
-		"update existing channel":               {channel, token, nil},
-		"update channel with wrong credentials": {channel, wrong, clients.ErrUnauthorizedAccess},
-		"update non-existing channel":           {clients.Channel{ID: "2", Name: "test"}, token, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		err := svc.UpdateChannel(tc.key, tc.channel)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestViewChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	chanID, _ := svc.CreateChannel(token, channel)
-	channel.ID = chanID
-
-	cases := map[string]struct {
-		id  string
-		key string
-		err error
-	}{
-		"view existing channel":               {channel.ID, token, nil},
-		"view channel with wrong credentials": {channel.ID, wrong, clients.ErrUnauthorizedAccess},
-		"view non-existing channel":           {wrong, token, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		_, err := svc.ViewChannel(tc.key, tc.id)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestListChannels(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-
-	n := 10
-	for i := 0; i < n; i++ {
-		svc.CreateChannel(token, channel)
-	}
-	cases := map[string]struct {
-		key    string
-		offset int
-		limit  int
-		size   int
-		err    error
-	}{
-		"list first 5 channels":                {token, 0, 5, 5, nil},
-		"list channels 5-10 channels":          {token, 5, 10, 5, nil},
-		"list last channel":                    {token, 6, 10, 4, nil},
-		"list offset < 0":                      {token, -1, 10, 0, nil},
-		"list limit < 0":                       {token, 1, -10, 0, nil},
-		"list limit = 0":                       {token, 1, 0, 0, nil},
-		"list channels with wrong credentials": {wrong, 0, 0, 0, clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		ch, err := svc.ListChannels(tc.key, tc.offset, tc.limit)
-		size := len(ch)
-		assert.Equal(t, tc.size, size, fmt.Sprintf("%s: expected %d got %d\n", desc, tc.size, size))
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestRemoveChannel(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-	chanID, _ := svc.CreateChannel(token, channel)
-	channel.ID = chanID
-
-	cases := map[string]struct {
-		id  string
-		key string
-		err error
-	}{
-		"remove channel with wrong credentials": {channel.ID, wrong, clients.ErrUnauthorizedAccess},
-		"remove existing channel":               {channel.ID, token, nil},
-		"remove removed channel":                {channel.ID, token, nil},
-		"remove non-existing channel":           {channel.ID, token, nil},
-	}
-
-	for desc, tc := range cases {
-		err := svc.RemoveChannel(tc.key, tc.id)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestConnect(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-
-	clientID, _ := svc.AddClient(token, client)
-	client.ID = clientID
-	chanID, _ := svc.CreateChannel(token, channel)
-	channel.ID = chanID
-
-	cases := map[string]struct {
-		key      string
-		chanID   string
-		clientID string
-		err      error
-	}{
-		"connect client":                         {token, channel.ID, client.ID, nil},
-		"connect client with wrong credentials":  {wrong, channel.ID, client.ID, clients.ErrUnauthorizedAccess},
-		"connect client to non-existing channel": {token, wrong, client.ID, clients.ErrNotFound},
-	}
-
-	for desc, tc := range cases {
-		err := svc.Connect(tc.key, tc.chanID, tc.clientID)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}
-
-func TestDisconnect(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-
-	clientID, _ := svc.AddClient(token, client)
-	client.ID = clientID
-	chanID, _ := svc.CreateChannel(token, channel)
-	channel.ID = chanID
-
-	svc.Connect(token, chanID, clientID)
-
-	cases := []struct {
-		desc     string
-		key      string
-		chanID   string
-		clientID string
-		err      error
-	}{
-		{"disconnect connected client", token, channel.ID, client.ID, nil},
-		{"disconnect disconnected client", token, channel.ID, client.ID, clients.ErrNotFound},
-		{"disconnect client with wrong credentials", wrong, channel.ID, client.ID, clients.ErrUnauthorizedAccess},
-		{"disconnect client from non-existing channel", token, wrong, client.ID, clients.ErrNotFound},
-		{"disconnect non-existing client", token, channel.ID, wrong, clients.ErrNotFound},
-	}
-
-	for _, tc := range cases {
-		err := svc.Disconnect(tc.key, tc.chanID, tc.clientID)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
-	}
-
-}
-
-func TestCanAccess(t *testing.T) {
-	svc := newService(map[string]string{token: email})
-
-	clientID, _ := svc.AddClient(token, client)
-	client.ID = clientID
-	client.Key = clientID
-
-	channel.Clients = []clients.Client{client}
-	chanID, _ := svc.CreateChannel(token, channel)
-	channel.ID = chanID
-
-	cases := map[string]struct {
-		key     string
-		channel string
-		err     error
-	}{
-		"allowed access":              {client.Key, channel.ID, nil},
-		"not-connected cannot access": {"", channel.ID, clients.ErrUnauthorizedAccess},
-		"access non-existing channel": {client.Key, wrong, clients.ErrUnauthorizedAccess},
-	}
-
-	for desc, tc := range cases {
-		_, err := svc.CanAccess(tc.key, tc.channel)
-		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %s\n", desc, tc.err, err))
-	}
-}

clients/swagger.yaml

@@ -1,445 +0,0 @@
-swagger: "2.0"
-info:
-  title: Mainflux clients service
-  description: HTTP API for managing platform devices, applications and channels.
-  version: "1.0.0"
-consumes:
-  - "application/json"
-produces:
-  - "application/json"
-paths:
-  /clients:
-    post:
-      summary: Adds new client
-      description: |
-        Adds new client to the list of clients owned by user identified using
-        the provided access token.
-      tags:
-        - clients
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - name: client
-          description: JSON-formatted document describing the new client.
-          in: body
-          schema:
-            $ref: "#/definitions/ClientReq"
-          required: true
-      responses:
-        201:
-          description: Client registered.
-          headers:
-            Location:
-              type: string
-              description: Created client's relative URL (i.e. /clients/{clientId}).
-        400:
-          description: Failed due to malformed JSON.
-        403:
-          description: Missing or invalid access token provided.
-        415:
-          description: Missing or invalid content type.
-        500:
-          $ref: "#/responses/ServiceError"
-    get:
-      summary: Retrieves managed clients
-      description: |
-        Retrieves a list of managed clients. Due to performance concerns, data
-        is retrieved in subsets. The API clients must ensure that the entire
-        dataset is consumed either by making subsequent requests, or by
-        increasing the subset size of the initial request.
-      tags:
-        - clients
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/Limit"
-        - $ref: "#/parameters/Offset"
-      responses:
-        200:
-          description: Data retrieved.
-          headers:
-            X-Count:
-              type: integer
-              description: |
-                Total number of managed clients. This value can be used to
-                implement the paging strategy on API clients.
-          schema:
-            $ref: "#/definitions/ClientList"
-        400:
-          description: Failed due to malformed query parameters.
-        403:
-          description: Missing or invalid access token provided.
-        500:
-          $ref: "#/responses/ServiceError"
-  /clients/{clientId}:
-    get:
-      summary: Retrieves client info
-      tags:
-        - clients
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ClientId"
-      responses:
-        200:
-          description: Data retrieved.
-          schema:
-            $ref: "#/definitions/ClientRes"
-        403:
-          description: Missing or invalid access token provided.
-        404:
-          description: Client does not exist.
-        500:
-          $ref: "#/responses/ServiceError"
-    put:
-      summary: Updates client info
-      description: |
-        Update is performed by replacing the current resource data with values
-        provided in a request payload. Note that the client's type and ID
-        cannot be changed.
-      tags:
-        - clients
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ClientId"
-        - name: client
-          description: JSON-formatted document describing the updated client.
-          in: body
-          schema:
-            $ref: "#/definitions/ClientReq"
-          required: true
-      responses:
-        200:
-          description: Client updated.
-        400:
-          description: Failed due to malformed JSON.
-        403:
-          description: Missing or invalid access token provided.
-        404:
-          description: Client does not exist.
-        415:
-          description: Missing or invalid content type.
-        500:
-          $ref: "#/responses/ServiceError"
-    delete:
-      summary: Removes a client
-      description: |
-        Removes a client. The service will ensure that the removed client is
-        disconnected from all of the existing channels.
-      tags:
-        - clients
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ClientId"
-      responses:
-        204:
-          description: Client removed.
-        403:
-          description: Missing or invalid access token provided.
-        500:
-          $ref: "#/responses/ServiceError"
-  /channels:
-    post:
-      summary: Creates new channel
-      description: |
-        Creates new channel. User identified by the provided access token will
-        be the channel's owner.
-      tags:
-        - channels
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - name: channel
-          description: JSON-formatted document describing the new channel.
-          in: body
-          schema:
-            $ref: "#/definitions/ChannelReq"
-          required: true
-      responses:
-        201:
-          description: Channel created.
-          headers:
-            Location:
-              type: string
-              description: Created channel's relative URL (i.e. /channels/{chanId}).
-        400:
-          description: Failed due to malformed JSON.
-        403:
-          description: Missing or invalid access token provided.
-        415:
-          description: Missing or invalid content type.
-        500:
-          $ref: "#/responses/ServiceError"
-    get:
-      summary: Retrieves managed channels
-      description: |
-        Retrieves a list of managed channels. Due to performance concerns, data
-        is retrieved in subsets. The API clients must ensure that the entire
-        dataset is consumed either by making subsequent requests, or by
-        increasing the subset size of the initial request.
-      tags:
-        - channels
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/Limit"
-        - $ref: "#/parameters/Offset"
-      responses:
-        200:
-          description: Data retrieved.
-          headers:
-            X-Count:
-              type: integer
-              description: |
-                Total number of managed channels. This value can be used to
-                implement the paging strategy on API clients.
-          schema:
-            $ref: "#/definitions/ChannelList"
-        400:
-          description: Failed due to malformed query parameters.
-        403:
-          description: Missing or invalid access token provided.
-        500:
-          $ref: "#/responses/ServiceError"
-  /channels/{chanId}:
-    get:
-      summary: Retrieves channel info
-      tags:
-        - channels
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ChanId"
-      responses:
-        200:
-          description: Data retrieved.
-          schema:
-            $ref: "#/definitions/ChannelRes"
-        403:
-          description: Missing or invalid access token provided.
-        404:
-          description: Channel does not exist.
-        500:
-          $ref: "#/responses/ServiceError"
-    put:
-      summary: Updates channel info
-      description: |
-        Update is performed by replacing the current resource data with values
-        provided in a request payload. Note that the channel's ID will not be
-        affected.
-      tags:
-        - channels
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ChanId"
-        - name: channel
-          description: JSON-formatted document describing the updated channel.
-          in: body
-          schema:
-            $ref: "#/definitions/ChannelReq"
-          required: true
-      responses:
-        200:
-          description: Channel updated.
-        400:
-          description: Failed due to malformed JSON.
-        403:
-          description: Missing or invalid access token provided.
-        404:
-          description: Channel does not exist.
-        415:
-          description: Missing or invalid content type.
-        500:
-          $ref: "#/responses/ServiceError"
-    delete:
-      summary: Removes a channel
-      description: |
-        Removes a channel. The service will ensure that the subscribed apps and
-        devices are unsubscribed from the removed channel.
-      tags:
-        - channels
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ChanId"
-      responses:
-        204:
-          description: Channel removed.
-        403:
-          description: Missing or invalid access token provided.
-        500:
-          $ref: "#/responses/ServiceError"
-  /channels/{chanId}/clients/{clientId}:
-    put:
-      summary: Connects the client to the channel
-      description: |
-        Creates connection between a client and a channel. Once connected to
-        the channel, clients are allowed to exchange messages through it.
-      tags:
-        - channels
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ChanId"
-        - $ref: "#/parameters/ClientId"
-      responses:
-        200:
-          description: Client connected.
-        403:
-          description: Missing or invalid access token provided.
-        404:
-          description: Channel or client does not exist.
-        500:
-          $ref: "#/responses/ServiceError"
-    delete:
-      summary: Disconnects the client from the channel
-      description: |
-        Removes connection between a client and a channel. Once connection is
-        removed, client can no longer exchange messages through the channel.
-      tags:
-        - channels
-      parameters:
-        - $ref: "#/parameters/Authorization"
-        - $ref: "#/parameters/ChanId"
-        - $ref: "#/parameters/ClientId"
-      responses:
-        204:
-          description: Client disconnected.
-        403:
-          description: Missing or invalid access token provided.
-        404:
-          description: Channel or client does not exist.
-        500:
-          $ref: "#/responses/ServiceError"
-parameters:
-  Authorization:
-    name: Authorization
-    description: User's access token.
-    in: header
-    type: string
-    required: true
-  ChanId:
-    name: chanId
-    description: Unique channel identifier.
-    in: path
-    type: string
-    format: uuid
-    required: true
-  ClientId:
-    name: clientId
-    description: Unique client identifier.
-    in: path
-    type: string
-    format: uuid
-    required: true
-  Limit:
-    name: limit
-    description: Size of the subset to retrieve.
-    in: query
-    type: integer
-    default: 10
-    maximum: 100
-    minimum: 1
-    required: false
-  Offset:
-    name: offset
-    description: Number of items to skip during retrieval.
-    in: query
-    type: integer
-    default: 0
-    minimum: 0
-    required: false
-
-responses:
-  ServiceError:
-    description: Unexpected server-side error occured.
-
-definitions:
-  ChannelList:
-    type: object
-    properties:
-      channels:
-        type: array
-        minItems: 0
-        uniqueItems: true
-        items:
-          type: object
-          properties:
-            id:
-              type: string
-              description: Unique channel identifier generated by the service.
-            name:
-              type: string
-              description: Free-form channel name.
-          required:
-            - id
-    required:
-      - channels
-  ChannelRes:
-    type: object
-    properties:
-      id:
-        type: string
-        description: Unique channel identifier generated by the service.
-      name:
-        type: string
-        description: Free-form channel name.
-      connected:
-        type: array
-        minItems: 0
-        uniqueItems: true
-        items:
-          $ref: '#/definitions/ClientRes'
-    required:
-      - id
-  ChannelReq:
-    type: object
-    properties:
-      name:
-        type: string
-        description: Free-form channel name.
-  ClientList:
-    type: object
-    properties:
-      clients:
-        type: array
-        minItems: 0
-        uniqueItems: true
-        items:
-          $ref: "#/definitions/ClientRes"
-    required:
-      - clients
-  ClientRes:
-    type: object
-    properties:
-      id:
-        type: string
-        description: Unique client identifier generated by the service.
-      type:
-        type: string
-        enum:
-          - app
-          - device
-        description: Type of the client.
-      name:
-        type: string
-        description: Free-form client name.
-      key:
-        type: string
-        description: Auto-generated access key.
-      payload:
-        type: string
-        description: Arbitrary, string-encoded client's data.
-    required:
-      - id
-      - type
-      - key
-  ClientReq:
-    type: object
-    properties:
-      type:
-        type: string
-        enum:
-          - app
-          - device
-        description: Type of the client.
-      name:
-        type: string
-        description: Free-form client name.
-      payload:
-        type: string
-        description: Arbitrary, string-encoded client's data.
-    required:
-      - type

cmd/bootstrap/main.go

@@ -0,0 +1,323 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	rediscons "github.com/mainflux/mainflux/bootstrap/redis/consumer"
+	redisprod "github.com/mainflux/mainflux/bootstrap/redis/producer"
+	"github.com/mainflux/mainflux/logger"
+	opentracing "github.com/opentracing/opentracing-go"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	r "github.com/go-redis/redis"
+	"github.com/jmoiron/sqlx"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/bootstrap"
+	api "github.com/mainflux/mainflux/bootstrap/api"
+	"github.com/mainflux/mainflux/bootstrap/postgres"
+	mflog "github.com/mainflux/mainflux/logger"
+	mfsdk "github.com/mainflux/mainflux/sdk/go"
+	usersapi "github.com/mainflux/mainflux/users/api/grpc"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	jconfig "github.com/uber/jaeger-client-go/config"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+)
+
+const (
+	defLogLevel      = "error"
+	defDBHost        = "localhost"
+	defDBPort        = "5432"
+	defDBUser        = "mainflux"
+	defDBPass        = "mainflux"
+	defDBName        = "bootstrap"
+	defDBSSLMode     = "disable"
+	defDBSSLCert     = ""
+	defDBSSLKey      = ""
+	defDBSSLRootCert = ""
+	defClientTLS     = "false"
+	defCACerts       = ""
+	defPort          = "8180"
+	defServerCert    = ""
+	defServerKey     = ""
+	defBaseURL       = "http://localhost"
+	defThingsPrefix  = ""
+	defUsersURL      = "localhost:8181"
+	defThingsESURL   = "localhost:6379"
+	defThingsESPass  = ""
+	defThingsESDB    = "0"
+	defESURL         = "localhost:6379"
+	defESPass        = ""
+	defESDB          = "0"
+	defInstanceName  = "bootstrap"
+	defJaegerURL     = "localhost:6831"
+	defUsersTimeout  = "1" // in seconds
+
+	envLogLevel      = "MF_BOOTSTRAP_LOG_LEVEL"
+	envDBHost        = "MF_BOOTSTRAP_DB_HOST"
+	envDBPort        = "MF_BOOTSTRAP_DB_PORT"
+	envDBUser        = "MF_BOOTSTRAP_DB_USER"
+	envDBPass        = "MF_BOOTSTRAP_DB_PASS"
+	envDBName        = "MF_BOOTSTRAP_DB"
+	envDBSSLMode     = "MF_BOOTSTRAP_DB_SSL_MODE"
+	envDBSSLCert     = "MF_BOOTSTRAP_DB_SSL_CERT"
+	envDBSSLKey      = "MF_BOOTSTRAP_DB_SSL_KEY"
+	envDBSSLRootCert = "MF_BOOTSTRAP_DB_SSL_ROOT_CERT"
+	envClientTLS     = "MF_BOOTSTRAP_CLIENT_TLS"
+	envCACerts       = "MF_BOOTSTRAP_CA_CERTS"
+	envPort          = "MF_BOOTSTRAP_PORT"
+	envServerCert    = "MF_BOOTSTRAP_SERVER_CERT"
+	envServerKey     = "MF_BOOTSTRAP_SERVER_KEY"
+	envBaseURL       = "MF_SDK_BASE_URL"
+	envThingsPrefix  = "MF_SDK_THINGS_PREFIX"
+	envUsersURL      = "MF_USERS_URL"
+	envThingsESURL   = "MF_THINGS_ES_URL"
+	envThingsESPass  = "MF_THINGS_ES_PASS"
+	envThingsESDB    = "MF_THINGS_ES_DB"
+	envESURL         = "MF_BOOTSTRAP_ES_URL"
+	envESPass        = "MF_BOOTSTRAP_ES_PASS"
+	envESDB          = "MF_BOOTSTRAP_ES_DB"
+	envInstanceName  = "MF_BOOTSTRAP_INSTANCE_NAME"
+	envJaegerURL     = "MF_JAEGER_URL"
+	envUsersTimeout  = "MF_BOOTSTRAP_USERS_TIMEOUT"
+)
+
+type config struct {
+	logLevel     string
+	dbConfig     postgres.Config
+	clientTLS    bool
+	caCerts      string
+	httpPort     string
+	serverCert   string
+	serverKey    string
+	baseURL      string
+	thingsPrefix string
+	usersURL     string
+	esThingsURL  string
+	esThingsPass string
+	esThingsDB   string
+	esURL        string
+	esPass       string
+	esDB         string
+	instanceName string
+	jaegerURL    string
+	usersTimeout time.Duration
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger, err := mflog.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	db := connectToDB(cfg.dbConfig, logger)
+	defer db.Close()
+
+	conn := connectToUsers(cfg, logger)
+	defer conn.Close()
+
+	thingsESConn := connectToRedis(cfg.esThingsURL, cfg.esThingsPass, cfg.esThingsDB, logger)
+	defer thingsESConn.Close()
+
+	esClient := connectToRedis(cfg.esURL, cfg.esPass, cfg.esDB, logger)
+	defer esClient.Close()
+
+	usersTracer, usersCloser := initJaeger("users", cfg.jaegerURL, logger)
+	defer usersCloser.Close()
+
+	svc := newService(conn, usersTracer, db, logger, esClient, cfg)
+	errs := make(chan error, 2)
+
+	go startHTTPServer(svc, cfg, logger, errs)
+	go subscribeToThingsES(svc, thingsESConn, cfg.instanceName, logger)
+
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("Bootstrap service terminated: %s", err))
+}
+
+func loadConfig() config {
+	tls, err := strconv.ParseBool(mainflux.Env(envClientTLS, defClientTLS))
+	if err != nil {
+		tls = false
+	}
+	dbConfig := postgres.Config{
+		Host:        mainflux.Env(envDBHost, defDBHost),
+		Port:        mainflux.Env(envDBPort, defDBPort),
+		User:        mainflux.Env(envDBUser, defDBUser),
+		Pass:        mainflux.Env(envDBPass, defDBPass),
+		Name:        mainflux.Env(envDBName, defDBName),
+		SSLMode:     mainflux.Env(envDBSSLMode, defDBSSLMode),
+		SSLCert:     mainflux.Env(envDBSSLCert, defDBSSLCert),
+		SSLKey:      mainflux.Env(envDBSSLKey, defDBSSLKey),
+		SSLRootCert: mainflux.Env(envDBSSLRootCert, defDBSSLRootCert),
+	}
+
+	timeout, err := strconv.ParseInt(mainflux.Env(envUsersTimeout, defUsersTimeout), 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid %s value: %s", envUsersTimeout, err.Error())
+	}
+
+	return config{
+		logLevel:     mainflux.Env(envLogLevel, defLogLevel),
+		dbConfig:     dbConfig,
+		clientTLS:    tls,
+		caCerts:      mainflux.Env(envCACerts, defCACerts),
+		httpPort:     mainflux.Env(envPort, defPort),
+		serverCert:   mainflux.Env(envServerCert, defServerCert),
+		serverKey:    mainflux.Env(envServerKey, defServerKey),
+		baseURL:      mainflux.Env(envBaseURL, defBaseURL),
+		thingsPrefix: mainflux.Env(envThingsPrefix, defThingsPrefix),
+		usersURL:     mainflux.Env(envUsersURL, defUsersURL),
+		esThingsURL:  mainflux.Env(envThingsESURL, defThingsESURL),
+		esThingsPass: mainflux.Env(envThingsESPass, defThingsESPass),
+		esThingsDB:   mainflux.Env(envThingsESDB, defThingsESDB),
+		esURL:        mainflux.Env(envESURL, defESURL),
+		esPass:       mainflux.Env(envESPass, defESPass),
+		esDB:         mainflux.Env(envESDB, defESDB),
+		instanceName: mainflux.Env(envInstanceName, defInstanceName),
+		jaegerURL:    mainflux.Env(envJaegerURL, defJaegerURL),
+		usersTimeout: time.Duration(timeout) * time.Second,
+	}
+}
+
+func connectToDB(cfg postgres.Config, logger mflog.Logger) *sqlx.DB {
+	db, err := postgres.Connect(cfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to postgres: %s", err))
+		os.Exit(1)
+	}
+	return db
+}
+
+func connectToRedis(redisURL, redisPass, redisDB string, logger mflog.Logger) *r.Client {
+	db, err := strconv.Atoi(redisDB)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to redis: %s", err))
+		os.Exit(1)
+	}
+
+	return r.NewClient(&r.Options{
+		Addr:     redisURL,
+		Password: redisPass,
+		DB:       db,
+	})
+}
+
+func initJaeger(svcName, url string, logger logger.Logger) (opentracing.Tracer, io.Closer) {
+	tracer, closer, err := jconfig.Configuration{
+		ServiceName: svcName,
+		Sampler: &jconfig.SamplerConfig{
+			Type:  "const",
+			Param: 1,
+		},
+		Reporter: &jconfig.ReporterConfig{
+			LocalAgentHostPort: url,
+			LogSpans:           true,
+		},
+	}.NewTracer()
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger client: %s", err))
+		os.Exit(1)
+	}
+
+	return tracer, closer
+}
+
+func newService(conn *grpc.ClientConn, usersTracer opentracing.Tracer, db *sqlx.DB, logger mflog.Logger, esClient *r.Client, cfg config) bootstrap.Service {
+	thingsRepo := postgres.NewConfigRepository(db, logger)
+
+	config := mfsdk.Config{
+		BaseURL:      cfg.baseURL,
+		ThingsPrefix: cfg.thingsPrefix,
+	}
+
+	sdk := mfsdk.NewSDK(config)
+	users := usersapi.NewClient(usersTracer, conn, cfg.usersTimeout)
+
+	svc := bootstrap.New(users, thingsRepo, sdk)
+	svc = redisprod.NewEventStoreMiddleware(svc, esClient)
+	svc = api.NewLoggingMiddleware(svc, logger)
+	svc = api.MetricsMiddleware(
+		svc,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "bootstrap",
+			Subsystem: "api",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "bootstrap",
+			Subsystem: "api",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+	return svc
+}
+
+func connectToUsers(cfg config, logger mflog.Logger) *grpc.ClientConn {
+	var opts []grpc.DialOption
+	if cfg.clientTLS {
+		if cfg.caCerts != "" {
+			tpc, err := credentials.NewClientTLSFromFile(cfg.caCerts, "")
+			if err != nil {
+				logger.Error(fmt.Sprintf("Failed to create tls credentials: %s", err))
+				os.Exit(1)
+			}
+			opts = append(opts, grpc.WithTransportCredentials(tpc))
+		}
+	} else {
+		opts = append(opts, grpc.WithInsecure())
+		logger.Info("gRPC communication is not encrypted")
+	}
+
+	conn, err := grpc.Dial(cfg.usersURL, opts...)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
+		os.Exit(1)
+	}
+
+	return conn
+}
+
+func startHTTPServer(svc bootstrap.Service, cfg config, logger mflog.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", cfg.httpPort)
+	if cfg.serverCert != "" || cfg.serverKey != "" {
+		logger.Info(fmt.Sprintf("Bootstrap service started using https on port %s with cert %s key %s",
+			cfg.httpPort, cfg.serverCert, cfg.serverKey))
+		errs <- http.ListenAndServeTLS(p, cfg.serverCert, cfg.serverKey, api.MakeHandler(svc, bootstrap.NewConfigReader()))
+		return
+	}
+	logger.Info(fmt.Sprintf("Bootstrap service started using http on port %s", cfg.httpPort))
+	errs <- http.ListenAndServe(p, api.MakeHandler(svc, bootstrap.NewConfigReader()))
+}
+
+func subscribeToThingsES(svc bootstrap.Service, client *r.Client, consumer string, logger mflog.Logger) {
+	eventStore := rediscons.NewEventStore(svc, client, consumer, logger)
+	logger.Info("Subscribed to Redis Event Store")
+	if err := eventStore.Subscribe("mainflux.things"); err != nil {
+		logger.Warn(fmt.Sprintf("Botstrap service failed to subscribe to event sourcing: %s", err))
+	}
+}

cmd/cassandra-reader/main.go

@@ -0,0 +1,228 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	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/auth/grpc"
+	opentracing "github.com/opentracing/opentracing-go"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	jconfig "github.com/uber/jaeger-client-go/config"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+)
+
+const (
+	sep = ","
+
+	defLogLevel      = "error"
+	defPort          = "8180"
+	defCluster       = "127.0.0.1"
+	defKeyspace      = "mainflux"
+	defDBUsername    = ""
+	defDBPassword    = ""
+	defDBPort        = "9042"
+	defThingsURL     = "localhost:8181"
+	defClientTLS     = "false"
+	defCACerts       = ""
+	defJaegerURL     = "localhost:6831"
+	defThingsTimeout = "1" // in seconds
+
+	envLogLevel      = "MF_CASSANDRA_READER_LOG_LEVEL"
+	envPort          = "MF_CASSANDRA_READER_PORT"
+	envCluster       = "MF_CASSANDRA_READER_DB_CLUSTER"
+	envKeyspace      = "MF_CASSANDRA_READER_DB_KEYSPACE"
+	envDBUsername    = "MF_CASSANDRA_READER_DB_USERNAME"
+	envDBPassword    = "MF_CASSANDRA_READER_DB_PASSWORD"
+	envDBPort        = "MF_CASSANDRA_READER_DB_PORT"
+	envThingsURL     = "MF_THINGS_URL"
+	envClientTLS     = "MF_CASSANDRA_READER_CLIENT_TLS"
+	envCACerts       = "MF_CASSANDRA_READER_CA_CERTS"
+	envJaegerURL     = "MF_JAEGER_URL"
+	envThingsTimeout = "MF_CASSANDRA_READER_THINGS_TIMEOUT"
+)
+
+type config struct {
+	logLevel      string
+	port          string
+	dbCfg         cassandra.DBConfig
+	thingsURL     string
+	clientTLS     bool
+	caCerts       string
+	jaegerURL     string
+	thingsTimeout time.Duration
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	session := connectToCassandra(cfg.dbCfg, logger)
+	defer session.Close()
+
+	conn := connectToThings(cfg, logger)
+	defer conn.Close()
+
+	thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
+	defer thingsCloser.Close()
+
+	tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
+	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 {
+	dbPort, err := strconv.Atoi(mainflux.Env(envDBPort, defDBPort))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	dbCfg := cassandra.DBConfig{
+		Hosts:    strings.Split(mainflux.Env(envCluster, defCluster), sep),
+		Keyspace: mainflux.Env(envKeyspace, defKeyspace),
+		Username: mainflux.Env(envDBUsername, defDBUsername),
+		Password: mainflux.Env(envDBPassword, defDBPassword),
+		Port:     dbPort,
+	}
+
+	tls, err := strconv.ParseBool(mainflux.Env(envClientTLS, defClientTLS))
+	if err != nil {
+		log.Fatalf("Invalid value passed for %s\n", envClientTLS)
+	}
+
+	timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
+	}
+
+	return config{
+		logLevel:      mainflux.Env(envLogLevel, defLogLevel),
+		port:          mainflux.Env(envPort, defPort),
+		dbCfg:         dbCfg,
+		thingsURL:     mainflux.Env(envThingsURL, defThingsURL),
+		clientTLS:     tls,
+		caCerts:       mainflux.Env(envCACerts, defCACerts),
+		jaegerURL:     mainflux.Env(envJaegerURL, defJaegerURL),
+		thingsTimeout: time.Duration(timeout) * time.Second,
+	}
+}
+
+func connectToCassandra(dbCfg cassandra.DBConfig, logger logger.Logger) *gocql.Session {
+	session, err := cassandra.Connect(dbCfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to Cassandra cluster: %s", err))
+		os.Exit(1)
+	}
+
+	return session
+}
+
+func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
+	var opts []grpc.DialOption
+	if cfg.clientTLS {
+		if cfg.caCerts != "" {
+			tpc, err := credentials.NewClientTLSFromFile(cfg.caCerts, "")
+			if err != nil {
+				logger.Error(fmt.Sprintf("Failed to load certs: %s", err))
+				os.Exit(1)
+			}
+			opts = append(opts, grpc.WithTransportCredentials(tpc))
+		}
+	} else {
+		logger.Info("gRPC communication is not encrypted")
+		opts = append(opts, grpc.WithInsecure())
+	}
+
+	conn, err := grpc.Dial(cfg.thingsURL, opts...)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
+		os.Exit(1)
+	}
+	return conn
+}
+
+func initJaeger(svcName, url string, logger logger.Logger) (opentracing.Tracer, io.Closer) {
+	tracer, closer, err := jconfig.Configuration{
+		ServiceName: svcName,
+		Sampler: &jconfig.SamplerConfig{
+			Type:  "const",
+			Param: 1,
+		},
+		Reporter: &jconfig.ReporterConfig{
+			LocalAgentHostPort: url,
+			LogSpans:           true,
+		},
+	}.NewTracer()
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger client: %s", err))
+		os.Exit(1)
+	}
+
+	return tracer, closer
+}
+
+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,196 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/BurntSushi/toml"
+	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/api"
+	"github.com/mainflux/mainflux/writers/cassandra"
+	nats "github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	svcName = "cassandra-writer"
+	sep     = ","
+
+	defNatsURL     = nats.DefaultURL
+	defLogLevel    = "error"
+	defPort        = "8180"
+	defCluster     = "127.0.0.1"
+	defKeyspace    = "mainflux"
+	defDBUsername  = ""
+	defDBPassword  = ""
+	defDBPort      = "9042"
+	defChanCfgPath = "/config/channels.toml"
+
+	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"
+	envDBUsername  = "MF_CASSANDRA_WRITER_DB_USERNAME"
+	envDBPassword  = "MF_CASSANDRA_WRITER_DB_PASSWORD"
+	envDBPort      = "MF_CASSANDRA_WRITER_DB_PORT"
+	envChanCfgPath = "MF_CASSANDRA_WRITER_CHANNELS_CONFIG"
+)
+
+type config struct {
+	natsURL  string
+	logLevel string
+	port     string
+	dbCfg    cassandra.DBConfig
+	channels map[string]bool
+}
+
+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.dbCfg, logger)
+	defer session.Close()
+
+	repo := newService(session, logger)
+	if err := writers.Start(nc, repo, svcName, cfg.channels, 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 {
+	dbPort, err := strconv.Atoi(mainflux.Env(envDBPort, defDBPort))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	dbCfg := cassandra.DBConfig{
+		Hosts:    strings.Split(mainflux.Env(envCluster, defCluster), sep),
+		Keyspace: mainflux.Env(envKeyspace, defKeyspace),
+		Username: mainflux.Env(envDBUsername, defDBUsername),
+		Password: mainflux.Env(envDBPassword, defDBPassword),
+		Port:     dbPort,
+	}
+
+	chanCfgPath := mainflux.Env(envChanCfgPath, defChanCfgPath)
+	return config{
+		natsURL:  mainflux.Env(envNatsURL, defNatsURL),
+		logLevel: mainflux.Env(envLogLevel, defLogLevel),
+		port:     mainflux.Env(envPort, defPort),
+		dbCfg:    dbCfg,
+		channels: loadChansConfig(chanCfgPath),
+	}
+}
+
+type channels struct {
+	List []string `toml:"filter"`
+}
+
+type chanConfig struct {
+	Channels channels `toml:"channels"`
+}
+
+func loadChansConfig(chanConfigPath string) map[string]bool {
+	data, err := ioutil.ReadFile(chanConfigPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var chanCfg chanConfig
+	if err := toml.Unmarshal(data, &chanCfg); err != nil {
+		log.Fatal(err)
+	}
+
+	chans := map[string]bool{}
+	for _, ch := range chanCfg.Channels.List {
+		chans[ch] = true
+	}
+
+	return chans
+}
+
+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(dbCfg cassandra.DBConfig, logger logger.Logger) *gocql.Session {
+	session, err := cassandra.Connect(dbCfg)
+	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 = api.LoggingMiddleware(repo, logger)
+	repo = api.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, api.MakeHandler(svcName))
+}

cmd/cli/main.go

@@ -0,0 +1,134 @@
+//
+// 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",
+		ReaderURL:         "http://localhost:8905",
+		ReaderPrefix:      "",
+		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()
+	provisionCmd := cli.NewProvisionCmd()
+
+	// Root Commands
+	rootCmd.AddCommand(versionCmd)
+	rootCmd.AddCommand(usersCmd)
+	rootCmd.AddCommand(thingsCmd)
+	rootCmd.AddCommand(channelsCmd)
+	rootCmd.AddCommand(messagesCmd)
+	rootCmd.AddCommand(provisionCmd)
+
+	// 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",
+	)
+
+	rootCmd.PersistentFlags().StringVarP(
+		&cli.Name,
+		"name",
+		"n",
+		"",
+		"name query parameter",
+	)
+
+	if err := rootCmd.Execute(); err != nil {
+		log.Fatal(err)
+	}
+}

cmd/clients/main.go

@@ -1,162 +0,0 @@
-package main
-
-import (
-	"database/sql"
-	"fmt"
-	"net"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-
-	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/clients"
-	"github.com/mainflux/mainflux/clients/api"
-	grpcapi "github.com/mainflux/mainflux/clients/api/grpc"
-	httpapi "github.com/mainflux/mainflux/clients/api/http"
-	"github.com/mainflux/mainflux/clients/bcrypt"
-	"github.com/mainflux/mainflux/clients/jwt"
-	"github.com/mainflux/mainflux/clients/postgres"
-	log "github.com/mainflux/mainflux/logger"
-	usersapi "github.com/mainflux/mainflux/users/api/grpc"
-	stdprometheus "github.com/prometheus/client_golang/prometheus"
-	"google.golang.org/grpc"
-)
-
-const (
-	defDBHost   = "localhost"
-	defDBPort   = "5432"
-	defDBUser   = "mainflux"
-	defDBPass   = "mainflux"
-	defDBName   = "clients"
-	defHTTPPort = "8180"
-	defGRPCPort = "8181"
-	defUsersURL = "localhost:8181"
-	defSecret   = "clients"
-	envDBHost   = "MF_CLIENTS_DB_HOST"
-	envDBPort   = "MF_CLIENTS_DB_PORT"
-	envDBUser   = "MF_CLIENTS_DB_USER"
-	envDBPass   = "MF_CLIENTS_DB_PASS"
-	envDBName   = "MF_CLIENTS_DB"
-	envHTTPPort = "MF_CLIENTS_HTTP_PORT"
-	envGRPCPort = "MF_CLIENTS_GRPC_PORT"
-	envUsersURL = "MF_USERS_URL"
-	envSecret   = "MF_CLIENTS_SECRET"
-)
-
-type config struct {
-	DBHost   string
-	DBPort   string
-	DBUser   string
-	DBPass   string
-	DBName   string
-	HTTPPort string
-	GRPCPort string
-	UsersURL string
-	Secret   string
-}
-
-func main() {
-	cfg := loadConfig()
-
-	logger := log.New(os.Stdout)
-
-	db := connectToDB(cfg, logger)
-	defer db.Close()
-
-	conn := connectToUsersService(cfg.UsersURL, logger)
-	defer conn.Close()
-
-	svc := newService(conn, db, cfg.Secret, logger)
-	errs := make(chan error, 2)
-
-	go startHTTPServer(svc, cfg.HTTPPort, logger, errs)
-	go startGRPCServer(svc, cfg.GRPCPort, 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("Clients 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),
-		Secret:   mainflux.Env(envSecret, defSecret),
-	}
-}
-
-func connectToDB(cfg config, logger log.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))
-		os.Exit(1)
-	}
-	return db
-}
-
-func connectToUsersService(usersAddr string, logger log.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))
-		os.Exit(1)
-	}
-	return conn
-}
-
-func newService(conn *grpc.ClientConn, db *sql.DB, secret string, logger log.Logger) clients.Service {
-	users := usersapi.NewClient(conn)
-	clientsRepo := postgres.NewClientRepository(db, logger)
-	channelsRepo := postgres.NewChannelRepository(db, logger)
-	hasher := bcrypt.New()
-	idp := jwt.New(secret)
-
-	svc := clients.New(users, clientsRepo, channelsRepo, hasher, idp)
-	svc = api.LoggingMiddleware(svc, logger)
-	svc = api.MetricsMiddleware(
-		svc,
-		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: "clients",
-			Subsystem: "api",
-			Name:      "request_count",
-			Help:      "Number of requests received.",
-		}, []string{"method"}),
-		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
-			Namespace: "clients",
-			Subsystem: "api",
-			Name:      "request_latency_microseconds",
-			Help:      "Total duration of requests in microseconds.",
-		}, []string{"method"}),
-	)
-	return svc
-}
-
-func startHTTPServer(svc clients.Service, port string, logger log.Logger, errs chan error) {
-	p := fmt.Sprintf(":%s", port)
-	logger.Info(fmt.Sprintf("Clients service started, exposed port %s", port))
-	errs <- http.ListenAndServe(p, httpapi.MakeHandler(svc))
-}
-
-func startGRPCServer(svc clients.Service, port string, logger log.Logger, errs chan error) {
-	p := fmt.Sprintf(":%s", port)
-	listener, err := net.Listen("tcp", p)
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to listen on port %s: %s", port, err))
-	}
-	server := grpc.NewServer()
-	mainflux.RegisterClientsServiceServer(server, grpcapi.NewServer(svc))
-	logger.Info(fmt.Sprintf("Clients gRPC service started, exposed port %s", port))
-	errs <- server.Serve(listener)
-}

cmd/coap/main.go

@@ -1,66 +1,99 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"fmt"
+	"io"
+	"log"
+	"net/http"
 	"os"
 	"os/signal"
+	"strconv"
 	"syscall"
+	"time"
 
+	gocoap "github.com/dustin/go-coap"
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	"github.com/mainflux/mainflux"
-	clientsapi "github.com/mainflux/mainflux/clients/api/grpc"
 	"github.com/mainflux/mainflux/coap"
 	"github.com/mainflux/mainflux/coap/api"
 	"github.com/mainflux/mainflux/coap/nats"
-	log "github.com/mainflux/mainflux/logger"
+	logger "github.com/mainflux/mainflux/logger"
+	thingsapi "github.com/mainflux/mainflux/things/api/auth/grpc"
+	opentracing "github.com/opentracing/opentracing-go"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	jconfig "github.com/uber/jaeger-client-go/config"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
 
 	broker "github.com/nats-io/go-nats"
 )
 
 const (
-	defPort       int    = 5683
-	defNatsURL    string = broker.DefaultURL
-	defClientsURL string = "localhost:8181"
-	envPort       string = "MF_COAP_ADAPTER_PORT"
-	envNatsURL    string = "MF_NATS_URL"
-	envClientsURL string = "MF_CLIENTS_URL"
+	defPort          = "5683"
+	defNatsURL       = broker.DefaultURL
+	defThingsURL     = "localhost:8181"
+	defLogLevel      = "error"
+	defClientTLS     = "false"
+	defCACerts       = ""
+	defPingPeriod    = "12"
+	defJaegerURL     = "localhost:6831"
+	defThingsTimeout = "1" // in seconds
+
+	envPort          = "MF_COAP_ADAPTER_PORT"
+	envNatsURL       = "MF_NATS_URL"
+	envThingsURL     = "MF_THINGS_URL"
+	envLogLevel      = "MF_COAP_ADAPTER_LOG_LEVEL"
+	envClientTLS     = "MF_COAP_ADAPTER_CLIENT_TLS"
+	envCACerts       = "MF_COAP_ADAPTER_CA_CERTS"
+	envPingPeriod    = "MF_COAP_ADAPTER_PING_PERIOD"
+	envJaegerURL     = "MF_JAEGER_URL"
+	envThingsTimeout = "MF_COAP_ADAPTER_THINGS_TIMEOUT"
 )
 
 type config struct {
-	ClientsURL string
-	NatsURL    string
-	Port       int
+	port          string
+	natsURL       string
+	thingsURL     string
+	logLevel      string
+	clientTLS     bool
+	caCerts       string
+	pingPeriod    time.Duration
+	jaegerURL     string
+	thingsTimeout time.Duration
 }
 
 func main() {
-	cfg := config{
-		ClientsURL: mainflux.Env(envClientsURL, defClientsURL),
-		NatsURL:    mainflux.Env(envNatsURL, defNatsURL),
-		Port:       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)
+	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.ClientsURL, grpc.WithInsecure())
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
-		os.Exit(1)
-	}
+	conn := connectToThings(cfg, logger)
 	defer conn.Close()
 
-	cc := clientsapi.NewClient(conn)
+	thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
+	defer thingsCloser.Close()
 
-	pubsub := nats.New(nc, logger)
-	svc := coap.New(pubsub)
+	cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
+	respChan := make(chan string, 10000)
+	pubsub := nats.New(nc)
+	svc := coap.New(pubsub, cc, respChan)
 	svc = api.LoggingMiddleware(svc, logger)
 
 	svc = api.MetricsMiddleware(
@@ -81,11 +114,8 @@ func main() {
 
 	errs := make(chan error, 2)
 
-	go func() {
-		p := fmt.Sprintf(":%d", cfg.Port)
-		logger.Info(fmt.Sprintf("CoAP adapter service started, exposed port %d", cfg.Port))
-		errs <- api.ListenAndServe(svc, cc, p)
-	}()
+	go startHTTPServer(cfg.port, logger, errs)
+	go startCOAPServer(cfg, svc, cc, respChan, logger, errs)
 
 	go func() {
 		c := make(chan os.Signal)
@@ -96,3 +126,92 @@ func main() {
 	err = <-errs
 	logger.Error(fmt.Sprintf("CoAP adapter terminated: %s", err))
 }
+
+func loadConfig() config {
+	tls, err := strconv.ParseBool(mainflux.Env(envClientTLS, defClientTLS))
+	if err != nil {
+		log.Fatalf("Invalid value passed for %s\n", envClientTLS)
+	}
+
+	pp, err := strconv.ParseInt(mainflux.Env(envPingPeriod, defPingPeriod), 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid value passed for %s\n", envPingPeriod)
+	}
+
+	if pp < 1 || pp > 24 {
+		log.Fatalf("Value of %s must be between 1 and 24", envPingPeriod)
+	}
+
+	timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
+	}
+
+	return config{
+		thingsURL:     mainflux.Env(envThingsURL, defThingsURL),
+		natsURL:       mainflux.Env(envNatsURL, defNatsURL),
+		port:          mainflux.Env(envPort, defPort),
+		logLevel:      mainflux.Env(envLogLevel, defLogLevel),
+		clientTLS:     tls,
+		caCerts:       mainflux.Env(envCACerts, defCACerts),
+		pingPeriod:    time.Duration(pp),
+		jaegerURL:     mainflux.Env(envJaegerURL, defJaegerURL),
+		thingsTimeout: time.Duration(timeout) * time.Second,
+	}
+}
+
+func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
+	var opts []grpc.DialOption
+	if cfg.clientTLS {
+		if cfg.caCerts != "" {
+			tpc, err := credentials.NewClientTLSFromFile(cfg.caCerts, "")
+			if err != nil {
+				logger.Error(fmt.Sprintf("Failed to load certs: %s", err))
+				os.Exit(1)
+			}
+			opts = append(opts, grpc.WithTransportCredentials(tpc))
+		}
+	} else {
+		logger.Info("gRPC communication is not encrypted")
+		opts = append(opts, grpc.WithInsecure())
+	}
+
+	conn, err := grpc.Dial(cfg.thingsURL, opts...)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
+		os.Exit(1)
+	}
+	return conn
+}
+
+func initJaeger(svcName, url string, logger logger.Logger) (opentracing.Tracer, io.Closer) {
+	tracer, closer, err := jconfig.Configuration{
+		ServiceName: svcName,
+		Sampler: &jconfig.SamplerConfig{
+			Type:  "const",
+			Param: 1,
+		},
+		Reporter: &jconfig.ReporterConfig{
+			LocalAgentHostPort: url,
+			LogSpans:           true,
+		},
+	}.NewTracer()
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger client: %s", err))
+		os.Exit(1)
+	}
+
+	return tracer, closer
+}
+
+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(cfg config, svc coap.Service, auth mainflux.ThingsServiceClient, respChan chan<- string, l logger.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", cfg.port)
+	l.Info(fmt.Sprintf("CoAP adapter service started, exposed port %s", cfg.port))
+	errs <- gocoap.ListenAndServe("udp", p, api.MakeCOAPHandler(svc, auth, l, respChan, cfg.pingPeriod))
+}

cmd/http/main.go

@@ -1,66 +1,99 @@
+//
+// Copyright (c) 2019
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
 package main
 
 import (
 	"fmt"
+	"io"
+	"log"
 	"net/http"
 	"os"
 	"os/signal"
+	"strconv"
 	"syscall"
+	"time"
+
+	"google.golang.org/grpc/credentials"
 
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	"github.com/mainflux/mainflux"
-	clientsapi "github.com/mainflux/mainflux/clients/api/grpc"
 	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/auth/grpc"
 	broker "github.com/nats-io/go-nats"
+	opentracing "github.com/opentracing/opentracing-go"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	jconfig "github.com/uber/jaeger-client-go/config"
 	"google.golang.org/grpc"
 )
 
 const (
-	defPort       string = "8180"
-	defNatsURL    string = broker.DefaultURL
-	defClientsURL string = "localhost:8181"
-	envPort       string = "MF_HTTP_ADAPTER_PORT"
-	envNatsURL    string = "MF_NATS_URL"
-	envClientsURL string = "MF_CLIENTS_URL"
+	defClientTLS     = "false"
+	defCACerts       = ""
+	defPort          = "8180"
+	defLogLevel      = "error"
+	defNatsURL       = broker.DefaultURL
+	defThingsURL     = "localhost:8181"
+	defJaegerURL     = "localhost:6831"
+	defThingsTimeout = "1" // in seconds
+
+	envClientTLS     = "MF_HTTP_ADAPTER_CLIENT_TLS"
+	envCACerts       = "MF_HTTP_ADAPTER_CA_CERTS"
+	envPort          = "MF_HTTP_ADAPTER_PORT"
+	envLogLevel      = "MF_HTTP_ADAPTER_LOG_LEVEL"
+	envNatsURL       = "MF_NATS_URL"
+	envThingsURL     = "MF_THINGS_URL"
+	envJaegerURL     = "MF_JAEGER_URL"
+	envThingsTimeout = "MF_HTTP_ADAPTER_THINGS_TIMEOUT"
 )
 
 type config struct {
-	ClientsURL string
-	NatsURL    string
-	Port       string
+	thingsURL     string
+	natsURL       string
+	logLevel      string
+	port          string
+	clientTLS     bool
+	caCerts       string
+	jaegerURL     string
+	thingsTimeout time.Duration
 }
 
 func main() {
-	cfg := config{
-		ClientsURL: mainflux.Env(envClientsURL, defClientsURL),
-		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)
+	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.ClientsURL, grpc.WithInsecure())
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
-		os.Exit(1)
-	}
+	conn := connectToThings(cfg, logger)
 	defer conn.Close()
 
-	cc := clientsapi.NewClient(conn)
+	tracer, closer := initJaeger("http_adapter", cfg.jaegerURL, logger)
+	defer closer.Close()
+
+	thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
+	defer thingsCloser.Close()
+
+	cc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
 	pub := nats.NewMessagePublisher(nc)
 
-	svc := adapter.New(pub)
+	svc := adapter.New(pub, cc)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(
 		svc,
@@ -81,9 +114,9 @@ func main() {
 	errs := make(chan error, 2)
 
 	go func() {
-		p := fmt.Sprintf(":%s", cfg.Port)
-		logger.Info(fmt.Sprintf("HTTP adapter service started, exposed port %s", cfg.Port))
-		errs <- http.ListenAndServe(p, api.MakeHandler(svc, cc))
+		p := fmt.Sprintf(":%s", cfg.port)
+		logger.Info(fmt.Sprintf("HTTP adapter service started on port %s", cfg.port))
+		errs <- http.ListenAndServe(p, api.MakeHandler(svc, tracer))
 	}()
 
 	go func() {
@@ -95,3 +128,70 @@ func main() {
 	err = <-errs
 	logger.Error(fmt.Sprintf("HTTP adapter terminated: %s", err))
 }
+
+func loadConfig() config {
+	tls, err := strconv.ParseBool(mainflux.Env(envClientTLS, defClientTLS))
+	if err != nil {
+		log.Fatalf("Invalid value passed for %s\n", envClientTLS)
+	}
+
+	timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
+	}
+
+	return config{
+		thingsURL:     mainflux.Env(envThingsURL, defThingsURL),
+		natsURL:       mainflux.Env(envNatsURL, defNatsURL),
+		logLevel:      mainflux.Env(envLogLevel, defLogLevel),
+		port:          mainflux.Env(envPort, defPort),
+		clientTLS:     tls,
+		caCerts:       mainflux.Env(envCACerts, defCACerts),
+		jaegerURL:     mainflux.Env(envJaegerURL, defJaegerURL),
+		thingsTimeout: time.Duration(timeout) * time.Second,
+	}
+}
+
+func initJaeger(svcName, url string, logger logger.Logger) (opentracing.Tracer, io.Closer) {
+	tracer, closer, err := jconfig.Configuration{
+		ServiceName: svcName,
+		Sampler: &jconfig.SamplerConfig{
+			Type:  "const",
+			Param: 1,
+		},
+		Reporter: &jconfig.ReporterConfig{
+			LocalAgentHostPort: url,
+			LogSpans:           true,
+		},
+	}.NewTracer()
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger client: %s", err))
+		os.Exit(1)
+	}
+
+	return tracer, closer
+}
+
+func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
+	var opts []grpc.DialOption
+	if cfg.clientTLS {
+		if cfg.caCerts != "" {
+			tpc, err := credentials.NewClientTLSFromFile(cfg.caCerts, "")
+			if err != nil {
+				logger.Error(fmt.Sprintf("Failed to load certs: %s", err))
+				os.Exit(1)
+			}
+			opts = append(opts, grpc.WithTransportCredentials(tpc))
+		}
+	} else {
+		logger.Info("gRPC communication is not encrypted")
+		opts = append(opts, grpc.WithInsecure())
+	}
+
+	conn, err := grpc.Dial(cfg.thingsURL, opts...)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
+		os.Exit(1)
+	}
+	return conn
+}

cmd/influxdb-reader/main.go

@@ -0,0 +1,213 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"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/readers"
+	"github.com/mainflux/mainflux/readers/api"
+	"github.com/mainflux/mainflux/readers/influxdb"
+	thingsapi "github.com/mainflux/mainflux/things/api/auth/grpc"
+	opentracing "github.com/opentracing/opentracing-go"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	jconfig "github.com/uber/jaeger-client-go/config"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+)
+
+const (
+	defThingsURL     = "localhost:8181"
+	defLogLevel      = "error"
+	defPort          = "8180"
+	defDBName        = "mainflux"
+	defDBHost        = "localhost"
+	defDBPort        = "8086"
+	defDBUser        = "mainflux"
+	defDBPass        = "mainflux"
+	defClientTLS     = "false"
+	defCACerts       = ""
+	defJaegerURL     = "localhost:6831"
+	defThingsTimeout = "1" // in seconds
+
+	envThingsURL     = "MF_THINGS_URL"
+	envLogLevel      = "MF_INFLUX_READER_LOG_LEVEL"
+	envPort          = "MF_INFLUX_READER_PORT"
+	envDBName        = "MF_INFLUX_READER_DB_NAME"
+	envDBHost        = "MF_INFLUX_READER_DB_HOST"
+	envDBPort        = "MF_INFLUX_READER_DB_PORT"
+	envDBUser        = "MF_INFLUX_READER_DB_USER"
+	envDBPass        = "MF_INFLUX_READER_DB_PASS"
+	envClientTLS     = "MF_INFLUX_READER_CLIENT_TLS"
+	envCACerts       = "MF_INFLUX_READER_CA_CERTS"
+	envJaegerURL     = "MF_JAEGER_URL"
+	envThingsTimeout = "MF_INFLUX_READER_THINGS_TIMEOUT"
+)
+
+type config struct {
+	thingsURL     string
+	logLevel      string
+	port          string
+	dbName        string
+	dbHost        string
+	dbPort        string
+	dbUser        string
+	dbPass        string
+	clientTLS     bool
+	caCerts       string
+	jaegerURL     string
+	thingsTimeout time.Duration
+}
+
+func main() {
+	cfg, clientCfg := loadConfigs()
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+	conn := connectToThings(cfg, logger)
+	defer conn.Close()
+
+	thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
+	defer thingsCloser.Close()
+
+	tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
+
+	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 := newService(client, cfg.dbName, 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("InfluxDB writer service terminated: %s", err))
+}
+
+func loadConfigs() (config, influxdata.HTTPConfig) {
+	tls, err := strconv.ParseBool(mainflux.Env(envClientTLS, defClientTLS))
+	if err != nil {
+		log.Fatalf("Invalid value passed for %s\n", envClientTLS)
+	}
+
+	timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
+	}
+
+	cfg := config{
+		thingsURL:     mainflux.Env(envThingsURL, defThingsURL),
+		logLevel:      mainflux.Env(envLogLevel, defLogLevel),
+		port:          mainflux.Env(envPort, defPort),
+		dbName:        mainflux.Env(envDBName, defDBName),
+		dbHost:        mainflux.Env(envDBHost, defDBHost),
+		dbPort:        mainflux.Env(envDBPort, defDBPort),
+		dbUser:        mainflux.Env(envDBUser, defDBUser),
+		dbPass:        mainflux.Env(envDBPass, defDBPass),
+		clientTLS:     tls,
+		caCerts:       mainflux.Env(envCACerts, defCACerts),
+		jaegerURL:     mainflux.Env(envJaegerURL, defJaegerURL),
+		thingsTimeout: time.Duration(timeout) * time.Second,
+	}
+
+	clientCfg := influxdata.HTTPConfig{
+		Addr:     fmt.Sprintf("http://%s:%s", cfg.dbHost, cfg.dbPort),
+		Username: cfg.dbUser,
+		Password: cfg.dbPass,
+	}
+
+	return cfg, clientCfg
+}
+
+func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
+	var opts []grpc.DialOption
+	if cfg.clientTLS {
+		if cfg.caCerts != "" {
+			tpc, err := credentials.NewClientTLSFromFile(cfg.caCerts, "")
+			if err != nil {
+				logger.Error(fmt.Sprintf("Failed to load certs: %s", err))
+				os.Exit(1)
+			}
+			opts = append(opts, grpc.WithTransportCredentials(tpc))
+		}
+	} else {
+		logger.Info("gRPC communication is not encrypted")
+		opts = append(opts, grpc.WithInsecure())
+	}
+
+	conn, err := grpc.Dial(cfg.thingsURL, opts...)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to things service: %s", err))
+		os.Exit(1)
+	}
+	return conn
+}
+
+func initJaeger(svcName, url string, logger logger.Logger) (opentracing.Tracer, io.Closer) {
+	tracer, closer, err := jconfig.Configuration{
+		ServiceName: svcName,
+		Sampler: &jconfig.SamplerConfig{
+			Type:  "const",
+			Param: 1,
+		},
+		Reporter: &jconfig.ReporterConfig{
+			LocalAgentHostPort: url,
+			LogSpans:           true,
+		},
+	}.NewTracer()
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger client: %s", err))
+		os.Exit(1)
+	}
+
+	return tracer, closer
+}
+
+func newService(client influxdata.Client, dbName string, logger logger.Logger) readers.MessageRepository {
+	repo := influxdb.New(client, dbName)
+	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,211 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/BurntSushi/toml"
+	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/api"
+	"github.com/mainflux/mainflux/writers/influxdb"
+	nats "github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	svcName = "influxdb-writer"
+
+	defNatsURL      = nats.DefaultURL
+	defLogLevel     = "error"
+	defPort         = "8180"
+	defBatchSize    = "5000"
+	defBatchTimeout = "5"
+	defDBName       = "mainflux"
+	defDBHost       = "localhost"
+	defDBPort       = "8086"
+	defDBUser       = "mainflux"
+	defDBPass       = "mainflux"
+	defChanCfgPath  = "/config/channels.toml"
+
+	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"
+	envChanCfgPath  = "MF_INFLUX_WRITER_CHANNELS_CONFIG"
+)
+
+type config struct {
+	natsURL      string
+	logLevel     string
+	port         string
+	batchSize    string
+	batchTimeout string
+	dbName       string
+	dbHost       string
+	dbPort       string
+	dbUser       string
+	dbPass       string
+	channels     map[string]bool
+}
+
+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 = api.LoggingMiddleware(repo, logger)
+	repo = api.MetricsMiddleware(repo, counter, latency)
+	if err := writers.Start(nc, repo, svcName, cfg.channels, logger); err != nil {
+		logger.Error(fmt.Sprintf("Failed to start 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 startHTTPService(cfg.port, logger, errs)
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("InfluxDB writer service terminated: %s", err))
+}
+
+func loadConfigs() (config, influxdata.HTTPConfig) {
+	chanCfgPath := mainflux.Env(envChanCfgPath, defChanCfgPath)
+	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),
+		channels:     loadChansConfig(chanCfgPath),
+	}
+
+	clientCfg := influxdata.HTTPConfig{
+		Addr:     fmt.Sprintf("http://%s:%s", cfg.dbHost, cfg.dbPort),
+		Username: cfg.dbUser,
+		Password: cfg.dbPass,
+	}
+
+	return cfg, clientCfg
+}
+
+type channels struct {
+	List []string `toml:"filter"`
+}
+
+type chanConfig struct {
+	Channels channels `toml:"channels"`
+}
+
+func loadChansConfig(chanConfigPath string) map[string]bool {
+	data, err := ioutil.ReadFile(chanConfigPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var chanCfg chanConfig
+	if err := toml.Unmarshal(data, &chanCfg); err != nil {
+		log.Fatal(err)
+	}
+
+	chans := map[string]bool{}
+	for _, ch := range chanCfg.Channels.List {
+		chans[ch] = true
+	}
+
+	return chans
+}
+
+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, api.MakeHandler(svcName))
+}

cmd/lora/main.go

@@ -0,0 +1,220 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+
+	mqtt "github.com/eclipse/paho.mqtt.golang"
+	r "github.com/go-redis/redis"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/lora"
+	"github.com/mainflux/mainflux/lora/api"
+	pub "github.com/mainflux/mainflux/lora/nats"
+	mqttBroker "github.com/mainflux/mainflux/lora/paho"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/mainflux/mainflux/lora/redis"
+	nats "github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	defHTTPPort     = "8180"
+	defLoraMsgURL   = "tcp://localhost:1883"
+	defNatsURL      = nats.DefaultURL
+	defLogLevel     = "error"
+	defESURL        = "localhost:6379"
+	defESPass       = ""
+	defESDB         = "0"
+	defInstanceName = "lora"
+	defRouteMapURL  = "localhost:6379"
+	defRouteMapPass = ""
+	defRouteMapDB   = "0"
+
+	envHTTPPort     = "MF_LORA_ADAPTER_HTTP_PORT"
+	envLoraMsgURL   = "MF_LORA_ADAPTER_MESSAGES_URL"
+	envNatsURL      = "MF_NATS_URL"
+	envLogLevel     = "MF_LORA_ADAPTER_LOG_LEVEL"
+	envESURL        = "MF_THINGS_ES_URL"
+	envESPass       = "MF_THINGS_ES_PASS"
+	envESDB         = "MF_THINGS_ES_DB"
+	envInstanceName = "MF_LORA_ADAPTER_INSTANCE_NAME"
+	envRouteMapURL  = "MF_LORA_ADAPTER_ROUTEMAP_URL"
+	envRouteMapPass = "MF_LORA_ADAPTER_ROUTEMAP_PASS"
+	envRouteMapDB   = "MF_LORA_ADAPTER_ROUTEMAP_DB"
+
+	loraServerTopic = "application/+/device/+/rx"
+
+	thingsRMPrefix   = "thing"
+	channelsRMPrefix = "channel"
+)
+
+type config struct {
+	httpPort     string
+	loraMsgURL   string
+	natsURL      string
+	logLevel     string
+	esURL        string
+	esPass       string
+	esDB         string
+	instanceName string
+	routeMapURL  string
+	routeMapPass string
+	routeMapDB   string
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	natsConn := connectToNATS(cfg.natsURL, logger)
+	defer natsConn.Close()
+
+	rmConn := connectToRedis(cfg.routeMapURL, cfg.routeMapPass, cfg.routeMapDB, logger)
+	defer rmConn.Close()
+
+	esConn := connectToRedis(cfg.esURL, cfg.esPass, cfg.esDB, logger)
+	defer esConn.Close()
+
+	publisher := pub.NewMessagePublisher(natsConn)
+
+	thingRM := newRouteMapRepositoy(rmConn, thingsRMPrefix, logger)
+	chanRM := newRouteMapRepositoy(rmConn, channelsRMPrefix, logger)
+
+	mqttConn := connectToMQTTBroker(cfg.loraMsgURL, logger)
+
+	svc := lora.New(publisher, thingRM, chanRM)
+	svc = api.LoggingMiddleware(svc, logger)
+	svc = api.MetricsMiddleware(
+		svc,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "lora_adapter",
+			Subsystem: "api",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "lora_adapter",
+			Subsystem: "api",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+
+	go subscribeToLoRaBroker(svc, mqttConn, logger)
+	go subscribeToThingsES(svc, esConn, cfg.instanceName, logger)
+
+	errs := make(chan error, 2)
+
+	go startHTTPServer(cfg, 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("LoRa adapter terminated: %s", err))
+}
+
+func loadConfig() config {
+	return config{
+		httpPort:     mainflux.Env(envHTTPPort, defHTTPPort),
+		loraMsgURL:   mainflux.Env(envLoraMsgURL, defLoraMsgURL),
+		natsURL:      mainflux.Env(envNatsURL, defNatsURL),
+		logLevel:     mainflux.Env(envLogLevel, defLogLevel),
+		esURL:        mainflux.Env(envESURL, defESURL),
+		esPass:       mainflux.Env(envESPass, defESPass),
+		esDB:         mainflux.Env(envESDB, defESDB),
+		instanceName: mainflux.Env(envInstanceName, defInstanceName),
+		routeMapURL:  mainflux.Env(envRouteMapURL, defRouteMapURL),
+		routeMapPass: mainflux.Env(envRouteMapPass, defRouteMapPass),
+		routeMapDB:   mainflux.Env(envRouteMapDB, defRouteMapDB),
+	}
+}
+
+func connectToNATS(url string, logger logger.Logger) *nats.Conn {
+	conn, err := nats.Connect(url)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
+		os.Exit(1)
+	}
+
+	logger.Info("Connected to NATS")
+	return conn
+}
+
+func connectToMQTTBroker(loraURL string, logger logger.Logger) mqtt.Client {
+	opts := mqtt.NewClientOptions()
+	opts.AddBroker(loraURL)
+	opts.SetUsername("")
+	opts.SetPassword("")
+	opts.SetOnConnectHandler(func(c mqtt.Client) {
+		logger.Info("Connected to Lora MQTT broker")
+	})
+	opts.SetConnectionLostHandler(func(c mqtt.Client, err error) {
+		logger.Error(fmt.Sprintf("MQTT connection lost: %s", err.Error()))
+		os.Exit(1)
+	})
+
+	client := mqtt.NewClient(opts)
+	if token := client.Connect(); token.Wait() && token.Error() != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to Lora MQTT broker: %s", token.Error()))
+		os.Exit(1)
+	}
+
+	return client
+}
+
+func connectToRedis(redisURL, redisPass, redisDB string, logger logger.Logger) *r.Client {
+	db, err := strconv.Atoi(redisDB)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to redis: %s", err))
+		os.Exit(1)
+	}
+
+	return r.NewClient(&r.Options{
+		Addr:     redisURL,
+		Password: redisPass,
+		DB:       db,
+	})
+}
+
+func subscribeToLoRaBroker(svc lora.Service, mc mqtt.Client, logger logger.Logger) {
+	mqttBroker := mqttBroker.NewBroker(svc, mc, logger)
+	logger.Info("Subscribed to Lora MQTT broker")
+	if err := mqttBroker.Subscribe(loraServerTopic); err != nil {
+		logger.Error(fmt.Sprintf("Failed to subscribe to Lora MQTT broker: %s", err))
+		os.Exit(1)
+	}
+}
+
+func subscribeToThingsES(svc lora.Service, client *r.Client, consumer string, logger logger.Logger) {
+	eventStore := redis.NewEventStore(svc, client, consumer, logger)
+	logger.Info("Subscribed to Redis Event Store")
+	if err := eventStore.Subscribe("mainflux.things"); err != nil {
+		logger.Warn(fmt.Sprintf("Lora-adapter service failed to subscribe to event sourcing: %s", err))
+	}
+}
+
+func newRouteMapRepositoy(client *r.Client, prefix string, logger logger.Logger) lora.RouteMapRepository {
+	logger.Info("Connected to Redis Route map")
+	return redis.NewRouteMapRepository(client, prefix)
+}
+
+func startHTTPServer(cfg config, logger logger.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", cfg.httpPort)
+	logger.Info(fmt.Sprintf("Lora-adapter service started, exposed port %s", cfg.httpPort))
+	errs <- http.ListenAndServe(p, api.MakeHandler())
+}

cmd/mongodb-reader/main.go

@@ -0,0 +1,213 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	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/auth/grpc"
+	opentracing "github.com/opentracing/opentracing-go"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	jconfig "github.com/uber/jaeger-client-go/config"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+)
+
+const (
+	defThingsURL     = "localhost:8181"
+	defLogLevel      = "error"
+	defPort          = "8180"
+	defDBName        = "mainflux"
+	defDBHost        = "localhost"
+	defDBPort        = "27017"
+	defClientTLS     = "false"
+	defCACerts       = ""
+	defJaegerURL     = "localhost:6831"
+	defThingsTimeout = "1" // in seconds
+
+	envThingsURL     = "MF_THINGS_URL"
+	envLogLevel      = "MF_MONGO_READER_LOG_LEVEL"
+	envPort          = "MF_MONGO_READER_PORT"
+	envDBName        = "MF_MONGO_READER_DB_NAME"
+	envDBHost        = "MF_MONGO_READER_DB_HOST"
+	envDBPort        = "MF_MONGO_READER_DB_PORT"
+	envClientTLS     = "MF_MONGO_READER_CLIENT_TLS"
+	envCACerts       = "MF_MONGO_READER_CA_CERTS"
+	envJaegerURL     = "MF_JAEGER_URL"
+	envThingsTimeout = "MF_MONGO_READER_THINGS_TIMEOUT"
+)
+
+type config struct {
+	thingsURL     string
+	logLevel      string
+	port          string
+	dbName        string
+	dbHost        string
+	dbPort        string
+	clientTLS     bool
+	caCerts       string
+	jaegerURL     string
+	thingsTimeout time.Duration
+}
+
+func main() {
+	cfg := loadConfigs()
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	conn := connectToThings(cfg, logger)
+	defer conn.Close()
+
+	thingsTracer, thingsCloser := initJaeger("things", cfg.jaegerURL, logger)
+	defer thingsCloser.Close()
+
+	tc := thingsapi.NewClient(conn, thingsTracer, cfg.thingsTimeout)
+
+	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 {
+	tls, err := strconv.ParseBool(mainflux.Env(envClientTLS, defClientTLS))
+	if err != nil {
+		log.Fatalf("Invalid value passed for %s\n", envClientTLS)
+	}
+
+	timeout, err := strconv.ParseInt(mainflux.Env(envThingsTimeout, defThingsTimeout), 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid %s value: %s", envThingsTimeout, err.Error())
+	}
+
+	return config{
+		thingsURL:     mainflux.Env(envThingsURL, defThingsURL),
+		logLevel:      mainflux.Env(envLogLevel, defLogLevel),
+		port:          mainflux.Env(envPort, defPort),
+		dbName:        mainflux.Env(envDBName, defDBName),
+		dbHost:        mainflux.Env(envDBHost, defDBHost),
+		dbPort:        mainflux.Env(envDBPort, defDBPort),
+		clientTLS:     tls,
+		caCerts:       mainflux.Env(envCACerts, defCACerts),
+		jaegerURL:     mainflux.Env(envJaegerURL, defJaegerURL),
+		thingsTimeout: time.Duration(timeout) * time.Second,
+	}
+}
+
+func connectToMongoDB(host, port, name string, logger logger.Logger) *mongo.Database {
+	addr := fmt.Sprintf("mongodb://%s:%s", host, port)
+	client, err := mongo.Connect(context.Background(), options.Client().ApplyURI(addr))
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to database: %s", err))
+		os.Exit(1)
+	}
+
+	return client.Database(name)
+}
+
+func initJaeger(svcName, url string, logger logger.Logger) (opentracing.Tracer, io.Closer) {
+	tracer, closer, err := jconfig.Configuration{
+		ServiceName: svcName,
+		Sampler: &jconfig.SamplerConfig{
+			Type:  "const",
+			Param: 1,
+		},
+		Reporter: &jconfig.ReporterConfig{
+			LocalAgentHostPort: url,
+			LogSpans:           true,
+		},
+	}.NewTracer()
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger client: %s", err))
+		os.Exit(1)
+	}
+
+	return tracer, closer
+}
+
+func connectToThings(cfg config, logger logger.Logger) *grpc.ClientConn {
+	var opts []grpc.DialOption
+	if cfg.clientTLS {
+		if cfg.caCerts != "" {
+			tpc, err := credentials.NewClientTLSFromFile(cfg.caCerts, "")
+			if err != nil {
+				logger.Error(fmt.Sprintf("Failed to load certs: %s", err))
+				os.Exit(1)
+			}
+			opts = append(opts, grpc.WithTransportCredentials(tpc))
+		}
+	} else {
+		logger.Info("gRPC communication is not encrypted")
+		opts = append(opts, grpc.WithInsecure())
+	}
+
+	conn, err := grpc.Dial(cfg.thingsURL, opts...)
+	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, "mongodb-reader"))
+}

cmd/mongodb-writer/main.go

@@ -0,0 +1,171 @@
+//
+// Copyright (c) 2018
+// Mainflux
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/BurntSushi/toml"
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/writers"
+	"github.com/mainflux/mainflux/writers/api"
+	"github.com/mainflux/mainflux/writers/mongodb"
+	nats "github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+const (
+	svcName = "mongodb-writer"
+
+	defNatsURL     = nats.DefaultURL
+	defLogLevel    = "error"
+	defPort        = "8180"
+	defDBName      = "mainflux"
+	defDBHost      = "localhost"
+	defDBPort      = "27017"
+	defChanCfgPath = "/config/channels.toml"
+
+	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"
+	envChanCfgPath = "MF_MONGO_WRITER_CHANNELS_CONFIG"
+)
+
+type config struct {
+	natsURL  string
+	logLevel string
+	port     string
+	dbName   string
+	dbHost   string
+	dbPort   string
+	channels map[string]bool
+}
+
+func main() {
+	cfg := loadConfigs()
+
+	logger, err := logger.New(os.Stdout, cfg.logLevel)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	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()
+
+	addr := fmt.Sprintf("mongodb://%s:%s", cfg.dbHost, cfg.dbPort)
+	client, err := mongo.Connect(context.Background(), options.Client().ApplyURI(addr))
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to database: %s", err))
+		os.Exit(1)
+	}
+
+	db := client.Database(cfg.dbName)
+	repo := mongodb.New(db)
+
+	counter, latency := makeMetrics()
+	repo = api.LoggingMiddleware(repo, logger)
+	repo = api.MetricsMiddleware(repo, counter, latency)
+	if err := writers.Start(nc, repo, svcName, cfg.channels, logger); err != nil {
+		logger.Error(fmt.Sprintf("Failed to start MongoDB 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("MongoDB writer service terminated: %s", err))
+}
+
+func loadConfigs() config {
+	chanCfgPath := mainflux.Env(envChanCfgPath, defChanCfgPath)
+	return config{
+		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),
+		channels: loadChansConfig(chanCfgPath),
+	}
+}
+
+type channels struct {
+	List []string `toml:"filter"`
+}
+
+type chanConfig struct {
+	Channels channels `toml:"channels"`
+}
+
+func loadChansConfig(chanConfigPath string) map[string]bool {
+	data, err := ioutil.ReadFile(chanConfigPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var chanCfg chanConfig
+	if err := toml.Unmarshal(data, &chanCfg); err != nil {
+		log.Fatal(err)
+	}
+
+	chans := map[string]bool{}
+	for _, ch := range chanCfg.Channels.List {
+		chans[ch] = true
+	}
+
+	return chans
+}
+
+func makeMetrics() (*kitprometheus.Counter, *kitprometheus.Summary) {
+	counter := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+		Namespace: "mongodb",
+		Subsystem: "message_writer",
+		Name:      "request_count",
+		Help:      "Number of database inserts.",
+	}, []string{"method"})
+
+	latency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+		Namespace: "mongodb",
+		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("Mongodb writer service started, exposed port %s", p))
+	errs <- http.ListenAndServe(p, api.MakeHandler(svcName))
+}