github.com/telepresenceio/telepresence/v2@v2.20.0-pro.6.0.20240517030216-236ea954e789/pkg/client/cli/internal/apiimpl/connection.go (about)

     1  package apiimpl
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"regexp"
     7  
     8  	"github.com/distribution/reference"
     9  	"google.golang.org/protobuf/types/known/emptypb"
    10  
    11  	"github.com/telepresenceio/telepresence/rpc/v2/connector"
    12  	daemon2 "github.com/telepresenceio/telepresence/rpc/v2/daemon"
    13  	"github.com/telepresenceio/telepresence/rpc/v2/manager"
    14  	"github.com/telepresenceio/telepresence/v2/pkg/client/cli/api"
    15  	"github.com/telepresenceio/telepresence/v2/pkg/client/cli/daemon"
    16  	"github.com/telepresenceio/telepresence/v2/pkg/client/cli/intercept"
    17  )
    18  
    19  type connection struct {
    20  	context.Context
    21  }
    22  
    23  func (c connection) Namespace() string {
    24  	return daemon.GetSession(c).Info.Namespace
    25  }
    26  
    27  func (c connection) AgentImage() (reference.Reference, error) {
    28  	fqn, err := daemon.GetSession(c).AgentImageFQN(c, &emptypb.Empty{})
    29  	if err != nil {
    30  		return nil, err
    31  	}
    32  	return reference.Parse(fqn.FQN)
    33  }
    34  
    35  func (c connection) Close() error {
    36  	return daemon.GetUserClient(c).Conn.Close()
    37  }
    38  
    39  func (c connection) Disconnect() error {
    40  	_, err := daemon.GetSession(c).Disconnect(c, &emptypb.Empty{})
    41  	return err
    42  }
    43  
    44  func (c connection) Info() *connector.ConnectInfo {
    45  	return daemon.GetSession(c).Info
    46  }
    47  
    48  func (c connection) DaemonInfo() (*daemon.Info, error) {
    49  	return daemon.LoadInfo(c, daemon.GetSession(c).DaemonID.InfoFileName())
    50  }
    51  
    52  func (c connection) List(namespace string) ([]*connector.WorkloadInfo, error) {
    53  	if namespace == "" {
    54  		namespace = c.Info().Namespace
    55  	}
    56  	wis, err := daemon.GetSession(c).List(c, &connector.ListRequest{
    57  		Namespace: namespace,
    58  		Filter:    connector.ListRequest_EVERYTHING,
    59  	})
    60  	if err != nil {
    61  		return nil, err
    62  	}
    63  	return wis.Workloads, nil
    64  }
    65  
    66  func (c connection) StartIntercept(rq api.InterceptRequest, mountPoint string) (*intercept.Info, error) {
    67  	ic := toInterceptCmd(&rq, nil)
    68  	ic.Mount, ic.MountSet = toCmdMount(mountPoint)
    69  	return intercept.NewState(ic).Run(c)
    70  }
    71  
    72  func (c connection) RunIntercept(rq api.InterceptRequest, handler api.InterceptHandler) (*intercept.Info, error) {
    73  	ic := toInterceptCmd(&rq, handler)
    74  	return intercept.NewState(ic).Run(c)
    75  }
    76  
    77  func (c connection) EndIntercept(name string) error {
    78  	s := daemon.GetSession(c)
    79  	_, err := s.RemoveIntercept(c, &manager.RemoveInterceptRequest2{
    80  		Session: s.Info.SessionInfo,
    81  		Name:    name,
    82  	})
    83  	return err
    84  }
    85  
    86  func toDaemonSnw(sns []api.SubnetViaWorkload) []*daemon2.SubnetViaWorkload {
    87  	if len(sns) == 0 {
    88  		return nil
    89  	}
    90  	dsn := make([]*daemon2.SubnetViaWorkload, len(sns))
    91  	for i, sn := range sns {
    92  		dsn[i] = &daemon2.SubnetViaWorkload{
    93  			Subnet:   sn.Subnet,
    94  			Workload: sn.Workload,
    95  		}
    96  	}
    97  	return dsn
    98  }
    99  
   100  func toDaemonRequest(cr *api.ConnectRequest) *daemon.Request {
   101  	var use *regexp.Regexp
   102  	if n := cr.Name; n != "" {
   103  		use = regexp.MustCompile(`\A` + n + `\z`)
   104  	}
   105  	return &daemon.Request{
   106  		ConnectRequest: connector.ConnectRequest{
   107  			KubeFlags:               cr.KubeFlags,
   108  			KubeconfigData:          cr.KubeConfigData,
   109  			Name:                    cr.Name,
   110  			MappedNamespaces:        cr.MappedNamespaces,
   111  			ManagerNamespace:        cr.ManagerNamespace,
   112  			AlsoProxy:               toStrings(cr.AlsoProxy),
   113  			NeverProxy:              toStrings(cr.NeverProxy),
   114  			AllowConflictingSubnets: toStrings(cr.AllowConflictingSubnets),
   115  			SubnetViaWorkloads:      toDaemonSnw(cr.SubnetViaWorkloads),
   116  		},
   117  		Docker:                  cr.Docker,
   118  		ExposedPorts:            cr.ExposedPorts,
   119  		Hostname:                cr.Hostname,
   120  		UserDaemonProfilingPort: cr.UserDaemonProfilingPort,
   121  		RootDaemonProfilingPort: cr.RootDaemonProfilingPort,
   122  		Use:                     use,
   123  	}
   124  }
   125  
   126  func toStrings[T fmt.Stringer](stringers []T) (ss []string) {
   127  	if ln := len(stringers); ln > 0 {
   128  		ss = make([]string, ln)
   129  		for i, s := range stringers {
   130  			ss[i] = s.String()
   131  		}
   132  	}
   133  	return
   134  }