/
shim.go
136 lines (116 loc) · 3.48 KB
/
shim.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
// Copyright 2016 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.
package sshclient
import (
"github.com/juju/errors"
"github.com/juju/names/v5"
"github.com/juju/juju/core/network"
environscloudspec "github.com/juju/juju/environs/cloudspec"
"github.com/juju/juju/environs/config"
"github.com/juju/juju/state"
"github.com/juju/juju/state/stateenvirons"
)
// Backend defines the State API used by the sshclient facade.
type Backend interface {
ModelConfig() (*config.Config, error)
GetMachineForEntity(tag string) (SSHMachine, error)
GetSSHHostKeys(names.MachineTag) (state.SSHHostKeys, error)
ModelTag() names.ModelTag
ControllerTag() names.ControllerTag
Model() (Model, error)
CloudSpec() (environscloudspec.CloudSpec, error)
}
// Model defines a point of use interface for the model from state.
type Model interface {
ControllerUUID() string
Config() (*config.Config, error)
Type() state.ModelType
}
// Broker is a subset of caas broker.
type Broker interface {
GetSecretToken(name string) (string, error)
}
// SSHMachine specifies the methods on State.Machine of interest to
// the SSHClient facade.
type SSHMachine interface {
MachineTag() names.MachineTag
PublicAddress() (network.SpaceAddress, error)
PrivateAddress() (network.SpaceAddress, error)
Addresses() network.SpaceAddresses
AllDeviceSpaceAddresses() (network.SpaceAddresses, error)
}
type sshMachine struct {
*state.Machine
st *state.State
}
// AllDeviceSpaceAddresses returns all machine link-layer
// device addresses as SpaceAddresses.
func (m *sshMachine) AllDeviceSpaceAddresses() (network.SpaceAddresses, error) {
addrs, err := m.Machine.AllDeviceAddresses()
if err != nil {
return nil, errors.Trace(err)
}
subs, err := m.st.AllSubnetInfos()
if err != nil {
return nil, errors.Trace(err)
}
spaceAddrs := make(network.SpaceAddresses, len(addrs))
for i, addr := range addrs {
if spaceAddrs[i], err = network.ConvertToSpaceAddress(addr, subs); err != nil {
return nil, errors.Trace(err)
}
}
return spaceAddrs, nil
}
type backend struct {
*state.State
stateenvirons.EnvironConfigGetter
controllerTag names.ControllerTag
modelTag names.ModelTag
}
// ModelTag returns the model tag of the backend.
func (b *backend) ModelTag() names.ModelTag {
return b.modelTag
}
func (b *backend) Model() (Model, error) {
return b.State.Model()
}
func (b *backend) CloudSpec() (environscloudspec.CloudSpec, error) {
return b.EnvironConfigGetter.CloudSpec()
}
// ControllerTag returns the controller tag of the backend.
func (b *backend) ControllerTag() names.ControllerTag {
return b.controllerTag
}
// GetMachineForEntity takes a machine or unit tag (as a string) and
// returns the associated SSHMachine.
func (b *backend) GetMachineForEntity(tagString string) (SSHMachine, error) {
tag, err := names.ParseTag(tagString)
if err != nil {
return nil, errors.Trace(err)
}
switch tag := tag.(type) {
case names.MachineTag:
m, err := b.State.Machine(tag.Id())
if err != nil {
return nil, errors.Trace(err)
}
return &sshMachine{Machine: m, st: b.State}, nil
case names.UnitTag:
unit, err := b.State.Unit(tag.Id())
if err != nil {
return nil, errors.Trace(err)
}
machineId, err := unit.AssignedMachineId()
if err != nil {
return nil, errors.Trace(err)
}
m, err := b.State.Machine(machineId)
if err != nil {
return nil, errors.Trace(err)
}
return &sshMachine{Machine: m, st: b.State}, nil
default:
return nil, errors.Errorf("unsupported entity: %q", tagString)
}
}