Manage streams

// This Go example uses the Lattice REST SDK (lattice-sdk-go) to list active ingress streams.
package main
import (
	"context"
	"fmt"
	"net/http"
	"os"
	Lattice "github.com/anduril/lattice-sdk-go/v5"
	"github.com/anduril/lattice-sdk-go/v5/client"
	"github.com/anduril/lattice-sdk-go/v5/option"
)
func main() {
	// Get environment variables
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
	environmentToken := os.Getenv("ENVIRONMENT_TOKEN")
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes.
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
	// Check required environment variables
	if latticeEndpoint == "" || environmentToken == "" || sandboxesToken == "" {
		fmt.Println("Missing required environment variables")
		os.Exit(1)
	}
	// Initialize headers for sandbox authorization
	headers := http.Header{}
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
	// Create the client
	LatticeClient := client.NewClient(
		option.WithToken(environmentToken),
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
		option.WithHTTPHeader(headers),
	)
	ctx := context.Background()
	// Iterate every page of active streams. Keep all request fields identical between
	// pages other than pageToken; the server may reject a request that changes them.
	pageToken := ""
	for {
		response, err := LatticeClient.Video.ListIngressStreams(ctx, &Lattice.ListIngressStreamsRequest{
			PageToken: &pageToken,
		})
		if err != nil {
			fmt.Printf("Failed to list streams: %v\n", err)
			os.Exit(1)
		}
		for _, stream := range response.GetIngressStreams() {
			fmt.Printf("Stream %s status %s\n", *stream.GetIngressID(), *stream.GetStatus())
		}
		if response.GetNextPageToken() == nil || *response.GetNextPageToken() == "" {
			break
		}
		pageToken = *response.GetNextPageToken()
	}
}

// This Go example uses the Lattice REST SDK (lattice-sdk-go) to retrieve a single ingress stream.
package main
import (
	"context"
	"fmt"
	"net/http"
	"os"
	Lattice "github.com/anduril/lattice-sdk-go/v5"
	"github.com/anduril/lattice-sdk-go/v5/client"
	"github.com/anduril/lattice-sdk-go/v5/option"
)
// Ingress ID of the stream to get. Replace before running.
const ingressID = "<INGRESS-ID>"
func main() {
	// Get environment variables
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
	environmentToken := os.Getenv("ENVIRONMENT_TOKEN")
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes.
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
	// Check required environment variables
	if latticeEndpoint == "" || environmentToken == "" || sandboxesToken == "" {
		fmt.Println("Missing required environment variables")
		os.Exit(1)
	}
	// Initialize headers for sandbox authorization
	headers := http.Header{}
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
	// Create the client
	LatticeClient := client.NewClient(
		option.WithToken(environmentToken),
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
		option.WithHTTPHeader(headers),
	)
	ctx := context.Background()
	response, err := LatticeClient.Video.GetIngressStream(ctx, &Lattice.GetIngressStreamRequest{
		IngressID: ingressID,
	})
	if err != nil {
		fmt.Printf("Failed to get stream: %v\n", err)
		os.Exit(1)
	}
	stream := response.GetIngressStream()
	if stream == nil {
		fmt.Printf("No ingress stream found for %s\n", ingressID)
		os.Exit(1)
	}
	fmt.Printf("Ingress ID: %s\n", *stream.GetIngressID())
	fmt.Printf("Title:      %q\n", *stream.GetTitle())
	fmt.Printf("Status:     %s\n", *stream.GetStatus())
}

// This Go example uses the Lattice REST SDK (lattice-sdk-go) to stop (archive) an ingress stream
// and remove its stale media reference from the associated camera entity.
package main
import (
	"context"
	"fmt"
	"net/http"
	"os"
	"time"
	Lattice "github.com/anduril/lattice-sdk-go/v5"
	"github.com/anduril/lattice-sdk-go/v5/client"
	"github.com/anduril/lattice-sdk-go/v5/option"
)
const (
	// Ingress ID of the stream to stop. Replace before running.
	ingressID = "<DELETE-INGRESS-ID>"
	// Entity the video is attached to. Set to "" to only stop the stream without
	// editing any entity's media list.
	entityID = "<ENTITY-ID>"
)
func main() {
	// Get environment variables
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
	environmentToken := os.Getenv("ENVIRONMENT_TOKEN")
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes.
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
	// Check required environment variables
	if latticeEndpoint == "" || environmentToken == "" || sandboxesToken == "" {
		fmt.Println("Missing required environment variables")
		os.Exit(1)
	}
	// Initialize headers for sandbox authorization
	headers := http.Header{}
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
	// Create the client
	LatticeClient := client.NewClient(
		option.WithToken(environmentToken),
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
		option.WithHTTPHeader(headers),
	)
	ctx := context.Background()
	fmt.Printf("Stopping ingress stream with ID: %s\n", ingressID)
	_, err := LatticeClient.Video.DeleteIngressStream(ctx, &Lattice.DeleteIngressStreamRequest{
		IngressID: ingressID,
	})
	if err != nil {
		fmt.Printf("Failed to stop ingress stream: %v\n", err)
		os.Exit(1)
	}
	// With no entity to update, stopping the stream is all there is to do.
	if entityID == "" {
		return
	}
	// Read the entity, filter the stale MediaItem out, and write the surviving items back.
	entity, err := LatticeClient.Entities.GetEntity(ctx, &Lattice.GetEntityRequest{
		EntityID: entityID,
	})
	if err != nil {
		fmt.Printf("Failed to fetch entity %s: %v\n", entityID, err)
		os.Exit(1)
	}
	var current []*Lattice.MediaItem
	if entity.GetMedia() != nil {
		current = entity.GetMedia().GetMedia()
	}
	remaining := make([]*Lattice.MediaItem, 0, len(current))
	for _, item := range current {
		if item.GetItemIdentifier() == nil || *item.GetItemIdentifier() != ingressID {
			remaining = append(remaining, item)
		}
	}
	if len(remaining) == len(current) {
		fmt.Printf("Video %s was not in entity %s media list; nothing to remove\n", ingressID, entityID)
		return
	}
	// A field_path of media replaces the entire Media component with the surviving items.
	_, err = LatticeClient.Entities.OverrideEntity(ctx, &Lattice.EntityOverride{
		EntityID:  entityID,
		FieldPath: "media",
		Entity: &Lattice.Entity{
			EntityID: Lattice.String(entityID),
			Media: &Lattice.Media{
				Media: remaining,
			},
		},
		Provenance: &Lattice.Provenance{
			IntegrationName:  Lattice.String("lattice-video-integration"),
			DataType:         Lattice.String("video-association"),
			SourceUpdateTime: Lattice.Time(time.Now().UTC()),
		},
	})
	if err != nil {
		fmt.Printf("Failed to override entity media: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Removed video %s from entity %s\n", ingressID, entityID)
}