github.com/caos/orbos@v1.5.14-0.20221103111702-e6cd0cea7ad4/internal/operator/orbiter/kinds/providers/static/ensure.go (about)

     1  package static
     2  
     3  import (
     4  	"fmt"
     5  	"sync"
     6  
     7  	"github.com/caos/orbos/internal/helpers"
     8  	"github.com/caos/orbos/internal/operator/orbiter/kinds/loadbalancers/dynamic/wrap"
     9  	"github.com/caos/orbos/internal/operator/orbiter/kinds/providers/core"
    10  
    11  	"github.com/caos/orbos/internal/operator/common"
    12  	"github.com/caos/orbos/internal/operator/orbiter"
    13  	"github.com/caos/orbos/internal/operator/orbiter/kinds/clusters/core/infra"
    14  	dynamiclbmodel "github.com/caos/orbos/internal/operator/orbiter/kinds/loadbalancers/dynamic"
    15  	"github.com/caos/orbos/mntr"
    16  )
    17  
    18  func query(
    19  	desired *DesiredV0,
    20  	current *Current,
    21  
    22  	nodeAgentsDesired *common.DesiredNodeAgents,
    23  	nodeAgentsCurrent *common.CurrentNodeAgents,
    24  	lb interface{},
    25  
    26  	monitor mntr.Monitor,
    27  	internalMachinesService *machinesService,
    28  	naFuncs core.IterateNodeAgentFuncs,
    29  	orbiterCommit string,
    30  ) (ensureFunc orbiter.EnsureFunc, err error) {
    31  
    32  	// TODO: Allow Changes
    33  	desireHostnameFunc := desireHostname(desired.Spec.Pools, nodeAgentsDesired, nodeAgentsCurrent, monitor)
    34  
    35  	queryNA, installNA := naFuncs(nodeAgentsCurrent)
    36  
    37  	ensureNodeFunc := func(machine infra.Machine, pool string) error {
    38  
    39  		na, _ := nodeAgentsDesired.Get(machine.ID())
    40  		na.LeaveOSRepositories = desired.Spec.LeaveOSRepositories
    41  
    42  		running, err := queryNA(machine, orbiterCommit)
    43  		if err != nil {
    44  			return err
    45  		}
    46  		if !running {
    47  			if err := installNA(machine); err != nil {
    48  				return err
    49  			}
    50  		}
    51  		_, err = desireHostnameFunc(machine, pool)
    52  		return err
    53  	}
    54  	internalMachinesService.onCreate = ensureNodeFunc
    55  
    56  	var externalMachinesService core.MachinesService = internalMachinesService
    57  
    58  	pools, err := internalMachinesService.ListPools()
    59  	if err != nil {
    60  		return nil, err
    61  	}
    62  
    63  	current.Current.Ingresses = make(map[string]*infra.Address)
    64  	ensureLBFunc := func() *orbiter.EnsureResult {
    65  		return &orbiter.EnsureResult{
    66  			Err:  nil,
    67  			Done: true,
    68  		}
    69  	}
    70  	switch lbCurrent := lb.(type) {
    71  	case *dynamiclbmodel.Current:
    72  
    73  		mapVIP := func(vip *dynamiclbmodel.VIP) string {
    74  			return vip.IP
    75  		}
    76  
    77  		vipInterface := desired.Spec.PrivateInterface
    78  		if len(desired.Spec.ExternalInterfaces) > 0 {
    79  			vipInterface = desired.Spec.ExternalInterfaces[0]
    80  		}
    81  
    82  		wrappedMachinesService := wrap.MachinesService(internalMachinesService, *lbCurrent, &dynamiclbmodel.VRRP{
    83  			VRRPInterface: desired.Spec.PrivateInterface,
    84  			VIPInterface:  vipInterface,
    85  			NotifyMaster:  nil,
    86  			AuthCheck:     nil,
    87  		}, mapVIP)
    88  		externalMachinesService = wrappedMachinesService
    89  		ensureLBFunc = func() *orbiter.EnsureResult {
    90  			return orbiter.ToEnsureResult(wrappedMachinesService.InitializeDesiredNodeAgents())
    91  		}
    92  		deployPools, _, err := lbCurrent.Current.Spec(internalMachinesService)
    93  		if err != nil {
    94  			return nil, err
    95  		}
    96  		for _, pool := range deployPools {
    97  			for _, vip := range pool {
    98  				for _, src := range vip.Transport {
    99  					current.Current.Ingresses[src.Name] = &infra.Address{
   100  						Location:     vip.IP,
   101  						FrontendPort: uint16(src.FrontendPort),
   102  						BackendPort:  uint16(src.BackendPort),
   103  					}
   104  				}
   105  			}
   106  		}
   107  
   108  		//	case *externallbmodel.Current:
   109  		//		for name, address := range lbCurrent.Current.Addresses {
   110  		//			current.Current.Ingresses[name] = address
   111  		//		}
   112  	default:
   113  		return nil, fmt.Errorf("unknown or unsupported load balancing of type %T", lb)
   114  	}
   115  
   116  	return func(pdf func(mntr.Monitor) error) *orbiter.EnsureResult {
   117  		var wg sync.WaitGroup
   118  		for _, pool := range pools {
   119  			machines, listErr := internalMachinesService.List(pool)
   120  			if listErr != nil {
   121  				err = helpers.Concat(err, listErr)
   122  			}
   123  			for _, machine := range machines {
   124  				wg.Add(1)
   125  				go func(m infra.Machine, p string) {
   126  					err = helpers.Concat(err, ensureNodeFunc(m, p))
   127  					wg.Done()
   128  				}(machine, pool)
   129  			}
   130  		}
   131  
   132  		wg.Wait()
   133  		if err != nil {
   134  			return orbiter.ToEnsureResult(false, err)
   135  		}
   136  		result := ensureLBFunc()
   137  
   138  		if result.Err == nil {
   139  			fwDone, err := core.DesireInternalOSFirewall(monitor, nodeAgentsDesired, nodeAgentsCurrent, externalMachinesService, false, desired.Spec.ExternalInterfaces)
   140  			result.Err = err
   141  			result.Done = result.Done && fwDone
   142  		}
   143  
   144  		return result
   145  	}, addPools(current, desired, externalMachinesService)
   146  }