github.com/caos/orbos@v1.5.14-0.20221103111702-e6cd0cea7ad4/pkg/labels/operator.go (about)

     1  package labels
     2  
     3  import (
     4  	"errors"
     5  
     6  	"gopkg.in/yaml.v3"
     7  )
     8  
     9  var _ Labels = (*Operator)(nil)
    10  
    11  type Operator struct {
    12  	model InternalOperator
    13  }
    14  
    15  func NoopOperator(product string) *Operator {
    16  	return &Operator{model: InternalOperator{
    17  		Version:               "unknown",
    18  		InternalPartofProp:    InternalPartofProp{PartOf: product},
    19  		InternalManagedByProp: InternalManagedByProp{ManagedBy: "unknown.caos.ch"},
    20  		//		Major:                 "unknown",
    21  	}}
    22  }
    23  
    24  func SelectorOperator(product, operator string) *Operator {
    25  	return &Operator{model: InternalOperator{
    26  		Version:               "unknown",
    27  		InternalPartofProp:    InternalPartofProp{PartOf: product},
    28  		InternalManagedByProp: InternalManagedByProp{ManagedBy: operator},
    29  		//		Major:                 major(version),
    30  	}}
    31  }
    32  
    33  func ForOperator(product, operator, version string) (*Operator, error) {
    34  
    35  	if operator == "" || version == "" {
    36  		return nil, errors.New("operator or version must not be nil")
    37  	}
    38  
    39  	return &Operator{model: InternalOperator{
    40  		Version:               version,
    41  		InternalPartofProp:    InternalPartofProp{PartOf: product},
    42  		InternalManagedByProp: InternalManagedByProp{ManagedBy: operator},
    43  		//		Major:                 major(version),
    44  	}}, nil
    45  }
    46  
    47  func (l *Operator) UnmarshalYAML(node *yaml.Node) error {
    48  	return node.Decode(&l.model)
    49  }
    50  
    51  func MustForOperator(product, operator, version string) *Operator {
    52  	o, err := ForOperator(product, operator, version)
    53  	if err != nil {
    54  		panic(err)
    55  	}
    56  	return o
    57  }
    58  
    59  func (l *Operator) Equal(r comparable) bool {
    60  	if right, ok := r.(*Operator); ok {
    61  		return l.model == right.model
    62  	}
    63  	return false
    64  }
    65  
    66  func (l *Operator) MarshalYAML() (interface{}, error) {
    67  	return nil, errors.New("type *labels.Operator is not serializable")
    68  }
    69  
    70  /*
    71  func (l *Operator) Major() int8 {
    72  
    73  	var unknown int8 = -1
    74  
    75  	if l.model.Major == "unknown" {
    76  		return unknown
    77  	}
    78  
    79  	m, err := strconv.Atoi(strings.TrimPrefix(l.model.Major, "v"))
    80  	if err != nil {
    81  		return unknown
    82  	}
    83  
    84  	if m > math.MaxInt8 {
    85  		return unknown
    86  	}
    87  
    88  	return int8(m)
    89  }
    90  */
    91  
    92  type InternalPartofProp struct {
    93  	PartOf string `yaml:"app.kubernetes.io/part-of,omitempty"`
    94  }
    95  
    96  type InternalManagedByProp struct {
    97  	ManagedBy string `yaml:"app.kubernetes.io/managed-by,omitempty"`
    98  }
    99  
   100  type InternalOperator struct {
   101  	InternalManagedByProp `yaml:",inline"`
   102  	Version               string `yaml:"app.kubernetes.io/version"`
   103  	//	Major                 string `yaml:"caos.ch/major"`
   104  	InternalPartofProp `yaml:",inline"`
   105  }
   106  
   107  /*
   108  func major(version string) string {
   109  	versionRegex := regexp.MustCompile("^v([0-9]+)\\.[0-9]+\\.[0-9]+$")
   110  	matches := versionRegex.FindStringSubmatch(version)
   111  	unknown := "unknown"
   112  	if len(matches) != 2 {
   113  		return unknown
   114  	}
   115  
   116  	m, err := strconv.Atoi(matches[1])
   117  	if err != nil {
   118  		return unknown
   119  	}
   120  
   121  	if m > math.MaxInt8 {
   122  		return unknown
   123  	}
   124  
   125  	return fmt.Sprintf("v%d", m)
   126  }
   127  */