Watch entities

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
	"net/http"
7
	"os"
8
	"time"
9
10
	Lattice "github.com/anduril/lattice-sdk-go/v4"
11
	"github.com/anduril/lattice-sdk-go/v4/client"
12
	"github.com/anduril/lattice-sdk-go/v4/option"
13
)
14
15
func main() {
16
	// Get environment variables
17
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
18
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
19
	clientId := os.Getenv("LATTICE_CLIENT_ID")
20
21
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes.
22
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
23
24
	// Check required environment variables
25
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
26
		fmt.Println("Missing required environment variables")
27
		os.Exit(1)
28
	}
29
30
	// Initialize headers for sandbox authorization
31
	headers := http.Header{}
32
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
33
34
	// Create the client
35
	LatticeClient := client.NewClient(
36
		option.WithClientCredentials(clientId, clientSecret),
37
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
38
		option.WithHTTPHeader(headers),
39
	)
40
41
	// Continuously get the entity
42
	for {
43
		// Create context for the request
44
		ctx := context.Background()
45
46
		entity, err := LatticeClient.Entities.GetEntity(
47
			ctx,
48
			&Lattice.GetEntityRequest{
49
				EntityID: "<ENTITY_ID>",
50
			},
51
		)
52
53
		if err != nil {
54
			fmt.Printf("Error fetching entity: %v\n", err)
55
		} else {
56
			fmt.Printf("Asset name     | %s\n", *entity.GetAliases().GetName())
57
			fmt.Printf("Asset location | %f, %f\n", *entity.GetLocation().GetPosition().GetLatitudeDegrees(),
58
				*entity.GetLocation().GetPosition().GetLongitudeDegrees())
59
		}
60
61
		// Wait before next request
62
		time.Sleep(5 * time.Second)
63
	}
64
}

1
package main
2
3
import (
4
	"context"
5
	"errors"
6
	"fmt"
7
	"io"
8
	"log"
9
	"net/http"
10
	"os"
11
12
	Lattice "github.com/anduril/lattice-sdk-go/v4"
13
	"github.com/anduril/lattice-sdk-go/v4/client"
14
	"github.com/anduril/lattice-sdk-go/v4/option"
15
)
16
17
func main() {
18
	ctx, cancel := context.WithCancel(context.Background())
19
	defer cancel()
20
21
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
22
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
23
	clientId := os.Getenv("LATTICE_CLIENT_ID")
24
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
25
26
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
27
		log.Fatal("Required environment variables not set.")
28
	}
29
30
	headers := http.Header{}
31
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
32
33
	latticeClient := client.NewClient(
34
		option.WithClientCredentials(clientId, clientSecret),
35
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
36
		option.WithHTTPHeader(headers),
37
	)
38
39
	// Create the entity stream.
40
	stream, err := latticeClient.Entities.StreamEntities(ctx, &Lattice.EntityStreamRequest{
41
		PreExistingOnly: Lattice.Bool(false),
42
	})
43
	if err != nil {
44
		log.Fatalf("Failed to create entity stream: %v", err)
45
	}
46
	defer stream.Close()
47
48
	for {
49
		select {
50
		case <-ctx.Done():
51
			log.Printf("Context canceled: %v", ctx.Err())
52
			return
53
		default:
54
			// Continue processing
55
		}
56
		message, err := stream.Recv()
57
58
		if errors.Is(err, io.EOF) {
59
			log.Println("Stream completed successfully.")
60
			return
61
		}
62
63
		if err != nil {
64
			log.Printf("Error receiving message: %v", err)
65
			continue
66
		}
67
68
		// Process the message based on its type
69
		switch message.Event {
70
		case "heartbeat":
71
			timestamp := *message.Heartbeat.Timestamp
72
			log.Printf("Heartbeat: %s", timestamp)
73
		case "entity":
74
			log.Printf("Entity: %s", *message.Entity.Entity.EntityID)
75
		default:
76
			log.Printf("Unknown event type: %s", message.Event)
77
		}
78
	}
79
}

1
package main
2
3
import (
4
	"context"
5
	"errors"
6
	"fmt"
7
	"io"
8
	"log"
9
	"net/http"
10
	"os"
11
12
	Lattice "github.com/anduril/lattice-sdk-go/v4"
13
	"github.com/anduril/lattice-sdk-go/v4/client"
14
	"github.com/anduril/lattice-sdk-go/v4/option"
15
)
16
17
func main() {
18
	ctx, cancel := context.WithCancel(context.Background())
19
	defer cancel()
20
21
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
22
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
23
	clientId := os.Getenv("LATTICE_CLIENT_ID")
24
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
25
26
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
27
		log.Fatal("Required environment variables not set.")
28
	}
29
30
	headers := http.Header{}
31
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
32
33
	latticeClient := client.NewClient(
34
		option.WithClientCredentials(clientId, clientSecret),
35
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
36
		option.WithHTTPHeader(headers),
37
	)
38
39
	// Create the entity stream.
40
	stream, err := latticeClient.Entities.StreamEntities(ctx, &Lattice.EntityStreamRequest{
41
		PreExistingOnly: Lattice.Bool(false),
42
		// Define a list of components to control which entities are fetched.
43
		// If set, Lattice streams only entities with the components you provide.
44
		ComponentsToInclude: []string{"aliases", "location_uncertainty"},
45
	})
46
	if err != nil {
47
		log.Fatalf("Failed to create entity stream: %v", err)
48
	}
49
	defer stream.Close()
50
51
	for {
52
		select {
53
		case <-ctx.Done():
54
			log.Printf("Context canceled: %v", ctx.Err())
55
			return
56
		default:
57
			// Continue processing
58
		}
59
		message, err := stream.Recv()
60
61
		// Handle stream completion
62
		if errors.Is(err, io.EOF) {
63
			log.Println("Stream completed successfully.")
64
			return
65
		}
66
67
		if err != nil {
68
			log.Printf("Error receiving message: %v", err)
69
			continue
70
		}
71
72
		// Process the event based whether it is a heartbeat or entity event.
73
		switch message.Event {
74
		case "heartbeat":
75
			timestamp := *message.Heartbeat.Timestamp
76
			log.Printf("Heartbeat: %s", timestamp)
77
		case "entity":
78
			log.Printf("Entity: %s", *message.Entity.Entity.Aliases.Name)
79
		default:
80
			log.Printf("Unknown event type: %s", message.Event)
81
		}
82
	}
83
}