/
schedule.go
136 lines (126 loc) · 5.2 KB
/
schedule.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
128
129
130
131
132
133
134
135
136
package cmds
import (
"io/ioutil"
"os"
"strings"
"time"
"github.com/appscode/go/log"
"github.com/appscode/kutil"
cs "github.com/appscode/stash/client/typed/stash/v1alpha1"
"github.com/appscode/stash/pkg/scheduler"
"github.com/spf13/cobra"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/tools/clientcmd"
)
func NewCmdSchedule() *cobra.Command {
var (
masterURL string
kubeconfigPath string
workload string
opt scheduler.Options = scheduler.Options{
Namespace: kutil.Namespace(),
ResticName: "",
ScratchDir: "/tmp",
PushgatewayURL: "http://stash-operator.kube-system.svc:56789",
PodLabelsPath: "/etc/stash/labels",
ResyncPeriod: 5 * time.Minute,
MaxNumRequeues: 5,
}
)
cmd := &cobra.Command{
Use: "schedule",
Short: "Run Stash cron daemon",
DisableAutoGenTag: true,
Run: func(cmd *cobra.Command, args []string) {
config, err := clientcmd.BuildConfigFromFlags(masterURL, kubeconfigPath)
if err != nil {
log.Fatalf("Could not get Kubernetes config: %s", err)
}
kubeClient = kubernetes.NewForConfigOrDie(config)
stashClient = cs.NewForConfigOrDie(config)
opt.NodeName = os.Getenv("NODE_NAME")
if opt.NodeName == "" {
log.Fatalln(`Missing ENV var "NODE_NAME"`)
}
opt.PodName = os.Getenv("POD_NAME")
if opt.PodName == "" {
log.Fatalln(`Missing ENV var "POD_NAME"`)
}
app := strings.SplitN(workload, "/", 2)
if len(app) != 2 {
log.Fatalf(`--workload flag must be in the format "Kind/Name", but found %v`, workload)
}
opt.AppName = app[1]
switch app[0] {
case "Deployments", "Deployment", "deployments", "deployment":
opt.AppKind = "Deployment"
opt.SmartPrefix = ""
_, err := kubeClient.AppsV1beta1().Deployments(opt.Namespace).Get(opt.AppName, metav1.GetOptions{})
if err != nil {
_, err := kubeClient.ExtensionsV1beta1().Deployments(opt.Namespace).Get(opt.AppName, metav1.GetOptions{})
if err != nil {
log.Fatalf(`Unknown Deployment %s/%s`, opt.Namespace, opt.AppName)
}
}
case "ReplicaSets", "ReplicaSet", "replicasets", "replicaset", "rs":
opt.AppKind = "ReplicaSet"
opt.SmartPrefix = ""
_, err := kubeClient.ExtensionsV1beta1().ReplicaSets(opt.Namespace).Get(opt.AppName, metav1.GetOptions{})
if err != nil {
log.Fatalf(`Unknown ReplicaSet %s/%s`, opt.Namespace, opt.AppName)
}
case "ReplicationControllers", "ReplicationController", "replicationcontrollers", "replicationcontroller", "rc":
opt.AppKind = "ReplicationController"
opt.SmartPrefix = ""
_, err := kubeClient.CoreV1().ReplicationControllers(opt.Namespace).Get(opt.AppName, metav1.GetOptions{})
if err != nil {
log.Fatalf(`Unknown ReplicationController %s/%s`, opt.Namespace, opt.AppName)
}
case "StatefulSets", "StatefulSet":
opt.AppKind = "StatefulSet"
opt.SmartPrefix = opt.PodName
_, err := kubeClient.AppsV1beta1().StatefulSets(opt.Namespace).Get(opt.AppName, metav1.GetOptions{})
if err != nil {
log.Fatalf(`Unknown StatefulSet %s/%s`, opt.Namespace, opt.AppName)
}
case "DaemonSets", "DaemonSet", "daemonsets", "daemonset":
opt.AppKind = "DaemonSet"
opt.SmartPrefix = opt.NodeName
_, err := kubeClient.ExtensionsV1beta1().DaemonSets(opt.Namespace).Get(opt.AppName, metav1.GetOptions{})
if err != nil {
log.Fatalf(`Unknown DaemonSet %s/%s`, opt.Namespace, opt.AppName)
}
default:
log.Fatalf(`Unrecognized workload "Kind" %v`, opt.AppKind)
}
opt.ScratchDir = strings.TrimSuffix(opt.ScratchDir, "/")
err = os.MkdirAll(opt.ScratchDir, 0755)
if err != nil {
log.Fatalf("Failed to create scratch dir: %s", err)
}
err = ioutil.WriteFile(opt.ScratchDir+"/.stash", []byte("test"), 644)
if err != nil {
log.Fatalf("No write access in scratch dir: %s", err)
}
ctrl := scheduler.New(kubeClient, stashClient, opt)
err = ctrl.Setup()
if err != nil {
log.Fatalf("Failed to setup scheduler: %s", err)
}
stop := make(chan struct{})
defer close(stop)
go ctrl.Run(1, stop)
// Wait forever
select {}
},
}
cmd.Flags().StringVar(&masterURL, "master", masterURL, "The address of the Kubernetes API server (overrides any value in kubeconfig)")
cmd.Flags().StringVar(&kubeconfigPath, "kubeconfig", kubeconfigPath, "Path to kubeconfig file with authorization information (the master location is set by the master flag).")
cmd.Flags().StringVar(&workload, "workload", workload, `"Kind/Name" of workload where sidecar pod is added (eg, Deployment/apiserver)`)
cmd.Flags().StringVar(&opt.ResticName, "restic-name", opt.ResticName, "Name of the Restic used as configuration.")
cmd.Flags().StringVar(&opt.ScratchDir, "scratch-dir", opt.ScratchDir, "Directory used to store temporary files. Use an `emptyDir` in Kubernetes.")
cmd.Flags().StringVar(&opt.PushgatewayURL, "pushgateway-url", opt.PushgatewayURL, "URL of Prometheus pushgateway used to cache backup metrics")
cmd.Flags().DurationVar(&opt.ResyncPeriod, "resync-period", opt.ResyncPeriod, "If non-zero, will re-list this often. Otherwise, re-list will be delayed aslong as possible (until the upstream source closes the watch or times out.")
return cmd
}