github.com/aporeto-inc/trireme-lib@v10.358.0+incompatible/monitor/internal/kubernetes/monitor.go (about)

     1  // +build !windows
     2  
     3  package kubernetesmonitor
     4  
     5  import (
     6  	"context"
     7  	"fmt"
     8  
     9  	"go.aporeto.io/trireme-lib/collector"
    10  	"go.aporeto.io/trireme-lib/monitor/config"
    11  	"go.aporeto.io/trireme-lib/monitor/extractors"
    12  	dockermonitor "go.aporeto.io/trireme-lib/monitor/internal/docker"
    13  	"go.aporeto.io/trireme-lib/monitor/registerer"
    14  	"go.uber.org/zap"
    15  	"k8s.io/client-go/kubernetes"
    16  	kubecache "k8s.io/client-go/tools/cache"
    17  )
    18  
    19  // KubernetesMonitor implements a monitor that sends pod events upstream
    20  // It is implemented as a filter on the standard DockerMonitor.
    21  // It gets all the PU events from the DockerMonitor and if the container is the POD container from Kubernetes,
    22  // It connects to the Kubernetes API and adds the tags that are coming from Kuberntes that cannot be found
    23  type KubernetesMonitor struct {
    24  	dockerMonitor       *dockermonitor.DockerMonitor
    25  	kubeClient          kubernetes.Interface
    26  	localNode           string
    27  	handlers            *config.ProcessorConfig
    28  	cache               *cache
    29  	kubernetesExtractor extractors.KubernetesMetadataExtractorType
    30  
    31  	podStore          kubecache.Store
    32  	podController     kubecache.Controller
    33  	podControllerStop chan struct{}
    34  
    35  	enableHostPods bool
    36  }
    37  
    38  // New returns a new kubernetes monitor.
    39  func New() *KubernetesMonitor {
    40  	kubeMonitor := &KubernetesMonitor{}
    41  	kubeMonitor.cache = newCache()
    42  
    43  	return kubeMonitor
    44  }
    45  
    46  // SetupConfig provides a configuration to implmentations. Every implmentation
    47  // can have its own config type.
    48  func (m *KubernetesMonitor) SetupConfig(registerer registerer.Registerer, cfg interface{}) error {
    49  
    50  	defaultConfig := DefaultConfig()
    51  
    52  	if cfg == nil {
    53  		cfg = defaultConfig
    54  	}
    55  
    56  	kubernetesconfig, ok := cfg.(*Config)
    57  	if !ok {
    58  		return fmt.Errorf("Invalid configuration specified")
    59  	}
    60  
    61  	kubernetesconfig = SetupDefaultConfig(kubernetesconfig)
    62  
    63  	processorConfig := &config.ProcessorConfig{
    64  		Policy:    m,
    65  		Collector: collector.NewDefaultCollector(),
    66  	}
    67  
    68  	// As the Kubernetes monitor depends on the DockerMonitor, we setup the Docker monitor first
    69  	dockerMon := dockermonitor.New()
    70  	dockerMon.SetupHandlers(processorConfig)
    71  
    72  	dockerConfig := dockermonitor.DefaultConfig()
    73  	dockerConfig.EventMetadataExtractor = kubernetesconfig.DockerExtractor
    74  
    75  	// we use the defaultconfig for now
    76  	if err := dockerMon.SetupConfig(nil, dockerConfig); err != nil {
    77  		return fmt.Errorf("docker monitor instantiation error: %s", err.Error())
    78  	}
    79  
    80  	m.dockerMonitor = dockerMon
    81  
    82  	// Setting up Kubernetes
    83  	m.localNode = kubernetesconfig.Nodename
    84  	kubeClient, err := NewKubeClient(kubernetesconfig.Kubeconfig)
    85  	if err != nil {
    86  		return fmt.Errorf("kubernetes client instantiation error: %s", err.Error())
    87  	}
    88  	m.kubeClient = kubeClient
    89  
    90  	m.enableHostPods = kubernetesconfig.EnableHostPods
    91  	m.kubernetesExtractor = kubernetesconfig.KubernetesExtractor
    92  
    93  	m.podStore, m.podController = m.CreateLocalPodController("",
    94  		m.addPod,
    95  		m.deletePod,
    96  		m.updatePod)
    97  
    98  	m.podControllerStop = make(chan struct{})
    99  
   100  	zap.L().Warn("Using deprecated Kubernetes Monitor")
   101  
   102  	return nil
   103  }
   104  
   105  // Run starts the monitor.
   106  func (m *KubernetesMonitor) Run(ctx context.Context) error {
   107  	if m.kubeClient == nil {
   108  		return fmt.Errorf("kubernetes client is not initialized correctly")
   109  	}
   110  
   111  	// TODO. Give directly the channel to the Kubernetes library
   112  	go m.podController.Run(ctx.Done())
   113  	initialPodSync := make(chan struct{})
   114  	go hasSynced(initialPodSync, m.podController)
   115  	<-initialPodSync
   116  
   117  	return m.dockerMonitor.Run(ctx)
   118  }
   119  
   120  // SetupHandlers sets up handlers for monitors to invoke for various events such as
   121  // processing unit events and synchronization events. This will be called before Start()
   122  // by the consumer of the monitor
   123  func (m *KubernetesMonitor) SetupHandlers(c *config.ProcessorConfig) {
   124  	m.handlers = c
   125  }
   126  
   127  // Resync requests to the monitor to do a resync.
   128  func (m *KubernetesMonitor) Resync(ctx context.Context) error {
   129  	return m.dockerMonitor.Resync(ctx)
   130  }