-
Notifications
You must be signed in to change notification settings - Fork 0
/
factory.go
120 lines (98 loc) · 3.61 KB
/
factory.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
package dialer
import (
"fmt"
"net"
"time"
"github.com/rancher/rancher/pkg/encryptedstore"
"github.com/rancher/rancher/pkg/nodeconfig"
"github.com/rancher/rancher/pkg/remotedialer"
"github.com/rancher/rancher/pkg/tunnelserver"
"github.com/rancher/types/apis/management.cattle.io/v3"
"github.com/rancher/types/config"
"github.com/rancher/types/config/dialer"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/tools/cache"
)
func NewFactory(apiContext *config.ScaledContext) (dialer.Factory, error) {
authorizer := tunnelserver.NewAuthorizer(apiContext)
tunneler := tunnelserver.NewTunnelServer(apiContext, authorizer)
secretStore, err := nodeconfig.NewStore(apiContext.Core.Namespaces(""), apiContext.K8sClient.CoreV1())
if err != nil {
return nil, err
}
apiContext.Management.Nodes("local").Controller().Informer().AddIndexers(cache.Indexers{
nodeAccessIndexer: nodeIndexer,
})
return &Factory{
clusterLister: apiContext.Management.Clusters("").Controller().Lister(),
localNodeController: apiContext.Management.Nodes("local").Controller(),
nodeLister: apiContext.Management.Nodes("").Controller().Lister(),
TunnelServer: tunneler,
TunnelAuthorizer: authorizer,
store: secretStore,
}, nil
}
type Factory struct {
localNodeController v3.NodeController
nodeLister v3.NodeLister
clusterLister v3.ClusterLister
TunnelServer *remotedialer.Server
TunnelAuthorizer *tunnelserver.Authorizer
store *encryptedstore.GenericEncryptedStore
}
func (f *Factory) ClusterDialer(clusterName string) (dialer.Dialer, error) {
cluster, err := f.clusterLister.Get("", clusterName)
if err != nil {
return nil, err
}
if cluster.Status.Driver == v3.ClusterDriverImported && !cluster.Spec.Internal && (cluster.Spec.ImportedConfig == nil || cluster.Spec.ImportedConfig.KubeConfig == "") {
return f.TunnelServer.Dialer(cluster.Name, 15*time.Second), nil
} else if cluster.Status.Driver == v3.ClusterDriverRKE {
nodes, err := f.nodeLister.List(cluster.Name, labels.Everything())
if err != nil {
return nil, err
}
for _, node := range nodes {
if node.Spec.Imported && node.DeletionTimestamp == nil && v3.NodeConditionProvisioned.IsTrue(node) {
return f.NodeDialer(clusterName, node.Name)
}
}
}
return net.Dial, nil
}
func (f *Factory) DockerDialer(clusterName, machineName string) (dialer.Dialer, error) {
machine, err := f.nodeLister.Get(clusterName, machineName)
if err != nil {
return nil, err
}
if machine.Spec.Imported {
d := f.TunnelServer.Dialer(machine.Name, 15*time.Second)
return func(string, string) (net.Conn, error) {
return d("unix", "/var/run/docker.sock")
}, nil
}
if machine.Spec.CustomConfig != nil && machine.Spec.CustomConfig.Address != "" && machine.Spec.CustomConfig.SSHKey != "" {
return f.sshDialer(machine)
}
if machine.Spec.NodeTemplateName != "" {
return f.tlsDialer(machine)
}
return nil, fmt.Errorf("can not build dailer to %s:%s", clusterName, machineName)
}
func (f *Factory) NodeDialer(clusterName, machineName string) (dialer.Dialer, error) {
machine, err := f.nodeLister.Get(clusterName, machineName)
if err != nil {
return nil, err
}
if machine.Spec.Imported {
d := f.TunnelServer.Dialer(machine.Name, 15*time.Second)
return dialer.Dialer(d), nil
}
if machine.Spec.CustomConfig != nil && machine.Spec.CustomConfig.Address != "" && machine.Spec.CustomConfig.SSHKey != "" {
return f.sshLocalDialer(machine)
}
if machine.Spec.NodeTemplateName != "" {
return f.sshLocalDialer(machine)
}
return nil, fmt.Errorf("can not build dailer to %s:%s", clusterName, machineName)
}