258b81122e
This executor based on kyaml.RunFns[1]. It allows to execute arbitrary container as RunFns function and handle any input data as ExecutorBundle. Be aware that runtimeutils.FunctionSpec used for version 0.4.1[2] and it can be changed in the future. It means that yaml scheme of executor can be changed during kyaml uplift. This executor transforms executor yaml to RunFns function acceptable format. [1] https://github.com/kubernetes-sigs/kustomize/blob/master/kyaml/runfn/runfn.go [2] https://github.com/kubernetes-sigs/kustomize/blob/kyaml/v0.4.1/kyaml/fn/runtime/runtimeutil/functiontypes.go#L22 Change-Id: I9eb648783f1ed462d2b8359d9dc86320c4db2a83 Closes: #202 Closes: #369
101 lines
3.1 KiB
Go
101 lines
3.1 KiB
Go
/*
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
https://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package events
|
|
|
|
import (
|
|
"k8s.io/cli-runtime/pkg/genericclioptions"
|
|
"sigs.k8s.io/cli-utils/cmd/printers"
|
|
"sigs.k8s.io/cli-utils/pkg/common"
|
|
|
|
applyevent "sigs.k8s.io/cli-utils/pkg/apply/event"
|
|
|
|
"opendev.org/airship/airshipctl/pkg/log"
|
|
)
|
|
|
|
// EventProcessor use to process event channels produced by executors
|
|
type EventProcessor interface {
|
|
Process(<-chan Event) error
|
|
Close()
|
|
}
|
|
|
|
// DefaultProcessor is implementation of EventProcessor
|
|
type DefaultProcessor struct {
|
|
errors []error
|
|
applierChan chan<- applyevent.Event
|
|
}
|
|
|
|
// NewDefaultProcessor returns instance of DefaultProcessor as interface Implementation
|
|
func NewDefaultProcessor(streams genericclioptions.IOStreams) EventProcessor {
|
|
applyCh := make(chan applyevent.Event)
|
|
go printers.GetPrinter(printers.EventsPrinter, streams).Print(applyCh, common.DryRunNone)
|
|
return &DefaultProcessor{
|
|
errors: []error{},
|
|
applierChan: applyCh,
|
|
}
|
|
}
|
|
|
|
// Process is implementation of EventProcessor
|
|
func (p *DefaultProcessor) Process(ch <-chan Event) error {
|
|
for e := range ch {
|
|
switch e.Type {
|
|
case ApplierType:
|
|
p.processApplierEvent(e.ApplierEvent)
|
|
case ErrorType:
|
|
log.Printf("Received error on event channel %v", e.ErrorEvent)
|
|
p.errors = append(p.errors, e.ErrorEvent.Error)
|
|
case ClusterctlType, IsogenType, GenericContainerType:
|
|
// TODO each event needs to be interface that allows us to print it for example
|
|
// Stringer interface or AsYAML for further processing.
|
|
// For now we print the event object as is
|
|
log.Printf("Received event: %v", e)
|
|
case BootstrapType:
|
|
log.Printf("%s", e.BootstrapEvent.Message)
|
|
case StatusPollerType:
|
|
log.Fatalf("Processing for status poller events are not yet implemented")
|
|
case WaitType:
|
|
log.Fatalf("Processing for wait events are not yet implemented")
|
|
default:
|
|
log.Fatalf("Unknown event type received: %d", e.Type)
|
|
}
|
|
}
|
|
return checkErrors(p.errors)
|
|
}
|
|
|
|
// Close cleans up the auxiliary channels used to process events
|
|
func (p *DefaultProcessor) Close() {
|
|
close(p.applierChan)
|
|
}
|
|
|
|
func (p *DefaultProcessor) processApplierEvent(e applyevent.Event) {
|
|
if e.Type == applyevent.ErrorType {
|
|
log.Printf("Received error when applying errors to kubernetes %v", e.ErrorEvent.Err)
|
|
p.errors = append(p.errors, e.ErrorEvent.Err)
|
|
// Don't write errors events to applier channel, as it will use os.Exit to stop program execution
|
|
return
|
|
}
|
|
p.applierChan <- e
|
|
}
|
|
|
|
// Check list of errors, and verify that these errors we are able to tolerate
|
|
// currently we simply check if the list is empty or not
|
|
func checkErrors(errs []error) error {
|
|
if len(errs) != 0 {
|
|
return ErrEventReceived{
|
|
Errors: errs,
|
|
}
|
|
}
|
|
return nil
|
|
}
|