/
manager.go
118 lines (97 loc) · 3.88 KB
/
manager.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
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"). You may
// not use this file except in compliance with the License. A copy of the
// License is located at
//
// http://aws.amazon.com/apache2.0/
//
// or in the "license" file accompanying this file. This file 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 resource
import (
"context"
"fmt"
"github.com/aws/amazon-vpc-resource-controller-k8s/pkg/api"
"github.com/aws/amazon-vpc-resource-controller-k8s/pkg/config"
"github.com/aws/amazon-vpc-resource-controller-k8s/pkg/handler"
"github.com/aws/amazon-vpc-resource-controller-k8s/pkg/provider"
"github.com/aws/amazon-vpc-resource-controller-k8s/pkg/provider/branch"
"github.com/aws/amazon-vpc-resource-controller-k8s/pkg/provider/ip"
"github.com/aws/amazon-vpc-resource-controller-k8s/pkg/worker"
ctrl "sigs.k8s.io/controller-runtime"
)
type Manager struct {
resource map[string]Resource
}
type Resource struct {
handler.Handler
provider.ResourceProvider
}
type ResourceManager interface {
GetResourceProviders() map[string]provider.ResourceProvider
GetResourceHandler(resourceName string) (handler.Handler, bool)
}
func NewResourceManager(ctx context.Context, resourceNames []string, wrapper api.Wrapper) (ResourceManager, error) {
// Load that static configuration of the resource
resourceConfig := config.LoadResourceConfig()
resources := make(map[string]Resource)
// For each supported resource, initialize the resource provider and handler
for _, resourceName := range resourceNames {
resourceConfig, ok := resourceConfig[resourceName]
if !ok {
return nil, fmt.Errorf("failed to find resource configuration %s", resourceName)
}
ctrl.Log.Info("initializing resource", "resource name",
resourceName, "resource count", resourceConfig.WorkerCount)
workers := worker.NewDefaultWorkerPool(
resourceConfig.Name,
resourceConfig.WorkerCount,
config.WorkQueueDefaultMaxRetries,
ctrl.Log.WithName(fmt.Sprintf("%s-%s", resourceName, "worker")), ctx)
var resourceHandler handler.Handler
var resourceProvider provider.ResourceProvider
if resourceName == config.ResourceNameIPAddress {
resourceProvider = ip.NewIPv4Provider(ctrl.Log.WithName("ipv4 provider"),
wrapper, workers, resourceConfig)
resourceHandler = handler.NewWarmResourceHandler(ctrl.Log.WithName(resourceName), wrapper,
resourceName, resourceProvider, ctx)
} else if resourceName == config.ResourceNamePodENI {
resourceProvider = branch.NewBranchENIProvider(ctrl.Log.WithName("branch eni provider"),
wrapper, workers, resourceConfig, ctx)
resourceHandler = handler.NewOnDemandHandler(ctrl.Log.WithName(resourceName),
resourceName, resourceProvider)
} else {
return nil, fmt.Errorf("resource type is not defnied %s", resourceName)
}
err := workers.StartWorkerPool(resourceProvider.ProcessAsyncJob)
if err != nil {
return nil, fmt.Errorf("unable to start the workers for resource %s", resourceName)
}
resources[resourceName] = Resource{
Handler: resourceHandler,
ResourceProvider: resourceProvider,
}
ctrl.Log.Info("successfully initialized resource handler and provider",
"resource name", resourceName)
}
return &Manager{
resource: resources,
}, nil
}
func (m *Manager) GetResourceProviders() map[string]provider.ResourceProvider {
providers := make(map[string]provider.ResourceProvider)
for resourceName, provider := range m.resource {
providers[resourceName] = provider
}
return providers
}
func (m *Manager) GetResourceHandler(resourceName string) (handler.Handler, bool) {
resource, found := m.resource[resourceName]
if !found {
return nil, found
}
return resource.Handler, found
}