Wworking on improving the tool

internal/datasource/epics/noop.go

@@ -28,9 +28,12 @@ func Available() bool { return true }
 
 // 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
+	caAddrList     string
+	archiveURL     string
+	cfURL          string
+	autoSyncFilter       string
+	autoSyncFromArchiver bool
+	pvNames              []string // pre-fetched at connect time for ListSignals
 
 	client *ca.Client
 
@@ -47,12 +50,15 @@ type EPICS struct {
 // 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 {
+func New(caAddrList, archiveURL, cfURL, autoSyncFilter string, autoSyncFromArchiver bool, pvNames []string) datasource.DataSource {
 	return &EPICS{
-		caAddrList: caAddrList,
-		archiveURL: archiveURL,
-		pvNames:    pvNames,
-		metadata:   make(map[string]datasource.Metadata),
+		caAddrList:           caAddrList,
+		archiveURL:           archiveURL,
+		cfURL:                cfURL,
+		autoSyncFilter:       autoSyncFilter,
+		autoSyncFromArchiver: autoSyncFromArchiver,
+		pvNames:              pvNames,
+		metadata:             make(map[string]datasource.Metadata),
 	}
 }
 
@@ -75,29 +81,24 @@ func (e *EPICS) Connect(ctx context.Context) error {
 	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.
+	// Perform background sync from Channel Finder if configured.
+	if e.cfURL != "" && e.autoSyncFilter != "" {
+		go e.syncFromChannelFinder(ctx)
+	}
+
+	// Perform background sync from Archive Appliance if configured.
+	if e.archiveURL != "" && e.autoSyncFromArchiver {
+		go e.syncFromArchiver(ctx)
+	}
+
+	// Pre-fetch metadata for any configured PV names.
 	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)
-				}()
+				e.prefetchPV(ctx, pv)
 			}
 		}()
 	}
@@ -105,6 +106,62 @@ func (e *EPICS) Connect(ctx context.Context) error {
 	return nil
 }
 
+func (e *EPICS) syncFromChannelFinder(ctx context.Context) {
+	time.Sleep(500 * time.Millisecond)
+	slog.Info("epics: syncing signals from Channel Finder", "url", e.cfURL, "filter", e.autoSyncFilter)
+	channels, err := queryChannelFinder(e.cfURL, e.autoSyncFilter)
+	if err != nil {
+		slog.Error("epics: Channel Finder sync failed", "err", err)
+		return
+	}
+
+	for _, ch := range channels {
+		if ctx.Err() != nil {
+			return
+		}
+		// Convert CFS properties and tags to datasource.Metadata
+		props := make(map[string]string)
+		for _, p := range ch.Properties {
+			props[p.Name] = p.Value
+		}
+		tags := make([]string, len(ch.Tags))
+		for i, t := range ch.Tags {
+			tags[i] = t.Name
+		}
+
+		// Initialize metadata with CFS info. Full metadata (type, units, etc.)
+		// will be populated on first access via DBR_CTRL GET.
+		e.mu.Lock()
+		if _, exists := e.metadata[ch.Name]; !exists {
+			e.metadata[ch.Name] = datasource.Metadata{
+				Name:       ch.Name,
+				Properties: props,
+				Tags:       tags,
+			}
+		}
+		e.mu.Unlock()
+
+		// Background pre-fetch of actual record info (type, etc.)
+		go e.prefetchPV(ctx, ch.Name)
+	}
+	slog.Info("epics: synced signals from Channel Finder", "count", len(channels))
+}
+
+func (e *EPICS) prefetchPV(ctx context.Context, pv string) {
+	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)
+}
+
 // -------------------------------------------------------------------------- //
 // Subscribe                                                                    //
 // -------------------------------------------------------------------------- //
@@ -273,6 +330,7 @@ func (e *EPICS) ctrlToMeta(name string, ci ca.CtrlInfo) datasource.Metadata {
 func (e *EPICS) ListSignals(_ context.Context) ([]datasource.Metadata, error) {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
+	slog.Debug("epics: listing signals", "count", len(e.metadata))
 	out := make([]datasource.Metadata, 0, len(e.metadata))
 	for _, m := range e.metadata {
 		out = append(out, m)
@@ -305,3 +363,27 @@ func (e *EPICS) History(ctx context.Context, signal string, start, end time.Time
 	}
 	return fetchArchiveHistory(ctx, e.archiveURL, signal, start, end, maxPoints)
 }
+
+func (e *EPICS) syncFromArchiver(ctx context.Context) {
+	time.Sleep(1 * time.Second) // wait for network
+	slog.Info("epics: syncing signals from Archiver", "url", e.archiveURL)
+	pvs, err := searchArchivePVs(ctx, e.archiveURL, "*")
+	if err != nil {
+		slog.Error("epics: Archiver sync failed", "err", err)
+		return
+	}
+
+	for _, name := range pvs {
+		if ctx.Err() != nil {
+			return
+		}
+		e.mu.Lock()
+		if _, exists := e.metadata[name]; !exists {
+			e.metadata[name] = datasource.Metadata{Name: name}
+		}
+		e.mu.Unlock()
+		// Background pre-fetch of record info
+		go e.prefetchPV(ctx, name)
+	}
+	slog.Info("epics: synced signals from Archiver", "count", len(pvs))
+}