forked from operator-framework/operator-sdk
-
Notifications
You must be signed in to change notification settings - Fork 0
/
main_entry.go
127 lines (121 loc) · 4.49 KB
/
main_entry.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
// Copyright 2018 The Operator-SDK Authors
//
// 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
//
// http://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 test
import (
"bytes"
"flag"
"fmt"
"io/ioutil"
"os"
"os/exec"
"os/signal"
"path/filepath"
"syscall"
"testing"
"k8s.io/client-go/tools/clientcmd"
"github.com/operator-framework/operator-sdk/pkg/k8sutil"
"github.com/operator-framework/operator-sdk/pkg/scaffold"
log "github.com/sirupsen/logrus"
)
const (
ProjRootFlag = "root"
KubeConfigFlag = "kubeconfig"
NamespacedManPathFlag = "namespacedMan"
GlobalManPathFlag = "globalMan"
SingleNamespaceFlag = "singleNamespace"
TestNamespaceEnv = "TEST_NAMESPACE"
LocalOperatorFlag = "localOperator"
)
func MainEntry(m *testing.M) {
projRoot := flag.String(ProjRootFlag, "", "path to project root")
kubeconfigPath := flag.String(KubeConfigFlag, "", "path to kubeconfig")
globalManPath := flag.String(GlobalManPathFlag, "", "path to operator manifest")
namespacedManPath := flag.String(NamespacedManPathFlag, "", "path to rbac manifest")
singleNamespace = flag.Bool(SingleNamespaceFlag, false, "enable single namespace mode")
localOperator := flag.Bool(LocalOperatorFlag, false, "enable if operator is running locally (not in cluster)")
flag.Parse()
// go test always runs from the test directory; change to project root
err := os.Chdir(*projRoot)
if err != nil {
log.Fatalf("failed to change directory to project root: %v", err)
}
if err := setup(kubeconfigPath, namespacedManPath, *localOperator); err != nil {
log.Fatalf("failed to set up framework: %v", err)
}
// setup local operator command, but don't start it yet
var localCmd *exec.Cmd
var localCmdOutBuf, localCmdErrBuf bytes.Buffer
if *localOperator {
// TODO: make a generic 'up-local' function to deduplicate shared code between this and cmd/up/local
// taken from commands/operator-sdk/cmd/up/local.go
runArgs := append([]string{"run"}, []string{filepath.Join(scaffold.ManagerDir, scaffold.CmdFile)}...)
localCmd = exec.Command("go", runArgs...)
localCmd.Stdout = &localCmdOutBuf
localCmd.Stderr = &localCmdErrBuf
c := make(chan os.Signal)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
go func() {
<-c
err := localCmd.Process.Signal(os.Interrupt)
if err != nil {
log.Fatalf("failed to terminate the operator: (%v)", err)
}
os.Exit(0)
}()
if *kubeconfigPath != "" {
localCmd.Env = append(os.Environ(), fmt.Sprintf("%v=%v", k8sutil.KubeConfigEnvVar, *kubeconfigPath))
} else {
// we can hardcode index 0 as that is the highest priority kubeconfig to be loaded and will always
// be populated by NewDefaultClientConfigLoadingRules()
localCmd.Env = append(os.Environ(), fmt.Sprintf("%v=%v", k8sutil.KubeConfigEnvVar, clientcmd.NewDefaultClientConfigLoadingRules().Precedence[0]))
}
localCmd.Env = append(localCmd.Env, fmt.Sprintf("%v=%v", k8sutil.WatchNamespaceEnvVar, Global.Namespace))
}
// setup context to use when setting up crd
ctx := NewTestCtx(nil)
// os.Exit stops the program before the deferred functions run
// to fix this, we put the exit in the defer as well
defer func() {
// start local operator before running tests
if *localOperator {
err := localCmd.Start()
if err != nil {
log.Fatalf("failed to run operator locally: (%v)", err)
}
log.Info("started local operator")
}
exitCode := m.Run()
if *localOperator {
err := localCmd.Process.Kill()
if err != nil {
log.Warn("failed to stop local operator process")
}
log.Infof("local operator stdout: %s", string(localCmdOutBuf.Bytes()))
log.Infof("local operator stderr: %s", string(localCmdErrBuf.Bytes()))
}
ctx.CleanupNoT()
os.Exit(exitCode)
}()
// create crd
if *kubeconfigPath != "incluster" {
globalYAML, err := ioutil.ReadFile(*globalManPath)
if err != nil {
log.Fatalf("failed to read global resource manifest: %v", err)
}
err = ctx.createFromYAML(globalYAML, true, &CleanupOptions{TestContext: ctx})
if err != nil {
log.Fatalf("failed to create resource(s) in global resource manifest: %v", err)
}
}
}