redis

package
v1.3.1-dev.18.0...-398431f Latest Latest
Warning

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

 Go to latest Published: Jun 30, 2021 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	MULTI            = "MULTI"
	SET              = "SET"
	GET              = "GET"
	EXISTS           = "EXISTS"
	DEL              = "DEL"
	HSET             = "HSET"
	HGET             = "HGET"
	HEXISTS          = "HEXISTS"
	HDEL             = "HDEL"
	SADD             = "SADD"
	SREM             = "SREM"
	ZADD             = "ZADD"
	ZREM             = "ZREM"
	EXEC             = "EXEC"
	ZRANGE           = "ZRANGE"
	ZREVRANGE        = "ZREVRANGE"
	MGET             = "MGET"
	ZCARD            = "ZCARD"
	ZCOUNT           = "ZCOUNT"
	UNLINK           = "UNLINK"
	ZRANGEBYSCORE    = "ZRANGEBYSCORE"
	ZREVRANGEBYSCORE = "ZREVRANGEBYSCORE"
	LIMIT            = "LIMIT"
	ZUNIONSTORE      = "ZUNIONSTORE"
	ZINTERSTORE      = "ZINTERSTORE"
)

Redis commmands used in this project Reference: https://redis.io/commands

View Source 
const (
	InfiniteMin     = "-inf"
	InfiniteMax     = "+inf"
	GreaterThanZero = "(0"
	DBKeySeparator  = ":"
)
View Source 
const (
	DeviceCollection            = "md|dv"
	DeviceCollectionName        = DeviceCollection + DBKeySeparator + common.Name
	DeviceCollectionLabel       = DeviceCollection + DBKeySeparator + common.Label
	DeviceCollectionServiceName = DeviceCollection + DBKeySeparator + common.Service + DBKeySeparator + common.Name
	DeviceCollectionProfileName = DeviceCollection + DBKeySeparator + common.Profile + DBKeySeparator + common.Name
)
View Source 
const (
	DeviceProfileCollection             = "md|dp"
	DeviceProfileCollectionName         = DeviceProfileCollection + DBKeySeparator + common.Name
	DeviceProfileCollectionLabel        = DeviceProfileCollection + DBKeySeparator + common.Label
	DeviceProfileCollectionModel        = DeviceProfileCollection + DBKeySeparator + common.Model
	DeviceProfileCollectionManufacturer = DeviceProfileCollection + DBKeySeparator + common.Manufacturer
)
View Source 
const (
	DeviceServiceCollection      = "md|ds"
	DeviceServiceCollectionName  = DeviceServiceCollection + DBKeySeparator + common.Name
	DeviceServiceCollectionLabel = DeviceServiceCollection + DBKeySeparator + common.Label
)
View Source 
const (
	EventsCollection           = "cd|evt"
	EventsCollectionOrigin     = EventsCollection + DBKeySeparator + common.Origin
	EventsCollectionDeviceName = EventsCollection + DBKeySeparator + common.Device + DBKeySeparator + common.Name
	EventsCollectionReadings   = EventsCollection + DBKeySeparator + "readings"
)
View Source 
const (
	IntervalCollection     = "ss|iv"
	IntervalCollectionName = IntervalCollection + DBKeySeparator + common.Name
)
View Source 
const (
	IntervalActionCollection             = "ss|ia"
	IntervalActionCollectionName         = IntervalActionCollection + DBKeySeparator + common.Name
	IntervalActionCollectionIntervalName = IntervalActionCollection + DBKeySeparator + common.Interval + DBKeySeparator + common.Name
)
View Source 
const (
	NotificationCollection         = "sn|notif"
	NotificationCollectionCategory = NotificationCollection + DBKeySeparator + common.Category
	NotificationCollectionLabel    = NotificationCollection + DBKeySeparator + common.Label
	NotificationCollectionSender   = NotificationCollection + DBKeySeparator + common.Sender
	NotificationCollectionSeverity = NotificationCollection + DBKeySeparator + common.Severity
	NotificationCollectionStatus   = NotificationCollection + DBKeySeparator + common.Status
	NotificationCollectionCreated  = NotificationCollection + DBKeySeparator + common.Created
)
View Source 
const (
	ProvisionWatcherCollection            = "md|pw"
	ProvisionWatcherCollectionName        = ProvisionWatcherCollection + DBKeySeparator + common.Name
	ProvisionWatcherCollectionLabel       = ProvisionWatcherCollection + DBKeySeparator + common.Label
	ProvisionWatcherCollectionServiceName = ProvisionWatcherCollectionName + DBKeySeparator + common.Service + DBKeySeparator + common.Name
	ProvisionWatcherCollectionProfileName = ProvisionWatcherCollectionName + DBKeySeparator + common.Profile + DBKeySeparator + common.Name
)
View Source 
const (
	ReadingsCollection             = "cd|rd"
	ReadingsCollectionOrigin       = ReadingsCollection + DBKeySeparator + common.Origin
	ReadingsCollectionDeviceName   = ReadingsCollection + DBKeySeparator + common.Device + DBKeySeparator + common.Name
	ReadingsCollectionResourceName = ReadingsCollection + DBKeySeparator + common.ResourceName
)
View Source 
const (
	SubscriptionCollection         = "sn|sub"
	SubscriptionCollectionName     = SubscriptionCollection + DBKeySeparator + common.Name
	SubscriptionCollectionCategory = SubscriptionCollection + DBKeySeparator + common.Category
	SubscriptionCollectionLabel    = SubscriptionCollection + DBKeySeparator + common.Label
	SubscriptionCollectionReceiver = SubscriptionCollection + DBKeySeparator + common.Receiver
)
View Source 
const (
	TransmissionCollection                 = "sn|trans"
	TransmissionCollectionStatus           = TransmissionCollection + DBKeySeparator + common.Status
	TransmissionCollectionSubscriptionName = TransmissionCollection + DBKeySeparator + common.Subscription + DBKeySeparator + common.Name
	TransmissionCollectionNotificationId   = TransmissionCollection + DBKeySeparator + common.Notification + DBKeySeparator + common.Id
	TransmissionCollectionCreated          = TransmissionCollection + DBKeySeparator + common.Created
)

Variables

This section is empty.

Functions

func CreateKey 

func CreateKey(targets ...string) string

CreateKey creates Redis key by connecting the target key with DBKeySeparator

Types

type Client 

type Client struct {
	*redisClient.Client
	// contains filtered or unexported fields
}

func NewClient 

func NewClient(config db.Configuration, logger logger.LoggingClient) (*Client, errors.EdgeX)

func (*Client) AddDevice 

func (c *Client) AddDevice(d model.Device) (model.Device, errors.EdgeX)

Add a new device

func (*Client) AddDeviceProfile 

func (c *Client) AddDeviceProfile(dp model.DeviceProfile) (model.DeviceProfile, errors.EdgeX)

Add a new device profle

func (*Client) AddDeviceService 

func (c *Client) AddDeviceService(ds model.DeviceService) (model.DeviceService, errors.EdgeX)

AddDeviceService adds a new device service

func (*Client) AddEvent 

func (c *Client) AddEvent(e model.Event) (model.Event, errors.EdgeX)

AddEvent adds a new event

func (*Client) AddInterval 

func (c *Client) AddInterval(interval model.Interval) (model.Interval, errors.EdgeX)

AddInterval adds a new interval

func (*Client) AddIntervalAction 

func (c *Client) AddIntervalAction(action model.IntervalAction) (model.IntervalAction, errors.EdgeX)

AddIntervalAction adds a new intervalAction

func (*Client) AddNotification 

func (c *Client) AddNotification(notification model.Notification) (model.Notification, errors.EdgeX)

AddNotification adds a new notification

func (*Client) AddProvisionWatcher 

func (c *Client) AddProvisionWatcher(pw model.ProvisionWatcher) (model.ProvisionWatcher, errors.EdgeX)

AddProvisionWatcher adds a new provision watcher

func (*Client) AddSubscription 

func (c *Client) AddSubscription(subscription model.Subscription) (model.Subscription, errors.EdgeX)

AddSubscription adds a new subscription

func (*Client) AddTransmission 

func (c *Client) AddTransmission(t model.Transmission) (model.Transmission, errors.EdgeX)

AddTransmission adds a new transmission

func (*Client) AllDeviceProfiles 

func (c *Client) AllDeviceProfiles(offset int, limit int, labels []string) ([]model.DeviceProfile, errors.EdgeX)

AllDeviceProfiles query device profiles with offset and limit

func (*Client) AllDeviceServices 

func (c *Client) AllDeviceServices(offset int, limit int, labels []string) (deviceServices []model.DeviceService, edgeXerr errors.EdgeX)

AllDeviceServices returns multiple device services per query criteria, including offset: the number of items to skip before starting to collect the result set limit: The numbers of items to return labels: allows for querying a given object by associated user-defined labels

func (*Client) AllDevices 

func (c *Client) AllDevices(offset int, limit int, labels []string) ([]model.Device, errors.EdgeX)

AllDevices query the devices with offset, limit, and labels

func (*Client) AllEvents 

func (c *Client) AllEvents(offset int, limit int) ([]model.Event, errors.EdgeX)

AllEvents query events by offset and limit

func (*Client) AllIntervalActions 

func (c *Client) AllIntervalActions(offset int, limit int) (intervalActions []model.IntervalAction, edgeXerr errors.EdgeX)

AllIntervalActions query intervalActions with offset and limit

func (*Client) AllIntervals 

func (c *Client) AllIntervals(offset int, limit int) (intervals []model.Interval, edgeXerr errors.EdgeX)

AllIntervals query intervals with offset and limit

func (*Client) AllProvisionWatchers 

func (c *Client) AllProvisionWatchers(offset int, limit int, labels []string) (provisionWatchers []model.ProvisionWatcher, edgexErr errors.EdgeX)

AllProvisionWatchers query provision watchers with offset, limit and labels

func (*Client) AllReadings 

func (c *Client) AllReadings(offset int, limit int) ([]model.Reading, errors.EdgeX)

AllReadings query events by offset, limit, and labels

func (*Client) AllSubscriptions 

func (c *Client) AllSubscriptions(offset int, limit int) ([]model.Subscription, errors.EdgeX)

AllSubscriptions returns multiple subscriptions per query criteria, including offset: The number of items to skip before starting to collect the result set. limit: The maximum number of items to return.

func (*Client) AllTransmissions 

func (c *Client) AllTransmissions(offset int, limit int) ([]model.Transmission, errors.EdgeX)

AllTransmissions returns multiple transmissions per query criteria, including offset: The number of items to skip before starting to collect the result set. limit: The maximum number of items to return.

func (*Client) CleanupNotificationsByAge 

func (c *Client) CleanupNotificationsByAge(age int64) (err errors.EdgeX)

CleanupNotificationsByAge deletes notifications and their corresponding transmissions that are older than age. This function is implemented to starts up two goroutines to delete transmissions and notifications in the background to achieve better performance.

func (*Client) CloseSession 

func (c *Client) CloseSession()

CloseSession closes the connections to Redis

func (*Client) DeleteDeviceById 

func (c *Client) DeleteDeviceById(id string) errors.EdgeX

DeleteDeviceById deletes a device by id

func (*Client) DeleteDeviceByName 

func (c *Client) DeleteDeviceByName(name string) errors.EdgeX

DeleteDeviceByName deletes a device by name

func (*Client) DeleteDeviceProfileById 

func (c *Client) DeleteDeviceProfileById(id string) errors.EdgeX

DeleteDeviceProfileById deletes a device profile by id

func (*Client) DeleteDeviceProfileByName 

func (c *Client) DeleteDeviceProfileByName(name string) errors.EdgeX

DeleteDeviceProfileByName deletes a device profile by name

func (*Client) DeleteDeviceServiceById 

func (c *Client) DeleteDeviceServiceById(id string) errors.EdgeX

DeleteDeviceServiceById deletes a device service by id

func (*Client) DeleteDeviceServiceByName 

func (c *Client) DeleteDeviceServiceByName(name string) errors.EdgeX

DeleteDeviceServiceByName deletes a device service by name

func (*Client) DeleteEventById 

func (c *Client) DeleteEventById(id string) (edgeXerr errors.EdgeX)

DeleteEventById removes an event by id

func (*Client) DeleteEventsByAge 

func (c *Client) DeleteEventsByAge(age int64) (edgeXerr errors.EdgeX)

DeleteEventsByAge deletes events and their corresponding readings that are older than age. This function is implemented to starts up two goroutines to delete readings and events in the background to achieve better performance.

func (*Client) DeleteEventsByDeviceName 

func (c *Client) DeleteEventsByDeviceName(deviceName string) (edgeXerr errors.EdgeX)

DeleteEventsByDeviceName deletes specific device's events and corresponding readings. This function is implemented to starts up two goroutines to delete readings and events in the background to achieve better performance.

func (*Client) DeleteIntervalActionByName 

func (c *Client) DeleteIntervalActionByName(name string) errors.EdgeX

DeleteIntervalActionByName deletes the intervalAction by name

func (*Client) DeleteIntervalByName 

func (c *Client) DeleteIntervalByName(name string) errors.EdgeX

DeleteIntervalByName deletes the interval by name

func (*Client) DeleteNotificationById 

func (c *Client) DeleteNotificationById(id string) errors.EdgeX

DeleteNotificationById deletes a notification by id

func (*Client) DeleteProcessedNotificationsByAge 

func (c *Client) DeleteProcessedNotificationsByAge(age int64) (err errors.EdgeX)

DeleteProcessedNotificationsByAge deletes processed notifications and their corresponding transmissions that are older than age. This function is implemented to starts up two goroutines to delete transmissions and notifications in the background to achieve better performance.

func (*Client) DeleteProcessedTransmissionsByAge 

func (c *Client) DeleteProcessedTransmissionsByAge(age int64) (err errors.EdgeX)

DeleteProcessedTransmissionsByAge deletes the processed transmissions((ACKNOWLEDGED, SENT, ESCALATED) that are older than age. This function is implemented to starts up goroutines to delete processed transmissions in the background to achieve better performance.

func (*Client) DeleteProvisionWatcherByName 

func (c *Client) DeleteProvisionWatcherByName(name string) errors.EdgeX

DeleteProvisionWatcherByName deletes a provision watcher by name

func (*Client) DeleteSubscriptionByName 

func (c *Client) DeleteSubscriptionByName(name string) errors.EdgeX

DeleteSubscriptionByName deletes a subscription by name

func (*Client) DeviceById 

func (c *Client) DeviceById(id string) (device model.Device, edgeXerr errors.EdgeX)

DeviceById gets a device by id

func (*Client) DeviceByName 

func (c *Client) DeviceByName(name string) (device model.Device, edgeXerr errors.EdgeX)

DeviceByName gets a device by name

func (*Client) DeviceIdExists 

func (c *Client) DeviceIdExists(id string) (bool, errors.EdgeX)

DeviceIdExists checks the device existence by id

func (*Client) DeviceNameExists 

func (c *Client) DeviceNameExists(name string) (bool, errors.EdgeX)

DeviceNameExists checks the device existence by name

func (*Client) DeviceProfileByName 

func (c *Client) DeviceProfileByName(name string) (deviceProfile model.DeviceProfile, edgeXerr errors.EdgeX)

DeviceProfileByName gets a device profile by name

func (*Client) DeviceProfileNameExists 

func (c *Client) DeviceProfileNameExists(name string) (bool, errors.EdgeX)

DeviceProfileNameExists checks the device profile exists by name

func (*Client) DeviceProfilesByManufacturer 

func (c *Client) DeviceProfilesByManufacturer(offset int, limit int, manufacturer string) ([]model.DeviceProfile, errors.EdgeX)

DeviceProfilesByManufacturer query device profiles with offset, limit and manufacturer

func (*Client) DeviceProfilesByManufacturerAndModel 

func (c *Client) DeviceProfilesByManufacturerAndModel(offset int, limit int, manufacturer string, model string) ([]model.DeviceProfile, errors.EdgeX)

DeviceProfilesByManufacturerAndModel query device profiles with offset, limit, manufacturer and model

func (*Client) DeviceProfilesByModel 

func (c *Client) DeviceProfilesByModel(offset int, limit int, model string) ([]model.DeviceProfile, errors.EdgeX)

DeviceProfilesByModel query device profiles with offset, limit and model

func (*Client) DeviceServiceById 

func (c *Client) DeviceServiceById(id string) (deviceService model.DeviceService, edgeXerr errors.EdgeX)

DeviceServiceById gets a device service by id

func (*Client) DeviceServiceByName 

func (c *Client) DeviceServiceByName(name string) (deviceService model.DeviceService, edgeXerr errors.EdgeX)

DeviceServiceByName gets a device service by name

func (*Client) DeviceServiceNameExists 

func (c *Client) DeviceServiceNameExists(name string) (bool, errors.EdgeX)

DeviceServiceNameExists checks the device service exists by name

func (*Client) DevicesByProfileName 

func (c *Client) DevicesByProfileName(offset int, limit int, profileName string) (devices []model.Device, edgeXerr errors.EdgeX)

DevicesByProfileName query devices by offset, limit and profile name

func (*Client) DevicesByServiceName 

func (c *Client) DevicesByServiceName(offset int, limit int, name string) (devices []model.Device, edgeXerr errors.EdgeX)

DevicesByServiceName query devices by offset, limit and name

func (*Client) EventById 

func (c *Client) EventById(id string) (event model.Event, edgeXerr errors.EdgeX)

EventById gets an event by id

func (*Client) EventCountByDeviceName 

func (c *Client) EventCountByDeviceName(deviceName string) (uint32, errors.EdgeX)

EventCountByDevice returns the count of Event associated a specific Device from the database

func (*Client) EventTotalCount 

func (c *Client) EventTotalCount() (uint32, errors.EdgeX)

EventTotalCount returns the total count of Event from the database

func (*Client) EventsByDeviceName 

func (c *Client) EventsByDeviceName(offset int, limit int, name string) (events []model.Event, edgeXerr errors.EdgeX)

EventsByDeviceName query events by offset, limit and device name

func (*Client) EventsByTimeRange 

func (c *Client) EventsByTimeRange(startTime int, endTime int, offset int, limit int) (events []model.Event, edgeXerr errors.EdgeX)

EventsByTimeRange query events by time range, offset, and limit

func (*Client) IntervalActionById 

func (c *Client) IntervalActionById(id string) (action model.IntervalAction, edgeXerr errors.EdgeX)

IntervalActionById gets a intervalAction by id

func (*Client) IntervalActionByName 

func (c *Client) IntervalActionByName(name string) (action model.IntervalAction, edgeXerr errors.EdgeX)

IntervalActionByName gets a intervalAction by name

func (*Client) IntervalActionsByIntervalName 

func (c *Client) IntervalActionsByIntervalName(offset int, limit int, intervalName string) (actions []model.IntervalAction, edgeXerr errors.EdgeX)

IntervalActionsByIntervalName query intervalActions by offset, limit and intervalName

func (*Client) IntervalById 

func (c *Client) IntervalById(id string) (interval model.Interval, edgeXerr errors.EdgeX)

IntervalById gets a interval by id

func (*Client) IntervalByName 

func (c *Client) IntervalByName(name string) (interval model.Interval, edgeXerr errors.EdgeX)

IntervalByName gets a interval by name

func (*Client) NotificationById 

func (c *Client) NotificationById(id string) (notification model.Notification, edgexErr errors.EdgeX)

NotificationById gets a notification by id

func (*Client) NotificationsByCategoriesAndLabels 

func (c *Client) NotificationsByCategoriesAndLabels(offset int, limit int, categories []string, labels []string) (notifications []model.Notification, edgeXerr errors.EdgeX)

NotificationsByCategoriesAndLabels queries notifications by offset, limit, categories and labels

func (*Client) NotificationsByCategory 

func (c *Client) NotificationsByCategory(offset int, limit int, category string) (notifications []model.Notification, edgeXerr errors.EdgeX)

NotificationsByCategory queries notifications by offset, limit and category

func (*Client) NotificationsByLabel 

func (c *Client) NotificationsByLabel(offset int, limit int, label string) (notifications []model.Notification, edgeXerr errors.EdgeX)

NotificationsByLabel queries notifications by offset, limit and label

func (*Client) NotificationsByStatus 

func (c *Client) NotificationsByStatus(offset int, limit int, status string) (notifications []model.Notification, edgeXerr errors.EdgeX)

NotificationsByStatus queries notifications by offset, limit and status

func (*Client) NotificationsByTimeRange 

func (c *Client) NotificationsByTimeRange(start int, end int, offset int, limit int) (notifications []model.Notification, edgeXerr errors.EdgeX)

NotificationsByTimeRange query notifications by time range, offset, and limit

func (*Client) ProvisionWatcherById 

func (c *Client) ProvisionWatcherById(id string) (provisionWatcher model.ProvisionWatcher, edgexErr errors.EdgeX)

ProvisionWatcherById gets a provision watcher by id

func (*Client) ProvisionWatcherByName 

func (c *Client) ProvisionWatcherByName(name string) (provisionWatcher model.ProvisionWatcher, edgexErr errors.EdgeX)

ProvisionWatcherByName gets a provision watcher by name

func (*Client) ProvisionWatchersByProfileName 

func (c *Client) ProvisionWatchersByProfileName(offset int, limit int, name string) (provisionWatchers []model.ProvisionWatcher, edgexErr errors.EdgeX)

ProvisionWatchersByProfileName query provision watchers by offset, limit and profile name

func (*Client) ProvisionWatchersByServiceName 

func (c *Client) ProvisionWatchersByServiceName(offset int, limit int, name string) (provisionWatchers []model.ProvisionWatcher, edgexErr errors.EdgeX)

ProvisionWatchersByServiceName query provision watchers by offset, limit and service name

func (*Client) ReadingCountByDeviceName 

func (c *Client) ReadingCountByDeviceName(deviceName string) (uint32, errors.EdgeX)

ReadingCountByDeviceName returns the count of Readings associated a specific Device from the database

func (*Client) ReadingTotalCount 

func (c *Client) ReadingTotalCount() (uint32, errors.EdgeX)

ReadingTotalCount returns the total count of Event from the database

func (*Client) ReadingsByDeviceName 

func (c *Client) ReadingsByDeviceName(offset int, limit int, name string) (readings []model.Reading, edgeXerr errors.EdgeX)

ReadingsByDeviceName query readings by offset, limit and device name

func (*Client) ReadingsByResourceName 

func (c *Client) ReadingsByResourceName(offset int, limit int, resourceName string) (readings []model.Reading, edgeXerr errors.EdgeX)

ReadingsByResourceName query readings by offset, limit and resource name

func (*Client) ReadingsByTimeRange 

func (c *Client) ReadingsByTimeRange(start int, end int, offset int, limit int) (readings []model.Reading, edgeXerr errors.EdgeX)

ReadingsByTimeRange query readings by time range, offset, and limit

func (*Client) SubscriptionById 

func (c *Client) SubscriptionById(id string) (subscription model.Subscription, edgexErr errors.EdgeX)

SubscriptionById gets a subscription by id

func (*Client) SubscriptionByName 

func (c *Client) SubscriptionByName(name string) (subscription model.Subscription, edgeXerr errors.EdgeX)

SubscriptionByName queries subscription by name

func (*Client) SubscriptionsByCategoriesAndLabels 

func (c *Client) SubscriptionsByCategoriesAndLabels(offset int, limit int, categories []string, labels []string) (subscriptions []model.Subscription, edgeXerr errors.EdgeX)

SubscriptionsByCategoriesAndLabels queries subscriptions by offset, limit, categories and labels

func (*Client) SubscriptionsByCategory 

func (c *Client) SubscriptionsByCategory(offset int, limit int, category string) (subscriptions []model.Subscription, edgeXerr errors.EdgeX)

SubscriptionsByCategory queries subscriptions by offset, limit and category

func (*Client) SubscriptionsByLabel 

func (c *Client) SubscriptionsByLabel(offset int, limit int, label string) (subscriptions []model.Subscription, edgeXerr errors.EdgeX)

SubscriptionsByLabel queries subscriptions by offset, limit and label

func (*Client) SubscriptionsByReceiver 

func (c *Client) SubscriptionsByReceiver(offset int, limit int, receiver string) (subscriptions []model.Subscription, edgeXerr errors.EdgeX)

SubscriptionsByReceiver queries subscriptions by offset, limit and receiver

func (*Client) TransmissionById 

func (c *Client) TransmissionById(id string) (trans model.Transmission, edgexErr errors.EdgeX)

TransmissionById gets a transmission by id

func (*Client) TransmissionsByStatus 

func (c *Client) TransmissionsByStatus(offset int, limit int, status string) (transmissions []model.Transmission, err errors.EdgeX)

TransmissionsByStatus queries transmissions by offset, limit and status

func (*Client) TransmissionsBySubscriptionName 

func (c *Client) TransmissionsBySubscriptionName(offset int, limit int, subscriptionName string) (transmissions []model.Transmission, err errors.EdgeX)

TransmissionsBySubscriptionName queries transmissions by offset, limit and subscription name

func (*Client) TransmissionsByTimeRange 

func (c *Client) TransmissionsByTimeRange(start int, end int, offset int, limit int) (transmissions []model.Transmission, err errors.EdgeX)

TransmissionsByTimeRange query transmissions by time range, offset, and limit

func (*Client) UpdateDevice 

func (c *Client) UpdateDevice(d model.Device) errors.EdgeX

Update a device

func (*Client) UpdateDeviceProfile 

func (c *Client) UpdateDeviceProfile(dp model.DeviceProfile) errors.EdgeX

UpdateDeviceProfile updates a new device profile

func (*Client) UpdateDeviceService 

func (c *Client) UpdateDeviceService(ds model.DeviceService) errors.EdgeX

UpdateDeviceService updates a device service

func (*Client) UpdateInterval 

func (c *Client) UpdateInterval(interval model.Interval) errors.EdgeX

UpdateInterval updates a interval

func (*Client) UpdateIntervalAction 

func (c *Client) UpdateIntervalAction(action model.IntervalAction) errors.EdgeX

UpdateIntervalAction updates a intervalAction

func (*Client) UpdateNotification 

func (c *Client) UpdateNotification(n model.Notification) errors.EdgeX

UpdateNotification updates a notification

func (*Client) UpdateProvisionWatcher 

func (c *Client) UpdateProvisionWatcher(pw model.ProvisionWatcher) errors.EdgeX

Update a provision watcher

func (*Client) UpdateSubscription 

func (c *Client) UpdateSubscription(subscription model.Subscription) errors.EdgeX

UpdateSubscription updates a new subscription

func (*Client) UpdateTransmission 

func (c *Client) UpdateTransmission(trans model.Transmission) errors.EdgeX

UpdateTransmission updates a transmission

Source Files

View all Source files

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.