Initial go port of epics
This commit is contained in:
Martino Ferrari
@@ -1,17 +1,311 @@
|
||||
//go:build !epics
|
||||
|
||||
// Package epics provides an EPICS Channel Access data source.
|
||||
// When built without the "epics" build tag (i.e. without CGo and EPICS Base),
|
||||
// this stub is compiled instead, so that the rest of the codebase can call
|
||||
// epics.Available() to decide whether to register the data source.
|
||||
// Package epics provides an EPICS Channel Access data source for uopi using a
|
||||
// pure-Go CA implementation (no CGo, no EPICS Base installation required).
|
||||
// When built WITH the "epics" build tag, the CGo-based implementation in
|
||||
// epics.go is used instead; that version requires CGo and a working EPICS Base.
|
||||
package epics
|
||||
|
||||
import "github.com/uopi/uopi/internal/datasource"
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog" //nolint:depguard
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
// Available reports whether the EPICS Channel Access data source is compiled in.
|
||||
// It always returns false when built without the "epics" build tag.
|
||||
func Available() bool { return false }
|
||||
ca "github.com/uopi/goca"
|
||||
"github.com/uopi/goca/proto"
|
||||
"github.com/uopi/uopi/internal/datasource"
|
||||
)
|
||||
|
||||
// New is a placeholder that returns nil when EPICS support is not compiled in.
|
||||
// Callers must check Available() before calling New().
|
||||
func New(caAddrList, archiveURL string) datasource.DataSource { return nil }
|
||||
// Available always returns true for the pure-Go build.
|
||||
func Available() bool { return true }
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// EPICS data source (pure-Go implementation) //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
// EPICS is the pure-Go Channel Access data source.
|
||||
type EPICS struct {
|
||||
caAddrList string
|
||||
archiveURL string
|
||||
pvNames []string // pre-fetched at connect time for ListSignals
|
||||
|
||||
client *ca.Client
|
||||
|
||||
mu sync.RWMutex
|
||||
metadata map[string]datasource.Metadata
|
||||
}
|
||||
|
||||
// New creates a new EPICS Channel Access data source.
|
||||
//
|
||||
// caAddrList is the EPICS_CA_ADDR_LIST value (space-separated addresses).
|
||||
// Leave empty to use the environment variable.
|
||||
// archiveURL is the base URL of an EPICS Archive Appliance instance; leave
|
||||
// empty to disable history queries.
|
||||
// pvNames is an optional list of PV names whose metadata will be pre-fetched
|
||||
// at connect time so they appear in ListSignals immediately (useful for the
|
||||
// edit-mode signal tree).
|
||||
func New(caAddrList, archiveURL string, pvNames []string) datasource.DataSource {
|
||||
return &EPICS{
|
||||
caAddrList: caAddrList,
|
||||
archiveURL: archiveURL,
|
||||
pvNames: pvNames,
|
||||
metadata: make(map[string]datasource.Metadata),
|
||||
}
|
||||
}
|
||||
|
||||
// Name implements datasource.DataSource.
|
||||
func (e *EPICS) Name() string { return "epics" }
|
||||
|
||||
// Connect creates the CA client and starts background I/O goroutines.
|
||||
// ctx governs the lifetime of the client; cancel it to shut everything down.
|
||||
func (e *EPICS) Connect(ctx context.Context) error {
|
||||
cfg := ca.ConfigFromEnv()
|
||||
if e.caAddrList != "" {
|
||||
cfg.AddrList = strings.Fields(e.caAddrList)
|
||||
cfg.AutoAddrList = false
|
||||
}
|
||||
slog.Info("epics: connecting CA client", "addrs", cfg.AddrList, "auto_addr", cfg.AutoAddrList)
|
||||
cli, err := ca.NewClient(ctx, cfg)
|
||||
if err != nil {
|
||||
return fmt.Errorf("epics: %w", err)
|
||||
}
|
||||
e.client = cli
|
||||
slog.Info("epics: CA client started", "addrs", cfg.AddrList)
|
||||
|
||||
// Pre-fetch metadata for any configured PV names so they appear in
|
||||
// ListSignals as soon as the datasource is ready. We open a short-lived
|
||||
// subscription (which drives channel connection) and then fetch CTRL info.
|
||||
if len(e.pvNames) > 0 {
|
||||
go func() {
|
||||
for _, pv := range e.pvNames {
|
||||
if ctx.Err() != nil {
|
||||
return
|
||||
}
|
||||
func() {
|
||||
tvCh := make(chan proto.TimeValue, 1)
|
||||
subCtx, subCancel := context.WithTimeout(ctx, 15*time.Second)
|
||||
defer subCancel()
|
||||
cancel, err := e.client.Subscribe(subCtx, pv, tvCh)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer cancel()
|
||||
// Channel is now connected; fetch CTRL metadata.
|
||||
mctx, mcancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
defer mcancel()
|
||||
_, _ = e.GetMetadata(mctx, pv)
|
||||
}()
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// Subscribe //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
// Subscribe registers ch to receive live value updates for signal.
|
||||
// It blocks until the CA channel is connected (or ctx expires).
|
||||
// A background goroutine forwards proto.TimeValue updates to ch as
|
||||
// datasource.Value. Call the returned CancelFunc to unsubscribe.
|
||||
func (e *EPICS) Subscribe(ctx context.Context, signal string, ch chan<- datasource.Value) (datasource.CancelFunc, error) {
|
||||
slog.Info("epics: subscribing", "pv", signal)
|
||||
tvCh := make(chan proto.TimeValue, 16)
|
||||
|
||||
clientCancel, err := e.client.Subscribe(ctx, signal, tvCh)
|
||||
if err != nil {
|
||||
slog.Error("epics: subscribe failed", "pv", signal, "err", err)
|
||||
return nil, fmt.Errorf("epics: subscribe %q: %w", signal, err)
|
||||
}
|
||||
slog.Info("epics: subscribed OK", "pv", signal)
|
||||
|
||||
// Fetch and cache metadata now that the channel is connected.
|
||||
// Send MetaUpdate so the dispatcher re-broadcasts metadata to clients.
|
||||
go func() {
|
||||
// Small delay gives ACCESS_RIGHTS message time to arrive before GetCtrl.
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
mctx, mcancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
defer mcancel()
|
||||
if _, err := e.GetMetadata(mctx, signal); err == nil {
|
||||
select {
|
||||
case ch <- datasource.Value{MetaUpdate: true}:
|
||||
default:
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
done := make(chan struct{})
|
||||
|
||||
// Forward goroutine: convert proto.TimeValue → datasource.Value.
|
||||
go func() {
|
||||
for {
|
||||
select {
|
||||
case tv := <-tvCh:
|
||||
slog.Debug("epics: value received", "pv", signal, "double", tv.Double, "severity", tv.Severity)
|
||||
val := e.timeValueToDS(signal, tv)
|
||||
select {
|
||||
case ch <- val:
|
||||
default: // drop if consumer is slow
|
||||
}
|
||||
case <-done:
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
cancel := func() {
|
||||
clientCancel()
|
||||
close(done)
|
||||
}
|
||||
return datasource.CancelFunc(cancel), nil
|
||||
}
|
||||
|
||||
// timeValueToDS converts a proto.TimeValue to a datasource.Value.
|
||||
func (e *EPICS) timeValueToDS(signal string, tv proto.TimeValue) datasource.Value {
|
||||
var data any
|
||||
if tv.Doubles != nil {
|
||||
data = tv.Doubles
|
||||
} else if tv.Str != "" {
|
||||
data = tv.Str
|
||||
} else {
|
||||
// Use cached metadata type for correct int64 / float64 distinction.
|
||||
e.mu.RLock()
|
||||
meta, hasMeta := e.metadata[signal]
|
||||
e.mu.RUnlock()
|
||||
if hasMeta && (meta.Type == datasource.TypeInt64 || meta.Type == datasource.TypeEnum) {
|
||||
data = int64(tv.Long)
|
||||
} else {
|
||||
data = tv.Double
|
||||
}
|
||||
}
|
||||
|
||||
quality := datasource.QualityGood
|
||||
switch tv.Severity {
|
||||
case proto.SeverityMinor:
|
||||
quality = datasource.QualityUncertain
|
||||
case proto.SeverityMajor, proto.SeverityInvalid:
|
||||
quality = datasource.QualityBad
|
||||
}
|
||||
|
||||
return datasource.Value{
|
||||
Timestamp: tv.Timestamp,
|
||||
Data: data,
|
||||
Quality: quality,
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// GetMetadata //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
// GetMetadata returns metadata for signal, using a cached value when available.
|
||||
// On the first call for a signal it performs a DBR_CTRL_* GET to retrieve
|
||||
// units, display limits, enum strings, and access rights.
|
||||
func (e *EPICS) GetMetadata(ctx context.Context, signal string) (datasource.Metadata, error) {
|
||||
e.mu.RLock()
|
||||
if m, ok := e.metadata[signal]; ok {
|
||||
e.mu.RUnlock()
|
||||
return m, nil
|
||||
}
|
||||
e.mu.RUnlock()
|
||||
|
||||
slog.Info("epics: fetching metadata", "pv", signal)
|
||||
ci, err := e.client.GetCtrl(ctx, signal)
|
||||
if err != nil {
|
||||
slog.Error("epics: GetMetadata failed", "pv", signal, "err", err)
|
||||
return datasource.Metadata{}, fmt.Errorf("epics: GetMetadata %q: %w", signal, err)
|
||||
}
|
||||
|
||||
m := e.ctrlToMeta(signal, ci)
|
||||
slog.Info("epics: metadata fetched", "pv", signal, "type", m.Type, "unit", m.Unit, "writable", m.Writable)
|
||||
|
||||
e.mu.Lock()
|
||||
e.metadata[signal] = m
|
||||
e.mu.Unlock()
|
||||
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// ctrlToMeta converts a ca.CtrlInfo to a datasource.Metadata.
|
||||
func (e *EPICS) ctrlToMeta(name string, ci ca.CtrlInfo) datasource.Metadata {
|
||||
m := datasource.Metadata{
|
||||
Name: name,
|
||||
Writable: ci.Access&proto.AccessWrite != 0,
|
||||
}
|
||||
|
||||
switch {
|
||||
case ci.Double != nil:
|
||||
m.Type = datasource.TypeFloat64
|
||||
if ci.Count > 1 {
|
||||
m.Type = datasource.TypeFloat64Array
|
||||
}
|
||||
m.Unit = ci.Double.Units
|
||||
m.DisplayLow = ci.Double.LowerDispLimit
|
||||
m.DisplayHigh = ci.Double.UpperDispLimit
|
||||
m.DriveLow = ci.Double.LowerCtrlLimit
|
||||
m.DriveHigh = ci.Double.UpperCtrlLimit
|
||||
|
||||
case ci.Long != nil:
|
||||
m.Type = datasource.TypeInt64
|
||||
m.Unit = ci.Long.Units
|
||||
m.DisplayLow = float64(ci.Long.LowerDispLimit)
|
||||
m.DisplayHigh = float64(ci.Long.UpperDispLimit)
|
||||
m.DriveLow = float64(ci.Long.LowerCtrlLimit)
|
||||
m.DriveHigh = float64(ci.Long.UpperCtrlLimit)
|
||||
|
||||
case ci.Enum != nil:
|
||||
m.Type = datasource.TypeEnum
|
||||
m.EnumStrings = ci.Enum.Strings
|
||||
|
||||
case ci.Str != nil:
|
||||
m.Type = datasource.TypeString
|
||||
}
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// ListSignals //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
// ListSignals returns metadata for all signals with cached information.
|
||||
func (e *EPICS) ListSignals(_ context.Context) ([]datasource.Metadata, error) {
|
||||
e.mu.RLock()
|
||||
defer e.mu.RUnlock()
|
||||
out := make([]datasource.Metadata, 0, len(e.metadata))
|
||||
for _, m := range e.metadata {
|
||||
out = append(out, m)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// Write //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
// Write puts a new value onto the named CA channel.
|
||||
// value must be one of: float64, float32, int64, int32, int, int16, string, bool.
|
||||
func (e *EPICS) Write(ctx context.Context, signal string, value any) error {
|
||||
if err := e.client.Put(ctx, signal, value); err != nil {
|
||||
return fmt.Errorf("epics: write %q: %w", signal, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------- //
|
||||
// History //
|
||||
// -------------------------------------------------------------------------- //
|
||||
|
||||
// History delegates to the Archive Appliance client, or returns
|
||||
// ErrHistoryUnavailable if no archive URL is configured.
|
||||
func (e *EPICS) History(ctx context.Context, signal string, start, end time.Time, maxPoints int) ([]datasource.Value, error) {
|
||||
if e.archiveURL == "" {
|
||||
return nil, datasource.ErrHistoryUnavailable
|
||||
}
|
||||
return fetchArchiveHistory(ctx, e.archiveURL, signal, start, end, maxPoints)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user