-
Notifications
You must be signed in to change notification settings - Fork 1
/
broker_controller.go
151 lines (130 loc) · 4.47 KB
/
broker_controller.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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/*
Copyright 2023 KhulnaSoft, Inc.
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 controllers
import (
"context"
"github.com/go-logr/logr"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
meshplayv1alpha1 "github.com/khulnasoft/meshplay/meshplay-operator/api/v1alpha1"
brokerpackage "github.com/khulnasoft/meshplay/meshplay-operator/pkg/broker"
"github.com/khulnasoft/meshplay/meshplay-operator/pkg/utils"
kubeerror "k8s.io/apimachinery/pkg/api/errors"
types "k8s.io/apimachinery/pkg/types"
)
// BrokerReconciler reconciles a Broker object
type BrokerReconciler struct {
client.Client
KubeConfig *rest.Config
Clientset *kubernetes.Clientset
Log logr.Logger
Scheme *runtime.Scheme
}
// +kubebuilder:rbac:groups=meshplay.khulnasoft.com,resources=brokers,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=meshplay.khulnasoft.com,resources=brokers/status,verbs=get;update;patch
func (r *BrokerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
log := r.Log
log = log.WithValues("controller", "Broker")
log = log.WithValues("namespace", req.NamespacedName)
log.Info("Reconciling broker")
baseResource := &meshplayv1alpha1.Broker{}
// Check if resource exists
err := r.Get(ctx, req.NamespacedName, baseResource)
if err != nil {
if kubeerror.IsNotFound(err) {
baseResource.Name = req.Name
baseResource.Namespace = req.Namespace
return r.reconcileBroker(ctx, false, baseResource, req)
}
return ctrl.Result{}, err
}
// Check if Broker controller deployed
result, err := r.reconcileBroker(ctx, true, baseResource, req)
if err != nil {
return ctrl.Result{}, ErrReconcileBroker(err)
}
// Check if Broker controller started
err = brokerpackage.CheckHealth(ctx, baseResource, r.Clientset)
if err != nil {
return ctrl.Result{Requeue: true}, ErrCheckHealth(err)
}
// Get broker endpoint
err = brokerpackage.GetEndpoint(ctx, baseResource, r.Clientset, r.KubeConfig.Host)
if err != nil {
return ctrl.Result{}, ErrGetEndpoint(err)
}
// Patch the broker resource
patch, err := utils.Marshal(baseResource)
if err != nil {
return ctrl.Result{}, ErrUpdateResource(err)
}
err = r.Status().Patch(ctx, baseResource, client.RawPatch(types.MergePatchType, []byte(patch)))
if err != nil {
return ctrl.Result{}, ErrUpdateResource(err)
}
return result, nil
}
func (r *BrokerReconciler) SetupWithManager(mgr ctrl.Manager) error {
return ctrl.NewControllerManagedBy(mgr).
For(&meshplayv1alpha1.Broker{}).
Complete(r)
}
func (r *BrokerReconciler) Cleanup() error {
objects := brokerpackage.GetObjects(&meshplayv1alpha1.Broker{
ObjectMeta: v1.ObjectMeta{
Name: "meshplay-broker",
Namespace: "meshplay",
},
})
for _, object := range objects {
err := r.Delete(context.TODO(), object)
if err != nil {
return ErrDeleteMeshsync(err)
}
}
return nil
}
func (r *BrokerReconciler) reconcileBroker(ctx context.Context, enable bool, baseResource *meshplayv1alpha1.Broker, req ctrl.Request) (ctrl.Result, error) {
objects := brokerpackage.GetObjects(baseResource)
for _, object := range objects {
object.SetNamespace(baseResource.Namespace)
err := r.Get(ctx,
types.NamespacedName{
Name: object.GetName(),
Namespace: object.GetNamespace(),
},
object,
)
if err != nil && kubeerror.IsNotFound(err) && enable {
_ = ctrl.SetControllerReference(baseResource, object, r.Scheme)
er := r.Create(ctx, object)
if er != nil {
return ctrl.Result{}, ErrCreateMeshsync(er)
}
return ctrl.Result{Requeue: true}, nil
} else if err != nil && enable {
return ctrl.Result{}, ErrGetMeshsync(err)
} else if err == nil && !kubeerror.IsNotFound(err) && !enable {
er := r.Delete(ctx, object)
if er != nil {
return ctrl.Result{}, ErrDeleteMeshsync(er)
}
return ctrl.Result{Requeue: true}, nil
}
}
return ctrl.Result{}, nil
}