import "google.golang.org/grpc/metadata"

md := metadata.Pairs("authorization", "Bearer eyJhbGciOiJIUzI1NiIs...")
ctx := metadata.NewOutgoingContext(context.Background(), md)

resp, err := client.GetUser(ctx, &pb.GetUserRequest{UserId: "usr_abc123"})

md := metadata.Pairs("x-api-key", "ogk_live_abc123...")
ctx := metadata.NewOutgoingContext(context.Background(), md)

resp, err := threatClient.CheckIndicator(ctx, &pb.CheckIndicatorRequest{
    Indicator: "suspicious-domain.com",
    Type:      pb.IndicatorType_DOMAIN,
})

import "google.golang.org/grpc/credentials"

creds, err := credentials.NewClientTLSFromFile("ca.pem", "")
// For mTLS, load both client cert and key
tlsCert, err := tls.LoadX509KeyPair("client.pem", "client-key.pem")

tlsConfig := &tls.Config{
    Certificates: []tls.Certificate{tlsCert},
    RootCAs:      certPool,
}

conn, err := grpc.Dial(
    "mesh-node-ip:50051",
    grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
)

package main

import (
    "context"
    "fmt"
    "log"

    pb "github.com/orbvpn/proto/orbguard/v1"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "google.golang.org/grpc/metadata"
)

func main() {
    // Connect with TLS
    creds, err := credentials.NewClientTLSFromFile("ca.pem", "guard.orbai.world")
    if err != nil {
        log.Fatal(err)
    }

    conn, err := grpc.Dial("guard.orbai.world:50051", grpc.WithTransportCredentials(creds))
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    client := pb.NewThreatIntelligenceServiceClient(conn)

    // Attach API key
    ctx := metadata.AppendToOutgoingContext(
        context.Background(),
        "x-api-key", "ogk_live_abc123...",
    )

    // Check a threat indicator
    resp, err := client.CheckIndicator(ctx, &pb.CheckIndicatorRequest{
        Indicator:      "suspicious-domain.com",
        Type:           pb.IndicatorType_DOMAIN,
        IncludeContext: true,
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Indicator: %s\n", resp.Indicator)
    fmt.Printf("Score:     %d/100\n", resp.Score)
    fmt.Printf("Severity:  %s\n", resp.Severity)
    fmt.Printf("Malicious: %v\n", resp.IsMalicious)

    for _, cat := range resp.Categories {
        fmt.Printf("  Category: %s\n", cat)
    }
}

// Stream real-time threat events
stream, err := client.StreamThreats(ctx, &pb.StreamThreatsRequest{
    Severity:   []pb.Severity{pb.Severity_HIGH, pb.Severity_CRITICAL},
    Categories: []string{"malware", "phishing", "c2"},
})
if err != nil {
    log.Fatal(err)
}

for {
    event, err := stream.Recv()
    if err != nil {
        log.Println("Stream ended:", err)
        break
    }

    fmt.Printf("[%s] %s -- %s (score: %d)\n",
        event.Severity,
        event.IndicatorType,
        event.Indicator,
        event.Score,
    )
}

// Bidirectional topology sync with OrbMesh
stream, err := meshClient.SyncTopology(ctx)
if err != nil {
    log.Fatal(err)
}

// Send local topology updates in a goroutine
go func() {
    updates := getLocalTopologyUpdates() // your implementation
    for _, update := range updates {
        if err := stream.Send(&update); err != nil {
            log.Println("Send error:", err)
            return
        }
    }
    stream.CloseSend()
}()

// Receive cluster-wide topology updates
for {
    update, err := stream.Recv()
    if err != nil {
        log.Println("Stream ended:", err)
        break
    }

    fmt.Printf("Topology update: node=%s action=%s\n",
        update.NodeId, update.Action)
    applyTopologyUpdate(update) // your implementation
}

import grpc
from orbguard.v1 import threat_service_pb2 as pb
from orbguard.v1 import threat_service_pb2_grpc as pb_grpc

# Connect with TLS
credentials = grpc.ssl_channel_credentials(
    root_certificates=open("ca.pem", "rb").read()
)

channel = grpc.secure_channel("guard.orbai.world:50051", credentials)
client = pb_grpc.ThreatIntelligenceServiceStub(channel)

# Attach API key metadata
metadata = [("x-api-key", "ogk_live_abc123...")]

# Check a threat indicator
response = client.CheckIndicator(
    pb.CheckIndicatorRequest(
        indicator="suspicious-domain.com",
        type=pb.DOMAIN,
        include_context=True,
    ),
    metadata=metadata,
)

print(f"Indicator: {response.indicator}")
print(f"Score:     {response.score}/100")
print(f"Severity:  {pb.Severity.Name(response.severity)}")
print(f"Malicious: {response.is_malicious}")

# Stream real-time threats
stream = client.StreamThreats(
    pb.StreamThreatsRequest(
        severity=[pb.HIGH, pb.CRITICAL],
        categories=["malware", "phishing"],
    ),
    metadata=metadata,
)

for event in stream:
    print(f"[{pb.Severity.Name(event.severity)}] "
          f"{pb.IndicatorType.Name(event.indicator_type)}: "
          f"{event.indicator} (score: {event.score})")

import asyncio
import grpc.aio

async def live_analysis():
    channel = grpc.aio.secure_channel(
        "guard.orbai.world:50051",
        grpc.ssl_channel_credentials(open("ca.pem", "rb").read()),
    )
    client = pb_grpc.ThreatIntelligenceServiceStub(channel)
    metadata = [("x-api-key", "ogk_live_abc123...")]

    # Bidirectional stream
    async def indicator_generator():
        indicators = [
            ("suspicious-domain.com", pb.DOMAIN),
            ("192.168.1.100", pb.IP),
            ("https://phishing-site.com/login", pb.URL),
        ]
        for indicator, itype in indicators:
            yield pb.AnalysisRequest(indicator=indicator, type=itype)
            await asyncio.sleep(0.1)  # Simulate real-time submissions

    stream = client.LiveAnalysis(indicator_generator(), metadata=metadata)

    async for result in stream:
        print(f"Result: {result.indicator} -> score={result.score}, "
              f"malicious={result.is_malicious}")

asyncio.run(live_analysis())

# Using protoc (Go example)
protoc --go_out=. --go-grpc_out=. \
  -I proto/ \
  proto/orbguard/v1/threat_service.proto

# Using buf (recommended)
buf generate proto/

# Using grpc_tools (Python)
python -m grpc_tools.protoc \
  -I proto/ \
  --python_out=. \
  --grpc_python_out=. \
  proto/orbguard/v1/threat_service.proto

# List available services (requires server reflection)
grpcurl -cacert ca.pem guard.orbai.world:50051 list

# Describe a service
grpcurl -cacert ca.pem guard.orbai.world:50051 \
  describe orbvpn.guard.v1.ThreatIntelligenceService

# Check a threat indicator
grpcurl -cacert ca.pem \
  -H "x-api-key: ogk_live_abc123..." \
  -d '{"indicator": "suspicious-domain.com", "type": "DOMAIN"}' \
  guard.orbai.world:50051 \
  orbvpn.guard.v1.ThreatIntelligenceService/CheckIndicator

# Stream threats (server streaming)
grpcurl -cacert ca.pem \
  -H "x-api-key: ogk_live_abc123..." \
  -d '{"severity": ["HIGH", "CRITICAL"]}' \
  guard.orbai.world:50051 \
  orbvpn.guard.v1.ThreatIntelligenceService/StreamThreats

import (
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

resp, err := client.CheckIndicator(ctx, req)
if err != nil {
    st, ok := status.FromError(err)
    if ok {
        switch st.Code() {
        case codes.Unauthenticated:
            // Refresh token and retry
        case codes.ResourceExhausted:
            // Rate limited -- backoff and retry
        case codes.Unavailable:
            // Transient failure -- retry with backoff
        default:
            log.Fatalf("gRPC error: %s -- %s", st.Code(), st.Message())
        }
    }
}

ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

resp, err := client.CheckIndicator(ctx, req)