github.com/abayer/test-infra@v0.0.5/mungegithub/mungers/mungers.go (about)

     1  /*
     2  Copyright 2015 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package mungers
    18  
    19  import (
    20  	"fmt"
    21  
    22  	"k8s.io/apimachinery/pkg/util/sets"
    23  	"k8s.io/test-infra/mungegithub/features"
    24  	"k8s.io/test-infra/mungegithub/github"
    25  	"k8s.io/test-infra/mungegithub/options"
    26  
    27  	"github.com/golang/glog"
    28  )
    29  
    30  // Munger is the interface which all mungers must implement to register
    31  type Munger interface {
    32  	// Take action on a specific github issue:
    33  	Munge(obj *github.MungeObject)
    34  	RegisterOptions(opts *options.Options) sets.String
    35  	Name() string
    36  	RequiredFeatures() []string
    37  	Initialize(*github.Config, *features.Features) error
    38  	EachLoop() error
    39  }
    40  
    41  var mungerMap = map[string]Munger{}
    42  var mungers = []Munger{}
    43  
    44  // GetAllMungers returns a slice of all registered mungers. This list is
    45  // completely independent of the mungers selected at runtime in --pr-mungers.
    46  // This is all possible mungers.
    47  func GetAllMungers() []Munger {
    48  	out := []Munger{}
    49  	for _, munger := range mungerMap {
    50  		out = append(out, munger)
    51  	}
    52  	return out
    53  }
    54  
    55  // GetActiveMungers returns a slice of all mungers which both registered and
    56  // were requested by the user
    57  func GetActiveMungers() []Munger {
    58  	return mungers
    59  }
    60  
    61  // RequestedFeatures returns a list of all feature which should be enabled
    62  // for the running mungers
    63  func RequestedFeatures() []string {
    64  	out := sets.NewString()
    65  	for _, m := range GetActiveMungers() {
    66  		f := m.RequiredFeatures()
    67  		out.Insert(f...)
    68  	}
    69  	return out.List()
    70  }
    71  
    72  // RegisterMungers will check if a requested munger exists and add it to
    73  // the list.
    74  func RegisterMungers(requestedMungers []string) error {
    75  	for _, name := range requestedMungers {
    76  		munger, found := mungerMap[name]
    77  		if !found {
    78  			return fmt.Errorf("couldn't find a munger named: %s", name)
    79  		}
    80  		mungers = append(mungers, munger)
    81  	}
    82  	return nil
    83  }
    84  
    85  // InitializeMungers will call munger.Initialize() for the requested mungers.
    86  func InitializeMungers(config *github.Config, features *features.Features) error {
    87  	for _, munger := range mungers {
    88  		if err := munger.Initialize(config, features); err != nil {
    89  			return fmt.Errorf("could not initialize %s: %v", munger.Name(), err)
    90  		}
    91  		glog.Infof("Initialized munger: %s", munger.Name())
    92  	}
    93  	return nil
    94  }
    95  
    96  // EachLoop will be called before we start a poll loop and will run the
    97  // EachLoop function for all active mungers
    98  func EachLoop() error {
    99  	for _, munger := range mungers {
   100  		if err := munger.EachLoop(); err != nil {
   101  			return err
   102  		}
   103  	}
   104  	return nil
   105  }
   106  
   107  // RegisterMunger should be called in `init()` by each munger to make itself
   108  // available by name
   109  func RegisterMunger(munger Munger) error {
   110  	if _, found := mungerMap[munger.Name()]; found {
   111  		return fmt.Errorf("a munger with that name (%s) already exists", munger.Name())
   112  	}
   113  	mungerMap[munger.Name()] = munger
   114  	glog.Infof("Registered %#v at %s", munger, munger.Name())
   115  	return nil
   116  }
   117  
   118  // RegisterMungerOrDie will call RegisterMunger but will be fatal on error
   119  func RegisterMungerOrDie(munger Munger) {
   120  	if err := RegisterMunger(munger); err != nil {
   121  		glog.Fatalf("Failed to register munger: %s", err)
   122  	}
   123  }
   124  
   125  // MungeIssue will call each activated munger with the given object
   126  func MungeIssue(obj *github.MungeObject) error {
   127  	for _, munger := range mungers {
   128  		munger.Munge(obj)
   129  	}
   130  	return nil
   131  }
   132  
   133  func RegisterOptions(opts *options.Options) sets.String {
   134  	immutables := sets.NewString()
   135  	for _, munger := range mungerMap {
   136  		immutables = immutables.Union(munger.RegisterOptions(opts))
   137  	}
   138  	return immutables
   139  }