main.go

Documentation: github.com/linkerd/linkerd2/controller/script/destination-client

     1  package main
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"flag"
     7  	"io"
     8  
     9  	pb "github.com/linkerd/linkerd2-proxy-api/go/destination"
    10  	"github.com/linkerd/linkerd2/controller/api/destination"
    11  	addrUtil "github.com/linkerd/linkerd2/pkg/addr"
    12  	log "github.com/sirupsen/logrus"
    13  )
    14  
    15  // This is a throwaway script for testing the destination service
    16  
    17  func main() {
    18  	addr := flag.String("addr", ":8086", "address of destination service")
    19  	path := flag.String("path", "strest-server.default.svc.cluster.local:8888", "destination path")
    20  	method := flag.String("method", "get", "which gRPC method to invoke")
    21  	token := flag.String("token", "", "context token")
    22  	flag.Parse()
    23  
    24  	client, conn, err := destination.NewClient(*addr)
    25  	if err != nil {
    26  		log.Fatal(err.Error())
    27  	}
    28  	defer conn.Close()
    29  
    30  	req := &pb.GetDestination{
    31  		Scheme:       "k8s",
    32  		Path:         *path,
    33  		ContextToken: *token,
    34  	}
    35  
    36  	switch *method {
    37  	case "get":
    38  		get(client, req)
    39  	case "getProfile":
    40  		getProfile(client, req)
    41  	default:
    42  		//nolint:gocritic
    43  		log.Fatalf("Unknown method: %s; supported methods: get, getProfile", *method)
    44  	}
    45  }
    46  
    47  func get(client pb.DestinationClient, req *pb.GetDestination) {
    48  	rsp, err := client.Get(context.Background(), req)
    49  	if err != nil {
    50  		log.Fatal(err.Error())
    51  	}
    52  
    53  	for {
    54  		update, err := rsp.Recv()
    55  		if err != nil {
    56  			if errors.Is(err, io.EOF) {
    57  				break
    58  			}
    59  			log.Fatal(err.Error())
    60  		}
    61  
    62  		switch updateType := update.Update.(type) {
    63  		case *pb.Update_Add:
    64  			log.Println("Add:")
    65  			log.Printf("labels: %v", updateType.Add.MetricLabels)
    66  			for _, addr := range updateType.Add.Addrs {
    67  				log.Printf("- %s:%d", addrUtil.ProxyAddressToString(addr.Addr), addr.Addr.Port)
    68  				log.Printf("  - labels: %v", addr.MetricLabels)
    69  				switch addr.GetProtocolHint().GetProtocol().(type) {
    70  				case *pb.ProtocolHint_H2_:
    71  					log.Printf("  - protocol hint: H2")
    72  				default:
    73  					log.Printf("  - protocol hint: UNKNOWN")
    74  				}
    75  				log.Printf("  - identity: %s", addr.GetTlsIdentity())
    76  				if ot := addr.GetProtocolHint().GetOpaqueTransport(); ot != nil {
    77  					log.Printf("  - opaque transport port: %d", ot.GetInboundPort())
    78  				}
    79  			}
    80  
    81  			log.Println()
    82  		case *pb.Update_Remove:
    83  			log.Println("Remove:")
    84  			for _, addr := range updateType.Remove.Addrs {
    85  				log.Printf("- %s:%d", addrUtil.ProxyAddressToString(addr), addr.Port)
    86  			}
    87  			log.Println()
    88  		case *pb.Update_NoEndpoints:
    89  			log.Println("NoEndpoints:")
    90  			log.Printf("- exists:%t", updateType.NoEndpoints.Exists)
    91  			log.Println()
    92  		}
    93  	}
    94  }
    95  
    96  func getProfile(client pb.DestinationClient, req *pb.GetDestination) {
    97  	rsp, err := client.GetProfile(context.Background(), req)
    98  	if err != nil {
    99  		log.Fatal(err.Error())
   100  	}
   101  
   102  	for {
   103  		update, err := rsp.Recv()
   104  		if err != nil {
   105  			if errors.Is(err, io.EOF) {
   106  				break
   107  			}
   108  			log.Fatal(err.Error())
   109  		}
   110  		log.Printf("%+v", update)
   111  		log.Println()
   112  	}
   113  }
   114
View as plain text