magistrala

package module
v0.20.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 17, 2026 License: Apache-2.0 Imports: 2 Imported by: 2

README

Magistrala

A Modern IoT Platform Framework for Scalable IoT

Made with ❤ by Abstract Machines

Build Status Go Report Card Ask DeepWiki Check License Header Check Generated Files Coverage License Matrix

Guide | Contributing | Website | Chat

Introduction 🌍

Magistrala is an open-source IoT platform built for engineers who need full control over their messaging, device management, and data pipelines.

It is built on top of FluxMQ, a modern message broker designed for both messaging and event streams. Magistrala provides everything around it: identity, access control, device provisioning, data processing, and observability.

IoT systems usually involve brokers, databases, rule engines, and custom services. Magistrala does not pretend those pieces disappear. It provides a coherent framework for integrating them into a single system with a consistent model for identity, access control, messaging, and observability.

What it is:

  • An event-driven IoT middleware platform
  • A unified control plane for devices, users, and data
  • A foundation for building scalable IoT systems

What it is not:

  • Not just an MQTT broker
  • Not a black-box SaaS
  • Not tied to a single cloud or vendor

🧩 IoT Platform Framework

We call Magistrala a framework, not just a platform.

It is extremely flexible and lets you build systems the way you want — from simple prototypes to complex, large-scale deployments — without forcing you into rigid patterns.

At the same time, it avoids the typical complexity of many IoT platforms, where you need to learn an entirely new set of concepts before you can even get started.

Magistrala is built around a small number of core concepts:

  • users
  • clients (devices)
  • channels
  • messages
  • policies

Most engineers are already familiar with these ideas, so you can start building immediately.

You can keep things simple:

  • connect devices
  • send messages
  • store data

Or you can go deeper:

  • define complex access control policies
  • build event-driven pipelines
  • integrate custom processing and automation

Magistrala scales with your needs — simple when you want it, powerful when you need it.

🚀 Key Benefits

  • A Coherent System, Not a Mess of Integrations Build IoT systems from multiple components without ending up with fragmented security, messaging, and operations.

  • Event-Driven at the Core Everything is built around events — enabling real-time processing, streaming, and scalable data flows.

  • Protocol-Native, Not Forced Abstractions MQTT, HTTP, WebSocket, and CoAP are treated as first-class citizens, each with their own semantics.

  • Security Built Into the Model Identity, authentication, and authorization are part of the system design — not bolted on later.

  • Flexible by Design Start simple or build complex systems — without changing platforms or rewriting your architecture.

  • Runs Where You Need It Cloud, edge, or hybrid — no vendor lock-in, no hidden dependencies.

✨ Features

Magistrala provides a complete set of building blocks for IoT systems — from device connectivity to data processing and observability — without forcing a rigid architecture.

🔐 Identity & Access
  • Multi-tenant domains for isolating environments
  • Users, roles, and organizational hierarchies
  • Fine-grained access control (ABAC + RBAC)
  • Mutual TLS (X.509) and JWT-based authentication
  • Personal Access Tokens (PATs) with scoping and revocation
🔌 Connectivity
  • Native support for MQTT, HTTP, WebSocket, and CoAP
  • Consistent authentication and authorization across protocols
  • Designed for both cloud services and constrained devices
📦 Device & Application Model
  • Device (client) provisioning and lifecycle management
  • Channels for grouping and controlling message flow
  • Application-level grouping and sharing of clients
  • Simple but flexible communication model
⚙️ Processing & Automation
  • Rules engine for message processing and routing
  • Alarms and triggers for reacting to events
  • Scheduled actions for time-based workflows
  • Event-driven architecture as the foundation
📊 Observability
  • Audit logs for tracking system activity
  • Metrics and tracing via Prometheus and OpenTelemetry
  • Built-in visibility into system behavior and data flows
🚀 Deployment & Operations
  • Container-native (Docker, Kubernetes)
  • Designed for cloud, edge, and hybrid deployments
  • Works with external storage and processing systems
  • Scales from small setups to production environments
🧑‍💻 Developer Experience
  • CLI and SDKs for fast integration
  • Straightforward APIs and concepts
  • Documentation focused on getting you running quickly

Installation

git clone https://github.com/absmach/magistrala.git
cd magistrala
make run_latest

Usage

make cli
./build/cli health <service>

License

Apache-2.0

Documentation

Overview

package magistrala acts as an umbrella package containing multiple different microservices and defines all shared domain concepts. For detailed documentation of the platform, please visit https://magistrala.absmach.eu/docs/.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// Version represents the last service git tag in git history.
	// It's meant to be set using go build ldflags:
	// -ldflags "-X 'github.com/absmach/magistrala.Version=0.0.0'".
	Version = "0.0.0"
	// Commit represents the service git commit hash.
	// It's meant to be set using go build ldflags:
	// -ldflags "-X 'github.com/absmach/magistrala.Commit=ffffffff'".
	Commit = "ffffffff"
	// BuildTime represetns the service build time.
	// It's meant to be set using go build ldflags:
	// -ldflags "-X 'github.com/absmach/magistrala.BuildTime=1970-01-01_00:00:00'".
	BuildTime = "1970-01-01_00:00:00"
)

Functions

func Health 

func Health(service, instanceID string) http.HandlerFunc

Health exposes an HTTP handler for retrieving service health.

Types

type HealthInfo 

type HealthInfo struct {
	// Status contains service status.
	Status string `json:"status"`

	// Version contains current service version.
	Version string `json:"version"`

	// Commit represents the git hash commit.
	Commit string `json:"commit"`

	// Description contains service description.
	Description string `json:"description"`

	// BuildTime contains service build time.
	BuildTime string `json:"build_time"`

	// InstanceID contains the ID of the current service instance
	InstanceID string `json:"instance_id"`
}

HealthInfo contains version endpoint response.

type IDProvider 

type IDProvider interface {
	// ID generates the unique identifier.
	ID() (string, error)
}

IDProvider specifies an API for generating unique identifiers.

type Response 

type Response interface {
	// Code returns HTTP response code.
	Code() int

	// Headers returns map of HTTP headers with their values.
	Headers() map[string]string

	// Empty indicates if HTTP response has content.
	Empty() bool
}

Response contains HTTP response specific methods.

Source Files

View all Source files

Directories

Path Synopsis
Package alarms contains domain concept definitions needed to support Alarms service feature, i.e.
 Package alarms contains domain concept definitions needed to support Alarms service feature, i.e.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
brokers
consumer
middleware
Package middleware provides middleware for the alarms service.
 Package middleware provides middleware for the alarms service.
mocks
operations
postgres
api
Package api contains commonly used constants and functions for the HTTP and gRPC API.
 Package api contains commonly used constants and functions for the HTTP and gRPC API.
grpc/auth/v1
grpc/certs/v1
grpc/channels/v1
grpc/clients/v1
grpc/common/v1
grpc/domains/v1
grpc/groups/v1
grpc/readers/v1
grpc/token/v1
grpc/users/v1
http
Package api contains commonly used constants and functions for the HTTP API.
 Package api contains commonly used constants and functions for the HTTP API.
http/util
api
Package api contains implementation of Auth service HTTP API.
 Package api contains implementation of Auth service HTTP API.
api/grpc
api/grpc/auth
Package auth contains implementation of Auth service gRPC API.
 Package auth contains implementation of Auth service gRPC API.
api/grpc/token
Package grpc contains implementation of Auth service gRPC API.
 Package grpc contains implementation of Auth service gRPC API.
api/http
api/http/keys
api/http/pats
cache
Package cache contains the domain concept definitions needed to support Magistrala auth cache service functionality.
 Package cache contains the domain concept definitions needed to support Magistrala auth cache service functionality.
hasher
Package hasher contains the domain concept definitions needed to support Supermq users password hasher sub-service functionality.
 Package hasher contains the domain concept definitions needed to support Supermq users password hasher sub-service functionality.
middleware
Package middleware provides logging metrics and tracing middleware for Magistrala Auth service.
 Package middleware provides logging metrics and tracing middleware for Magistrala Auth service.
mocks
postgres
Package postgres contains Key repository implementations using PostgreSQL as the underlying database.
 Package postgres contains Key repository implementations using PostgreSQL as the underlying database.
tokenizer/asymmetric
tokenizer/symmetric
tokenizer/util
Package bootstrap contains the domain concept definitions needed to support Magistrala bootstrap service functionality.
 Package bootstrap contains the domain concept definitions needed to support Magistrala bootstrap service functionality.
api
Package api contains implementation of bootstrap service HTTP API.
 Package api contains implementation of bootstrap service HTTP API.
events
Package events provides the domain concept definitions needed to support bootstrap events functionality.
 Package events provides the domain concept definitions needed to support bootstrap events functionality.
events/consumer
Package consumer contains events consumer for events published by Bootstrap service.
 Package consumer contains events consumer for events published by Bootstrap service.
events/producer
Package producer contains the domain events needed to support event sourcing of Bootstrap service actions.
 Package producer contains the domain events needed to support event sourcing of Bootstrap service actions.
middleware
mocks
postgres
Package postgres contains repository implementations using PostgreSQL as the underlying database.
 Package postgres contains repository implementations using PostgreSQL as the underlying database.
tracing
Package tracing provides tracing instrumentation for Magistrala Users service.
 Package tracing provides tracing instrumentation for Magistrala Users service.
api
api/grpc
api/http
client
middleware
mocks
pki
Package pki wraps OpenBao client for PKI operations
 Package pki wraps OpenBao client for PKI operations
postgres
api/grpc
Package grpc contains implementation of Auth service gRPC API.
 Package grpc contains implementation of Auth service gRPC API.
api/http
cache
Package cache contains the domain concept definitions needed to support Magistrala Channels cache service functionality.
 Package cache contains the domain concept definitions needed to support Magistrala Channels cache service functionality.
events
Package events provides the domain concept definitions needed to support clients events functionality.
 Package events provides the domain concept definitions needed to support clients events functionality.
middleware
Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Channels Service.
 Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Channels Service.
mocks
operations
postgres
private
private/mocks
Package cli contains the domain concept definitions needed to support Magistrala CLI functionality.
 Package cli contains the domain concept definitions needed to support Magistrala CLI functionality.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
api/grpc
Package grpc contains implementation of Auth service gRPC API.
 Package grpc contains implementation of Auth service gRPC API.
api/http
cache
Package cache contains the domain concept definitions needed to support Magistrala clients cache service functionality.
 Package cache contains the domain concept definitions needed to support Magistrala clients cache service functionality.
events
Package events provides the domain concept definitions needed to support clients events functionality.
 Package events provides the domain concept definitions needed to support clients events functionality.
middleware
Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Clients Service.
 Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Clients Service.
mocks
Package mocks contains mocks for testing purposes.
 Package mocks contains mocks for testing purposes.
operations
postgres
Package postgres contains the database implementation of clients repository layer.
 Package postgres contains the database implementation of clients repository layer.
private
Private package is a service wrapper around the underlying Repository.
 Private package is a service wrapper around the underlying Repository.
private/mocks
standalone
Package standalone contains implementation for auth service in single-user scenario.
 Package standalone contains implementation for auth service in single-user scenario.
cmd
alarms command
auth command
bootstrap command
Package main contains bootstrap main function to start the bootstrap service.
 Package main contains bootstrap main function to start the bootstrap service.
certs command
channels command
Package main contains clients main function to start the clients service.
 Package main contains clients main function to start the clients service.
cli command
Package main contains cli main function to run the cli.
 Package main contains cli main function to run the cli.
clients command
Package main contains clients main function to start the clients service.
 Package main contains clients main function to start the clients service.
domains command
fluxmq command
Package main contains the FluxMQ auth bridge service entry point.
 Package main contains the FluxMQ auth bridge service entry point.
groups command
Package main contains groups main function to start the groups service.
 Package main contains groups main function to start the groups service.
journal command
Package main contains journal main function to start the journal service.
 Package main contains journal main function to start the journal service.
notifications command
Package main contains notifications main function to start the notifications service.
 Package main contains notifications main function to start the notifications service.
postgres-reader command
Package main contains postgres-reader main function to start the postgres-reader service.
 Package main contains postgres-reader main function to start the postgres-reader service.
postgres-writer command
Package main contains postgres-writer main function to start the postgres-writer service.
 Package main contains postgres-writer main function to start the postgres-writer service.
provision command
Package main contains provision main function to start the provision service.
 Package main contains provision main function to start the provision service.
re command
Package main contains rule engine main function to start the service.
 Package main contains rule engine main function to start the service.
reports command
Package main contains reports main function to start the service.
 Package main contains reports main function to start the service.
timescale-reader command
Package main contains timescale-reader main function to start the timescale-reader service.
 Package main contains timescale-reader main function to start the timescale-reader service.
timescale-writer command
Package main contains timescale-writer main function to start the timescale-writer service.
 Package main contains timescale-writer main function to start the timescale-writer service.
users command
Package main contains users main function to start the users service.
 Package main contains users main function to start the users service.
Package consumers contain the domain concept definitions needed to support Magistrala consumer services functionality.
 Package consumers contain the domain concept definitions needed to support Magistrala consumer services functionality.
mocks
notifiers
Package notifiers contain the domain concept definitions needed to support Magistrala notifications functionality.
 Package notifiers contain the domain concept definitions needed to support Magistrala notifications functionality.
notifiers/api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
notifiers/mocks
notifiers/postgres
Package postgres contains repository implementations using PostgreSQL as the underlying database.
 Package postgres contains repository implementations using PostgreSQL as the underlying database.
notifiers/smpp
Package smpp contains the domain concept definitions needed to support Magistrala SMS notifications.
 Package smpp contains the domain concept definitions needed to support Magistrala SMS notifications.
notifiers/smtp
notifiers/tracing
Package tracing provides tracing instrumentation for Magistrala WebSocket adapter service.
 Package tracing provides tracing instrumentation for Magistrala WebSocket adapter service.
tracing
writers
Package writers contain the domain concept definitions needed to support Magistrala writer services functionality.
 Package writers contain the domain concept definitions needed to support Magistrala writer services functionality.
writers/api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
writers/brokers
writers/postgres
Package postgres contains repository implementations using Postgres as the underlying database.
 Package postgres contains repository implementations using Postgres as the underlying database.
writers/timescale
Package timescale contains repository implementations using Timescale as the underlying database.
 Package timescale contains repository implementations using Timescale as the underlying database.
api/grpc
Package grpc contains implementation of Domains service gRPC API.
 Package grpc contains implementation of Domains service gRPC API.
api/http
cache
Package cache contains the domain concept definitions needed to support Magistrala Domains cache service functionality.
 Package cache contains the domain concept definitions needed to support Magistrala Domains cache service functionality.
events
Package events provides the domain concept definitions needed to support Magistrala auth service functionality.
 Package events provides the domain concept definitions needed to support Magistrala auth service functionality.
middleware
Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Domains service.
 Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Domains service.
mocks
operations
postgres
Package postgres contains Key repository implementations using PostgreSQL as the underlying database.
 Package postgres contains Key repository implementations using PostgreSQL as the underlying database.
private
private/mocks
fluxmq
api/grpc
Package grpc contains the FluxMQ auth callout gRPC server implementation.
 Package grpc contains the FluxMQ auth callout gRPC server implementation.
Package groups contains the domain concept definitions needed to support Magistrala groups functionality.
 Package groups contains the domain concept definitions needed to support Magistrala groups functionality.
api/grpc
Package grpc contains implementation of Auth service gRPC API.
 Package grpc contains implementation of Auth service gRPC API.
api/http
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
events
Package events contains event source Redis client implementation.
 Package events contains event source Redis client implementation.
middleware
Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Domains service.
 Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Domains service.
mocks
Package mocks contains mocks for testing purposes.
 Package mocks contains mocks for testing purposes.
operations
postgres
Package postgres contains the database implementation of groups repository layer.
 Package postgres contains the database implementation of groups repository layer.
private
private/mocks
internal
clients
Package clients contains the domain concept definitions needed to support Magistrala clients functionality for example: postgres, redis, grpc, jaeger.
 Package clients contains the domain concept definitions needed to support Magistrala clients functionality for example: postgres, redis, grpc, jaeger.
clients/redis
Package redis contains the domain concept definitions needed to support Magistrala redis cache functionality.
 Package redis contains the domain concept definitions needed to support Magistrala redis cache functionality.
email
Package email contains the domain concept definitions needed to support Magistrala email functionality.
 Package email contains the domain concept definitions needed to support Magistrala email functionality.
nullable
Package nullable contains nullable types used to handle scenarios where default values can't be used to indicate empty, and we want to avoid using pointers for that.
 Package nullable contains nullable types used to handle scenarios where default values can't be used to indicate empty, and we want to avoid using pointers for that.
testsutil
Package journal contains the journal service.
 Package journal contains the journal service.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
events
Package events provides the event consumer for the journal service.
 Package events provides the event consumer for the journal service.
middleware
Package middleware provides tracing, logging and metrics middleware for Magistrala Journal service.
 Package middleware provides tracing, logging and metrics middleware for Magistrala Journal service.
mocks
Package mocks contains mocks for testing purposes.
 Package mocks contains mocks for testing purposes.
postgres
Package postgres provides a postgres implementation of the journal log repository.
 Package postgres provides a postgres implementation of the journal log repository.
Package logger contains logger API definition, wrapper that can be used around any other logger.
 Package logger contains logger API definition, wrapper that can be used around any other logger.
Package notifications provides the domain model for the notifications service.
 Package notifications provides the domain model for the notifications service.
emailer
Package emailer provides email notification implementation for the notifications service.
 Package emailer provides email notification implementation for the notifications service.
events
Package events provides event handling for the notifications service.
 Package events provides event handling for the notifications service.
middleware
Package middleware provides middleware for the notifications service.
 Package middleware provides middleware for the notifications service.
mocks
Package mocks provides mocks for the notifications service.
 Package mocks provides mocks for the notifications service.
pkg
Package pkg contains library packages used by Magistrala services and external services that integrate with Magistrala.
 Package pkg contains library packages used by Magistrala services and external services that integrate with Magistrala.
authn
authn/authsvc
authn/jwks
authn/mocks
authz
authz/authsvc
authz/mocks
callout
callout/mocks
channels/events
Package events provides the events sourcing of channels to provide replication in other service and definitions needed to support it
 Package events provides the events sourcing of channels to provide replication in other service and definitions needed to support it
channels/events/consumer
Package consumer contains events consumer for events published by channels service.
 Package consumer contains events consumer for events published by channels service.
clients/events
Package events provides the events sourcing of clients to provide replication in other service and definitions needed to support it
 Package events provides the events sourcing of clients to provide replication in other service and definitions needed to support it
clients/events/consumer
Package consumer contains events consumer for events published by clients service.
 Package consumer contains events consumer for events published by clients service.
connections
domains
domains/events/consumer
domains/grpcclient
domains/psvc
emailer
emailer/mocks
errors
Package errors contains Magistrala errors definitions.
 Package errors contains Magistrala errors definitions.
errors/repository
errors/service
events
events/fluxmq
events/mocks
events/nats
Package redis contains the domain concept definitions needed to support Magistrala redis events source service functionality.
 Package redis contains the domain concept definitions needed to support Magistrala redis events source service functionality.
events/redis
Package redis contains the domain concept definitions needed to support Magistrala redis events source service functionality.
 Package redis contains the domain concept definitions needed to support Magistrala redis events source service functionality.
events/store
groups
groups/events
Package events provides the events sourcing of groups to provide listing in clients and channels concept definitions needed to support
 Package events provides the events sourcing of groups to provide listing in clients and channels concept definitions needed to support
groups/events/consumer
Package consumer contains events consumer for events published by Bootstrap service.
 Package consumer contains events consumer for events published by Bootstrap service.
grpcclient
Package auth contains the domain concept definitions needed to support Magistrala auth functionality.
 Package auth contains the domain concept definitions needed to support Magistrala auth functionality.
jaeger
Package jaeger contains the domain concept definitions needed to support Magistrala Jaeger tracing functionality.
 Package jaeger contains the domain concept definitions needed to support Magistrala Jaeger tracing functionality.
logger
messaging
messaging/brokers
messaging/brokers/tracing
messaging/events
messaging/fluxmq
messaging/fluxmq/tracing
messaging/mocks
messaging/mqtt
Package mqtt hold the implementation of the Publisher and PubSub interfaces for the MQTT messaging system, the internal messaging broker of the Magistrala IoT platform.
 Package mqtt hold the implementation of the Publisher and PubSub interfaces for the MQTT messaging system, the internal messaging broker of the Magistrala IoT platform.
messaging/nats
Package nats hold the implementation of the Publisher and PubSub interfaces for the NATS messaging system, the internal messaging broker of the Magistrala IoT platform.
 Package nats hold the implementation of the Publisher and PubSub interfaces for the NATS messaging system, the internal messaging broker of the Magistrala IoT platform.
messaging/nats/tracing
Package tracing provides tracing instrumentation for Magistrala clients policies service.
 Package tracing provides tracing instrumentation for Magistrala clients policies service.
messaging/tracing
Package tracing provides tracing instrumentation for Magistrala clients policies service.
 Package tracing provides tracing instrumentation for Magistrala clients policies service.
oauth2
Package oauth2 contains the domain concept definitions needed to support Magistrala ui service OAuth2 functionality.
 Package oauth2 contains the domain concept definitions needed to support Magistrala ui service OAuth2 functionality.
oauth2/google
Package google contains the domain concept definitions needed to support Magistrala services for Google OAuth2 functionality.
 Package google contains the domain concept definitions needed to support Magistrala services for Google OAuth2 functionality.
oauth2/mocks
permissions
policies
Package policies contains Magistrala policy definitions.
 Package policies contains Magistrala policy definitions.
policies/mocks
policies/spicedb
Package server contains the HTTP, gRPC and CoAP server implementation.
 Package server contains the HTTP, gRPC and CoAP server implementation.
postgres
Package postgres contains the domain concept definitions needed to support Magistrala PostgreSQL database functionality.
 Package postgres contains the domain concept definitions needed to support Magistrala PostgreSQL database functionality.
prometheus
Package prometheus provides a framework for defining and collecting metrics for prometheus.
 Package prometheus provides a framework for defining and collecting metrics for prometheus.
re/events/consumer
Package consumer contains events consumer for events published by the Rules Engine service.
 Package consumer contains events consumer for events published by the Rules Engine service.
reltime
roles
roles/mocks
roles/repo
roles/repo/postgres
roles/rolemanager/api
roles/rolemanager/events
Package events provides the domain concept definitions needed to support Magistrala auth service functionality.
 Package events provides the domain concept definitions needed to support Magistrala auth service functionality.
roles/rolemanager/events/consumer
roles/rolemanager/middleware
Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala RoleManager service.
 Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala RoleManager service.
schedule
sdk
Package sdk contains Magistrala SDK.
 Package sdk contains Magistrala SDK.
sdk/mocks
server
Package server contains the HTTP, gRPC and CoAP server implementation.
 Package server contains the HTTP, gRPC and CoAP server implementation.
server/coap
Package coap contains the CoAP server implementation.
 Package coap contains the CoAP server implementation.
server/grpc
Package grpc contains the gRPC server implementation.
 Package grpc contains the gRPC server implementation.
server/http
Package http contains the HTTP server implementation.
 Package http contains the HTTP server implementation.
sid
Package ulid contains ULID generator.
 Package ulid contains ULID generator.
spicedb
ticker
ticker/mocks
tracing
transformers
Package transformers contains the domain concept definitions needed to support Magistrala transformer services functionality.
 Package transformers contains the domain concept definitions needed to support Magistrala transformer services functionality.
transformers/json
Package json contains JSON transformer.
 Package json contains JSON transformer.
transformers/senml
Package senml contains SenML transformer.
 Package senml contains SenML transformer.
ulid
Package ulid contains ULID generator.
 Package ulid contains ULID generator.
uuid
Package uuid contains UUID generator.
 Package uuid contains UUID generator.
Package provision contains domain concept definitions needed to support Provision service feature, i.e.
 Package provision contains domain concept definitions needed to support Provision service feature, i.e.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
middleware
mocks
re
Package re contain the domain concept definitions needed to support Magistrala Rule Egine services functionality.
 Package re contain the domain concept definitions needed to support Magistrala Rule Egine services functionality.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
events
Package events provides the domain concept definitions needed to support clients events functionality.
 Package events provides the domain concept definitions needed to support clients events functionality.
middleware
mocks
operations
outputs
postgres
Package readers provides a set of readers for various formats.
 Package readers provides a set of readers for various formats.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
api/grpc
Package grpc contains implementation of Readers service gRPC API.
 Package grpc contains implementation of Readers service gRPC API.
api/http
middleware
Package middleware provides middleware for Magistrala Readers service.
 Package middleware provides middleware for Magistrala Readers service.
mocks
postgres
Package postgres contains repository implementations using Postgres as the underlying database.
 Package postgres contains repository implementations using Postgres as the underlying database.
timescale
Package timescale contains repository implementations using Timescale as the underlying database.
 Package timescale contains repository implementations using Timescale as the underlying database.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
events
Package events provides the domain concept definitions needed to support reports events functionality.
 Package events provides the domain concept definitions needed to support reports events functionality.
middleware
mocks
operations
postgres
Package tools contains tools for Magistrala.
 Package tools contains tools for Magistrala.
e2e
Package e2e contains entry point for end-to-end tests.
 Package e2e contains entry point for end-to-end tests.
e2e/cmd command
Package main contains e2e tool for testing Magistrala.
 Package main contains e2e tool for testing Magistrala.
mqtt-bench
Package bench contains benchmarking tool for MQTT broker.
 Package bench contains benchmarking tool for MQTT broker.
mqtt-bench/cmd command
Package main contains the entry point of the mqtt-bench tool.
 Package main contains the entry point of the mqtt-bench tool.
provision
Package provision is a simple utility to create a list of channels and clients connected to these channels with possibility to create certificates for mTLS use case.
 Package provision is a simple utility to create a list of channels and clients connected to these channels with possibility to create certificates for mTLS use case.
provision/cmd command
Package main contains entry point for provisioning tool.
 Package main contains entry point for provisioning tool.
Package users contains the domain concept definitions needed to support Magistrala users service functionality.
 Package users contains the domain concept definitions needed to support Magistrala users service functionality.
api
Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
 Package api contains API-related concerns: endpoint definitions, middlewares and all resource representations.
api/grpc
Package grpc contains implementation of Users service gRPC API.
 Package grpc contains implementation of Users service gRPC API.
emailer
Package emailer contains the domain concept definitions needed to support Magistrala users email service functionality.
 Package emailer contains the domain concept definitions needed to support Magistrala users email service functionality.
events
Package events provides the domain concept definitions needed to support Magistrala users service functionality.
 Package events provides the domain concept definitions needed to support Magistrala users service functionality.
hasher
Package hasher contains the domain concept definitions needed to support Magistrala users password hasher sub-service functionality.
 Package hasher contains the domain concept definitions needed to support Magistrala users password hasher sub-service functionality.
middleware
Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Users Service.
 Package middleware provides authorization, logging, metrics and tracing middleware for Magistrala Users Service.
mocks
Package mocks contains mocks for testing purposes.
 Package mocks contains mocks for testing purposes.
postgres
Package postgres contains the database implementation of users repository layer.
 Package postgres contains the database implementation of users repository layer.
private

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.