-
Notifications
You must be signed in to change notification settings - Fork 87
/
controller.go
89 lines (68 loc) · 2.81 KB
/
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
/*
Copyright 2023 The Radius 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 controller
import (
"context"
"github.com/radius-project/radius/pkg/corerp/backend/deployment"
"github.com/radius-project/radius/pkg/ucp/dataprovider"
"github.com/radius-project/radius/pkg/ucp/store"
runtimeclient "sigs.k8s.io/controller-runtime/pkg/client"
)
// Options represents controller options.
type Options struct {
// StorageClient is the data storage client.
StorageClient store.StorageClient
// DataProvider is the data storage provider.
DataProvider dataprovider.DataStorageProvider
// KubeClient is the Kubernetes controller runtime client.
KubeClient runtimeclient.Client
// ResourceType is the string that represents the resource type.
ResourceType string
// GetDeploymentProcessor is the factory function to create core rp DeploymentProcessor instance.
GetDeploymentProcessor func() deployment.DeploymentProcessor
}
// Controller is an interface to implement async operation controller.
type Controller interface {
// Run runs async request operation.
Run(ctx context.Context, request *Request) (Result, error)
// StorageClient gets the storage client for resource type.
StorageClient() store.StorageClient
}
// BaseController is the base struct of async operation controller.
type BaseController struct {
options Options
}
// NewBaseAsyncController creates a new BaseController instance with the given Options for Async Operation.
func NewBaseAsyncController(options Options) BaseController {
return BaseController{options}
}
// StorageClient gets storage client for this controller.
func (b *BaseController) StorageClient() store.StorageClient {
return b.options.StorageClient
}
// DataProvider gets data storage provider for this controller.
func (b *BaseController) DataProvider() dataprovider.DataStorageProvider {
return b.options.DataProvider
}
// KubeClient gets Kubernetes client for this controller.
func (b *BaseController) KubeClient() runtimeclient.Client {
return b.options.KubeClient
}
// ResourceType gets the resource type for this controller.
func (b *BaseController) ResourceType() string {
return b.options.ResourceType
}
// DeploymentProcessor gets the core rp deployment processor for this controller.
func (b *BaseController) DeploymentProcessor() deployment.DeploymentProcessor {
return b.options.GetDeploymentProcessor()
}