things

README

Things

Things service provides an HTTP API for managing platform resources: things and profiles. Through this API clients are able to do the following actions:

• provision new things
• create new profiles
• "connect" things into the profiles

For an in-depth explanation of the aforementioned scenarios, as well as thorough understanding of Mainflux, please check out the official documentation.

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_THINGS_LOG_LEVEL	Log level for Things (debug, info, warn, error)	error
MF_THINGS_DB_HOST	Database host address	localhost
MF_THINGS_DB_PORT	Database host port	5432
MF_THINGS_DB_USER	Database user	mainflux
MF_THINGS_DB_PASS	Database password	mainflux
MF_THINGS_DB	Name of the database used by the service	things
MF_THINGS_DB_SSL_MODE	Database connection SSL mode (disable, require, verify-ca, verify-full)	disable
MF_THINGS_DB_SSL_CERT	Path to the PEM encoded certificate file
MF_THINGS_DB_SSL_KEY	Path to the PEM encoded key file
MF_THINGS_DB_SSL_ROOT_CERT	Path to the PEM encoded root certificate file
MF_THINGS_CLIENT_TLS	Flag that indicates if TLS should be turned on	false
MF_THINGS_CA_CERTS	Path to trusted CAs in PEM format
MF_THINGS_CACHE_URL	Cache database URL	localhost:6379
MF_THINGS_CACHE_PASS	Cache database password
MF_THINGS_CACHE_DB	Cache instance name	0
MF_THINGS_ES_URL	Event store URL	localhost:6379
MF_THINGS_ES_PASS	Event store password
MF_THINGS_ES_DB	Event store instance name	0
MF_THINGS_HTTP_PORT	Things service HTTP port	8182
MF_THINGS_AUTH_HTTP_PORT	Things service Auth HTTP port	8989
MF_THINGS_AUTH_GRPC_PORT	Things service Auth gRPC port	8181
MF_THINGS_SERVER_CERT	Path to server certificate in pem format
MF_THINGS_SERVER_KEY	Path to server key in pem format
MF_THINGS_STANDALONE_EMAIL	User email for standalone mode (no gRPC communication with users)
MF_THINGS_STANDALONE_TOKEN	User token for standalone mode that should be passed in auth header
MF_JAEGER_URL	Jaeger server URL	localhost:6831
MF_AUTH_GRPC_URL	Auth service gRPC URL	localhost:8181
MF_AUTH_GRPC_TIMEOUT	Auth service gRPC request timeout in seconds	1s

Note that if you want things service to have only one user locally, you should use MF_THINGS_STANDALONE env vars. By specifying these, you don't need auth service in your deployment for users' authorization.

Deployment

The service itself is distributed as Docker container. Check the things service section in docker-compose to see how service is deployed.

To start the service outside of the container, execute the following shell script:

# download the latest version of the service
git clone https://github.com/MainfluxLabs/mainflux

cd mainflux

# compile the things
make things

# copy binary to bin
make install

# set the environment variables and run the service
MF_THINGS_LOG_LEVEL=[Things log level] \
MF_THINGS_DB_HOST=[Database host address] \
MF_THINGS_DB_PORT=[Database host port] \
MF_THINGS_DB_USER=[Database user] \
MF_THINGS_DB_PASS=[Database password] \
MF_THINGS_DB=[Name of the database used by the service] \
MF_THINGS_DB_SSL_MODE=[SSL mode to connect to the database with] \
MF_THINGS_DB_SSL_CERT=[Path to the PEM encoded certificate file] \
MF_THINGS_DB_SSL_KEY=[Path to the PEM encoded key file] \
MF_THINGS_DB_SSL_ROOT_CERT=[Path to the PEM encoded root certificate file] \
MF_HTTP_ADAPTER_CA_CERTS=[Path to trusted CAs in PEM format] \
MF_THINGS_CACHE_URL=[Cache database URL] \
MF_THINGS_CACHE_PASS=[Cache database password] \
MF_THINGS_CACHE_DB=[Cache instance name] \
MF_THINGS_ES_URL=[Event store URL] \
MF_THINGS_ES_PASS=[Event store password] \
MF_THINGS_ES_DB=[Event store instance name] \
MF_THINGS_HTTP_PORT=[Things service HTTP port] \
MF_THINGS_AUTH_HTTP_PORT=[Things service Auth HTTP port] \
MF_THINGS_AUTH_GRPC_PORT=[Things service Auth gRPC port] \
MF_THINGS_SERVER_CERT=[Path to server certificate] \
MF_THINGS_SERVER_KEY=[Path to server key] \
MF_THINGS_STANDALONE_EMAIL=[User email for standalone mode (no gRPC communication with auth)] \
MF_THINGS_STANDALONE_TOKEN=[User token for standalone mode that should be passed in auth header] \
MF_JAEGER_URL=[Jaeger server URL] \
MF_AUTH_GRPC_URL=[Auth service gRPC URL] \
MF_AUTH_GRPC_TIMEOUT=[Auth service gRPC request timeout in seconds] \
$GOBIN/mainfluxlabs-things

Setting MF_THINGS_CA_CERTS expects a file in PEM format of trusted CAs. This will enable TLS against the Users gRPC endpoint trusting only those CAs that are provided.

In constrained environments, sometimes it makes sense to run Things service as a standalone to reduce network traffic and simplify deployment. This means that Things service operates only using a single user and is able to authorize it without gRPC communication with Auth service. To run service in a standalone mode, set MF_THINGS_STANDALONE_EMAIL and MF_THINGS_STANDALONE_TOKEN.

Usage

For more information about service capabilities and its usage, please check out the API documentation.

Documentation

Overview

Package things contains the domain concept definitions needed to support Mainflux things service functionality.

Index

• Constants
• type AuthorizeReq
• type Backup
• type Config
• type Group
• type GroupMember
• type GroupMembersPage
• type GroupPage
• type GroupRepository
• type Groups
• type Identity
• type Metadata
• type Notifier
• type NotifiersPage
• type PageMetadata
• type Profile
• type ProfileCache
• type ProfileRepository
• type ProfilesPage
• type PubConfInfo
• type Roles
• type RolesRepository
• type Service
  • func New(auth protomfx.AuthServiceClient, users protomfx.UsersServiceClient, ...) Service
• type Thing
• type ThingCache
• type ThingRepository
• type ThingsPage
• type Transformer

Constants

const (
	Viewer     = "viewer"
	Editor     = "editor"
	Admin      = "admin"
	Owner      = "owner"
	ThingSub   = "thing"
	ProfileSub = "profile"
	GroupSub   = "group"
)

Types

type AuthorizeReq

type AuthorizeReq struct {
	Token   string
	Object  string
	Subject string
	Action  string
}

type Backup

type Backup struct {
	Things     []Thing
	Profiles   []Profile
	Groups     []Group
	GroupRoles []GroupMember
}

type Config

type Config struct {
	ContentType string      `json:"content_type"`
	Write       bool        `json:"write"`
	WebhookID   string      `json:"webhook_id"`
	Transformer Transformer `json:"transformer"`
	SmtpID      string      `json:"smtp_id"`
	SmppID      string      `json:"smpp_id"`
}

type Group

type Group struct {
	ID          string
	OrgID       string
	Name        string
	Description string
	Metadata    Metadata
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

Group represents the group information.

type GroupMember

type GroupMember struct {
	GroupID  string
	MemberID string
	Email    string
	Role     string
}

type GroupMembersPage

type GroupMembersPage struct {
	PageMetadata
	GroupMembers []GroupMember
}

type GroupPage

type GroupPage struct {
	PageMetadata
	Groups []Group
}

GroupPage contains page related metadata as well as list of groups that belong to this page.

type GroupRepository

type GroupRepository interface {
	// Save group
	Save(ctx context.Context, g Group) (Group, error)

	// Update a group
	Update(ctx context.Context, g Group) (Group, error)

	// Remove a groups
	Remove(ctx context.Context, groupIDs ...string) error

	// RetrieveByID retrieves group by its id
	RetrieveByID(ctx context.Context, id string) (Group, error)

	// RetrieveByIDs retrieves groups by their ids
	RetrieveByIDs(ctx context.Context, groupIDs []string, pm PageMetadata) (GroupPage, error)

	// RetrieveAll retrieves all groups.
	RetrieveAll(ctx context.Context) ([]Group, error)

	// RetrieveByAdmin retrieves all groups with pagination.
	RetrieveByAdmin(ctx context.Context, orgID string, pm PageMetadata) (GroupPage, error)
}

GroupRepository specifies a group persistence API.

type Groups

type Groups interface {
	// CreateGroups adds groups to the user identified by the provided key.
	CreateGroups(ctx context.Context, token string, groups ...Group) ([]Group, error)

	// UpdateGroup updates the group identified by the provided ID.
	UpdateGroup(ctx context.Context, token string, g Group) (Group, error)

	// ViewGroup retrieves data about the group identified by ID.
	ViewGroup(ctx context.Context, token, id string) (Group, error)

	// ListGroups retrieves groups.
	ListGroups(ctx context.Context, token, orgID string, pm PageMetadata) (GroupPage, error)

	// ListGroupsByIDs retrieves groups by their IDs.
	ListGroupsByIDs(ctx context.Context, ids []string) ([]Group, error)

	// ListThingsByGroup retrieves page of things that are assigned to a group identified by ID.
	ListThingsByGroup(ctx context.Context, token string, groupID string, pm PageMetadata) (ThingsPage, error)

	// ListProfilesByGroup retrieves page of profiles that are assigned to a group identified by ID.
	ListProfilesByGroup(ctx context.Context, token string, groupID string, pm PageMetadata) (ProfilesPage, error)

	// ViewGroupByThing retrieves group that thing belongs to.
	ViewGroupByThing(ctx context.Context, token, thingID string) (Group, error)

	// RemoveGroups removes the groups identified with the provided IDs.
	RemoveGroups(ctx context.Context, token string, ids ...string) error

	// ViewGroupByProfile retrieves group that profile belongs to.
	ViewGroupByProfile(ctx context.Context, token, profileID string) (Group, error)
}

type Identity

type Identity struct {
	ID    string
	Email string
}

Identity contains ID and Email.

type Metadata

type Metadata map[string]interface{}

Metadata to be used for Mainflux thing or profile for customized describing of particular thing or profile.

type Notifier

type Notifier struct {
	ID       string
	GroupID  string
	Name     string
	Contacts []string
	Metadata Metadata
}

type NotifiersPage

type NotifiersPage struct {
	PageMetadata
	Notifiers []Notifier
}

type PageMetadata

type PageMetadata struct {
	Total    uint64
	Offset   uint64                 `json:"offset,omitempty"`
	Limit    uint64                 `json:"limit,omitempty"`
	Name     string                 `json:"name,omitempty"`
	Order    string                 `json:"order,omitempty"`
	Dir      string                 `json:"dir,omitempty"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

PageMetadata contains page metadata that helps navigation.

type Profile

type Profile struct {
	ID       string
	GroupID  string
	Name     string
	Config   map[string]interface{}
	Metadata map[string]interface{}
}

Profile represents a Mainflux "communication group". This group contains the things that can exchange messages between each other.

type ProfileCache

type ProfileCache interface {
	// Remove removes profile from cache.
	Remove(context.Context, string) error
}

ProfileCache contains profile caching interface.

type ProfileRepository

type ProfileRepository interface {
	// Save persists multiple profiles. Profiles are saved using a transaction. If one profile
	// fails then none will be saved. Successful operation is indicated by non-nil
	// error response.
	Save(ctx context.Context, prs ...Profile) ([]Profile, error)

	// Update performs an update to the existing profile. A non-nil error is
	// returned to indicate operation failure.
	Update(ctx context.Context, c Profile) error

	// RetrieveByID retrieves the profile having the provided identifier, that is owned
	// by the specified user.
	RetrieveByID(ctx context.Context, id string) (Profile, error)

	// RetrieveByThing retrieves the profile connected to the given thing id.
	RetrieveByThing(ctx context.Context, thID string) (Profile, error)

	// Remove removes the profiles having the provided identifiers, that is owned
	// by the specified user.
	Remove(ctx context.Context, id ...string) error

	// RetrieveAll retrieves all profiles for all users.
	RetrieveAll(ctx context.Context) ([]Profile, error)

	// RetrieveByAdmin  retrieves all profiles for all users with pagination.
	RetrieveByAdmin(ctx context.Context, pm PageMetadata) (ProfilesPage, error)

	// RetrieveByGroupIDs retrieves the subset of profiles specified by given group ids.
	RetrieveByGroupIDs(ctx context.Context, groupIDs []string, pm PageMetadata) (ProfilesPage, error)
}

ProfileRepository specifies a profile persistence API.

type ProfilesPage

type ProfilesPage struct {
	PageMetadata
	Profiles []Profile
}

ProfilesPage contains page related metadata as well as list of profiles that belong to this page.

type PubConfInfo

type PubConfInfo struct {
	PublisherID   string
	ProfileConfig map[string]interface{}
}

type Roles

type Roles interface {
	// CreateRolesByGroup creates roles of the group identified by the provided ID.
	CreateRolesByGroup(ctx context.Context, token string, gms ...GroupMember) error

	// ListRolesByGroup retrieves a page of roles for a group that is identified by the provided ID.
	ListRolesByGroup(ctx context.Context, token, groupID string, pm PageMetadata) (GroupMembersPage, error)

	// UpdateRolesByGroup updates roles of the group identified by the provided ID.
	UpdateRolesByGroup(ctx context.Context, token string, gms ...GroupMember) error

	// RemoveRolesByGroup removes roles of the group identified by the provided ID.
	RemoveRolesByGroup(ctx context.Context, token, groupID string, memberIDs ...string) error
}

type RolesRepository

type RolesRepository interface {
	// SaveRolesByGroup saves group roles by group ID.
	SaveRolesByGroup(ctx context.Context, gms ...GroupMember) error

	// RetrieveRole retrieves group role by group ID.
	RetrieveRole(ctc context.Context, gp GroupMember) (string, error)

	// RetrieveRolesByGroup retrieves page of group roles by groupID.
	RetrieveRolesByGroup(ctx context.Context, groupID string, pm PageMetadata) (GroupMembersPage, error)

	// RetrieveAllRolesByGroup retrieves all group roles by group ID. This is used for backup.
	RetrieveAllRolesByGroup(ctx context.Context) ([]GroupMember, error)

	// RetrieveGroupIDsByMember retrieves the IDs of the groups to which the member belongs
	RetrieveGroupIDsByMember(ctx context.Context, memberID string) ([]string, error)

	// RemoveRolesByGroup removes group roles by group ID.
	RemoveRolesByGroup(ctx context.Context, groupID string, memberIDs ...string) error

	// UpdateRolesByGroup updates group roles by group ID.
	UpdateRolesByGroup(ctx context.Context, gms ...GroupMember) error
}

type Service

type Service interface {
	// CreateThings adds things to the user identified by the provided key.
	CreateThings(ctx context.Context, token string, things ...Thing) ([]Thing, error)

	// UpdateThing updates the thing identified by the provided ID, that
	// belongs to the user identified by the provided key.
	UpdateThing(ctx context.Context, token string, thing Thing) error

	// UpdateKey updates key value of the existing thing. A non-nil error is
	// returned to indicate operation failure.
	UpdateKey(ctx context.Context, token, id, key string) error

	// ViewThing retrieves data about the thing identified with the provided
	// ID, that belongs to the user identified by the provided key.
	ViewThing(ctx context.Context, token, id string) (Thing, error)

	// ListThings retrieves data about subset of things that belongs to the
	// user identified by the provided key.
	ListThings(ctx context.Context, token string, pm PageMetadata) (ThingsPage, error)

	// ListThingsByProfile retrieves data about subset of things that are
	// connected or not connected to specified profile and belong to the user identified by
	// the provided key.
	ListThingsByProfile(ctx context.Context, token, prID string, pm PageMetadata) (ThingsPage, error)

	// RemoveThings removes the things identified with the provided IDs, that
	// belongs to the user identified by the provided key.
	RemoveThings(ctx context.Context, token string, id ...string) error

	// CreateProfiles adds profiles to the user identified by the provided key.
	CreateProfiles(ctx context.Context, token string, profiles ...Profile) ([]Profile, error)

	// UpdateProfile updates the profile identified by the provided ID, that
	// belongs to the user identified by the provided key.
	UpdateProfile(ctx context.Context, token string, profile Profile) error

	// ViewProfile retrieves data about the profile identified by the provided
	// ID, that belongs to the user identified by the provided key.
	ViewProfile(ctx context.Context, token, id string) (Profile, error)

	// ListProfiles retrieves data about subset of profiles that belongs to the
	// user identified by the provided key.
	ListProfiles(ctx context.Context, token string, pm PageMetadata) (ProfilesPage, error)

	// ViewProfileByThing retrieves data about profile that have
	// specified thing connected or not connected to it and belong to the user identified by
	// the provided key.
	ViewProfileByThing(ctx context.Context, token, thID string) (Profile, error)

	// RemoveProfiles removes the things identified by the provided IDs, that
	// belongs to the user identified by the provided key.
	RemoveProfiles(ctx context.Context, token string, ids ...string) error

	// GetPubConfByKey determines whether the profile can be accessed using the
	// provided key and returns thing's id if access is allowed.
	GetPubConfByKey(ctx context.Context, key string) (PubConfInfo, error)

	// GetConfigByThingID returns profile config for given thing ID.
	GetConfigByThingID(ctx context.Context, thingID string) (map[string]interface{}, error)

	// Authorize determines whether the group and its things and profiles can be accessed by
	// the given user and returns error if it cannot.
	Authorize(ctx context.Context, req AuthorizeReq) error

	// Identify returns thing ID for given thing key.
	Identify(ctx context.Context, key string) (string, error)

	// GetGroupIDByThingID returns a thing's group ID for given thing ID.
	GetGroupIDByThingID(ctx context.Context, thingID string) (string, error)

	// Backup retrieves all things, profiles, groups, and groups roles for all users. Only accessible by admin.
	Backup(ctx context.Context, token string) (Backup, error)

	// Restore adds things, profiles, groups, and groups roles from a backup. Only accessible by admin.
	Restore(ctx context.Context, token string, backup Backup) error

	Groups

	Roles
}

Service specifies an API that must be fullfiled by the domain service implementation, and all of its decorators (e.g. logging & metrics).

func New

func New(auth protomfx.AuthServiceClient, users protomfx.UsersServiceClient, things ThingRepository, profiles ProfileRepository, groups GroupRepository, roles RolesRepository, pcache ProfileCache, tcache ThingCache, idp uuid.IDProvider) Service

New instantiates the things service implementation.

type Thing

type Thing struct {
	ID        string
	GroupID   string
	ProfileID string
	Name      string
	Key       string
	Metadata  Metadata
}

Thing represents a Mainflux thing. Each thing is owned by one user, and it is assigned with the unique identifier and (temporary) access key.

type ThingCache

type ThingCache interface {
	// Save stores pair thing key, thing id.
	Save(context.Context, string, string) error

	// ID returns thing ID for given key.
	ID(context.Context, string) (string, error)

	// Remove removes thing from cache.
	Remove(context.Context, string) error

	// SaveRole stores pair groupID:memberID, role.
	SaveRole(context.Context, string, string, string) error

	// Role returns group member role by given groupID and memberID.
	Role(context.Context, string, string) (string, error)

	// RemoveRole removes group member role from cache.
	RemoveRole(context.Context, string, string) error
}

ThingCache contains thing caching interface.

type ThingRepository

type ThingRepository interface {
	// Save persists multiple things. Things are saved using a transaction. If one thing
	// fails then none will be saved. Successful operation is indicated by non-nil
	// error response.
	Save(ctx context.Context, ths ...Thing) ([]Thing, error)

	// Update performs an update to the existing thing. A non-nil error is
	// returned to indicate operation failure.
	Update(ctx context.Context, t Thing) error

	// UpdateKey updates key value of the existing thing. A non-nil error is
	// returned to indicate operation failure.
	UpdateKey(ctx context.Context, id, key string) error

	// RetrieveByID retrieves the thing having the provided identifier, that is owned
	// by the specified user.
	RetrieveByID(ctx context.Context, id string) (Thing, error)

	// RetrieveByKey returns thing ID for given thing key.
	RetrieveByKey(ctx context.Context, key string) (string, error)

	// RetrieveByGroupIDs retrieves the subset of things specified by given group ids.
	RetrieveByGroupIDs(ctx context.Context, groupIDs []string, pm PageMetadata) (ThingsPage, error)

	// RetrieveByProfile retrieves the subset of things assigned to the specified profile.
	RetrieveByProfile(ctx context.Context, prID string, pm PageMetadata) (ThingsPage, error)

	// Remove removes the things having the provided identifiers, that is owned
	// by the specified user.
	Remove(ctx context.Context, ids ...string) error

	// RetrieveAll retrieves all things for all users.
	RetrieveAll(ctx context.Context) ([]Thing, error)

	// RetrieveByAdmin retrieves all things for all users with pagination.
	RetrieveByAdmin(ctx context.Context, pm PageMetadata) (ThingsPage, error)
}

ThingRepository specifies a thing persistence API.

type ThingsPage

type ThingsPage struct {
	PageMetadata
	Things []Thing
}

ThingsPage contains page related metadata as well as list of things that belong to this page.

type Transformer

type Transformer struct {
	ValuesFilter []string `json:"values_filter"`
	TimeField    string   `json:"time_field"`
	TimeFormat   string   `json:"time_format"`
	TimeLocation string   `json:"time_location"`
}