git.giacomolli.uk - onehouse/blob - protocol/builders.go

   1 package protocol
   2
   3 import "fmt"
   4
   5 // BuildDescriptor returns a validated descriptor publication with its delivery
   6 // rules.
   7 func BuildDescriptor(deviceID string, metadata Metadata, payload DescriptorPayload) (Publication, error) {
   8         return buildMessage(Address{
   9                 Kind: Descriptor,
  10                 ID:   deviceID,
  11         }, metadata, payload)
  12 }
  13
  14 // ParseDescriptor validates its topic, envelope, payload, and delivery
  15 // retention.
  16 func ParseDescriptor(topic string, data []byte, retained bool) (Message[DescriptorPayload], error) {
  17         message, err := parseMessage[DescriptorPayload](Descriptor, topic, data, retained)
  18         if err != nil {
  19                 return Message[DescriptorPayload]{}, fmt.Errorf("parse descriptor: %w", err)
  20         }
  21
  22         return message, nil
  23 }
  24
  25 // BuildAvailability returns a validated availability publication with its
  26 // delivery rules.
  27 func BuildAvailability(deviceID string, metadata Metadata, payload AvailabilityPayload) (Publication, error) {
  28         return buildMessage(Address{
  29                 Kind: Availability,
  30                 ID:   deviceID,
  31         }, metadata, payload)
  32 }
  33
  34 // ParseAvailability validates its topic, envelope, payload, and delivery
  35 // retention.
  36 func ParseAvailability(topic string, data []byte, retained bool) (Message[AvailabilityPayload], error) {
  37         message, err := parseMessage[AvailabilityPayload](Availability, topic, data, retained)
  38         if err != nil {
  39                 return Message[AvailabilityPayload]{}, fmt.Errorf("parse availability: %w", err)
  40         }
  41
  42         return message, nil
  43 }
  44
  45 // BuildReported returns a validated reported publication with its delivery
  46 // rules.
  47 func BuildReported(deviceID string, capability string, metadata Metadata, payload ValuePayload) (Publication, error) {
  48         return buildMessage(Address{
  49                 Kind:   Reported,
  50                 ID:     deviceID,
  51                 Target: capability,
  52         }, metadata, payload)
  53 }
  54
  55 // ParseReported validates its topic, envelope, payload, and delivery retention.
  56 func ParseReported(topic string, data []byte, retained bool) (Message[ValuePayload], error) {
  57         message, err := parseMessage[ValuePayload](Reported, topic, data, retained)
  58         if err != nil {
  59                 return Message[ValuePayload]{}, fmt.Errorf("parse reported: %w", err)
  60         }
  61
  62         return message, nil
  63 }
  64
  65 // BuildTelemetry returns a validated telemetry publication with its delivery
  66 // rules.
  67 func BuildTelemetry(deviceID string, capability string, metadata Metadata, payload ValuePayload) (Publication, error) {
  68         return buildMessage(Address{
  69                 Kind:   Telemetry,
  70                 ID:     deviceID,
  71                 Target: capability,
  72         }, metadata, payload)
  73 }
  74
  75 // ParseTelemetry validates its topic, envelope, payload, and delivery
  76 // retention.
  77 func ParseTelemetry(topic string, data []byte, retained bool) (Message[ValuePayload], error) {
  78         message, err := parseMessage[ValuePayload](Telemetry, topic, data, retained)
  79         if err != nil {
  80                 return Message[ValuePayload]{}, fmt.Errorf("parse telemetry: %w", err)
  81         }
  82
  83         return message, nil
  84 }
  85
  86 // BuildEvent returns a validated event publication with its delivery rules.
  87 func BuildEvent(deviceID string, event string, metadata Metadata, payload EventPayload) (Publication, error) {
  88         return buildMessage(Address{
  89                 Kind:   Event,
  90                 ID:     deviceID,
  91                 Target: event,
  92         }, metadata, payload)
  93 }
  94
  95 // ParseEvent validates its topic, envelope, payload, and delivery retention.
  96 func ParseEvent(topic string, data []byte, retained bool) (Message[EventPayload], error) {
  97         message, err := parseMessage[EventPayload](Event, topic, data, retained)
  98         if err != nil {
  99                 return Message[EventPayload]{}, fmt.Errorf("parse event: %w", err)
 100         }
 101
 102         return message, nil
 103 }
 104
 105 // BuildCommand returns a validated command publication with its delivery rules.
 106 func BuildCommand(deviceID string, capability string, metadata Metadata, payload ValuePayload) (Publication, error) {
 107         return buildMessage(Address{
 108                 Kind:   Command,
 109                 ID:     deviceID,
 110                 Target: capability,
 111         }, metadata, payload)
 112 }
 113
 114 // ParseCommand validates its topic, envelope, payload, and delivery retention.
 115 func ParseCommand(topic string, data []byte, retained bool) (Message[ValuePayload], error) {
 116         message, err := parseMessage[ValuePayload](Command, topic, data, retained)
 117         if err != nil {
 118                 return Message[ValuePayload]{}, fmt.Errorf("parse command: %w", err)
 119         }
 120
 121         return message, nil
 122 }
 123
 124 // BuildCommandBatch returns a validated command batch publication with its
 125 // delivery rules.
 126 func BuildCommandBatch(deviceID string, metadata Metadata, payload BatchPayload) (Publication, error) {
 127         return buildMessage(Address{
 128                 Kind: CommandBatch,
 129                 ID:   deviceID,
 130         }, metadata, payload)
 131 }
 132
 133 // ParseCommandBatch validates its topic, envelope, payload, and delivery
 134 // retention.
 135 func ParseCommandBatch(topic string, data []byte, retained bool) (Message[BatchPayload], error) {
 136         message, err := parseMessage[BatchPayload](CommandBatch, topic, data, retained)
 137         if err != nil {
 138                 return Message[BatchPayload]{}, fmt.Errorf("parse command batch: %w", err)
 139         }
 140
 141         return message, nil
 142 }
 143
 144 // BuildResult returns a validated result publication with its delivery rules.
 145 func BuildResult(deviceID string, commandID string, metadata Metadata, payload ResultPayload) (Publication, error) {
 146         return buildMessage(Address{
 147                 Kind:   Result,
 148                 ID:     deviceID,
 149                 Target: commandID,
 150         }, metadata, payload)
 151 }
 152
 153 // ParseResult validates its topic, envelope, payload, and delivery retention.
 154 func ParseResult(topic string, data []byte, retained bool) (Message[ResultPayload], error) {
 155         message, err := parseMessage[ResultPayload](Result, topic, data, retained)
 156         if err != nil {
 157                 return Message[ResultPayload]{}, fmt.Errorf("parse result: %w", err)
 158         }
 159
 160         return message, nil
 161 }
 162
 163 // BuildHubStatus returns a validated hub status publication with its delivery
 164 // rules.
 165 func BuildHubStatus(hubID string, metadata Metadata, payload HubStatusPayload) (Publication, error) {
 166         return buildMessage(Address{
 167                 Kind: HubStatus,
 168                 ID:   hubID,
 169         }, metadata, payload)
 170 }
 171
 172 // ParseHubStatus validates its topic, envelope, payload, and delivery
 173 // retention.
 174 func ParseHubStatus(topic string, data []byte, retained bool) (Message[HubStatusPayload], error) {
 175         message, err := parseMessage[HubStatusPayload](HubStatus, topic, data, retained)
 176         if err != nil {
 177                 return Message[HubStatusPayload]{}, fmt.Errorf("parse hub status: %w", err)
 178         }
 179
 180         return message, nil
 181 }