forked from cloudfoundry/bosh-agent
-
Notifications
You must be signed in to change notification settings - Fork 0
/
agent_client.go
156 lines (132 loc) · 5.03 KB
/
agent_client.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
152
153
154
155
156
package integrationagentclient
import (
"encoding/json"
"time"
"github.com/cloudfoundry/bosh-agent/agent/action"
"github.com/cloudfoundry/bosh-agent/agent/applier/applyspec"
"github.com/cloudfoundry/bosh-agent/agentclient/http"
"github.com/cloudfoundry/bosh-agent/settings"
boshcrypto "github.com/cloudfoundry/bosh-utils/crypto"
bosherr "github.com/cloudfoundry/bosh-utils/errors"
"github.com/cloudfoundry/bosh-utils/httpclient"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
)
type IntegrationAgentClient struct {
*http.AgentClient
}
func NewIntegrationAgentClient(
endpoint string,
directorID string,
getTaskDelay time.Duration,
toleratedErrorCount int,
httpClient *httpclient.HTTPClient,
logger boshlog.Logger,
) *IntegrationAgentClient {
return &IntegrationAgentClient{
AgentClient: http.NewAgentClient(endpoint, directorID, getTaskDelay, toleratedErrorCount, httpClient, logger).(*http.AgentClient),
}
}
type exception struct {
Message string
}
type SSHResponse struct {
action.SSHResult
Exception *exception
}
func (r *SSHResponse) ServerError() error {
if r.Exception != nil {
return bosherr.Errorf("Agent responded with error: %s", r.Exception.Message)
}
return nil
}
func (r *SSHResponse) Unmarshal(message []byte) error {
return json.Unmarshal(message, r)
}
func (c *IntegrationAgentClient) FetchLogs(logType string, filters []string) (map[string]interface{}, error) {
responseRaw, err := c.SendAsyncTaskMessage("fetch_logs", []interface{}{logType, filters})
if err != nil {
return nil, bosherr.WrapError(err, "Fetching logs from agent")
}
responseValue, ok := responseRaw.(map[string]interface{})
if !ok {
return nil, bosherr.Errorf("Unable to parse fetch_logs response value: %#v", responseRaw)
}
if err != nil {
return nil, bosherr.WrapError(err, "Sending 'fetch_logs' to the agent")
}
return responseValue, err
}
func (c *IntegrationAgentClient) Prepare(spec applyspec.V1ApplySpec) error {
_, err := c.SendAsyncTaskMessage("prepare", []interface{}{spec})
return err
}
func (c *IntegrationAgentClient) FetchLogsWithSignedURLAction(signedURL, logType string, filters []string, headers map[string]string) (action.FetchLogsWithSignedURLResponse, error) {
req := action.FetchLogsWithSignedURLRequest{
LogType: logType,
Filters: filters,
SignedURL: signedURL,
BlobstoreHeaders: headers,
}
responseRaw, err := c.SendAsyncTaskMessage("fetch_logs_with_signed_url", []interface{}{req})
if err != nil {
return action.FetchLogsWithSignedURLResponse{}, bosherr.WrapError(err, "Sending 'fetch_logs_with_signed_url' to the agent")
}
responseValue, ok := responseRaw.(map[string]interface{})
if !ok {
return action.FetchLogsWithSignedURLResponse{}, bosherr.Errorf("Unable to parse fetch_logs_with_signed_url response value: %#v", responseRaw)
}
return action.FetchLogsWithSignedURLResponse{
SHA1Digest: responseValue["sha1"].(string),
}, err
}
func (c *IntegrationAgentClient) SyncDNSWithSignedURL(signedURL string, digest boshcrypto.MultipleDigest, version uint64) (string, error) {
var response http.SyncDNSResponse
req := action.SyncDNSWithSignedURLRequest{
SignedURL: signedURL,
MultiDigest: digest,
Version: version,
}
err := c.AgentRequest.Send("sync_dns_with_signed_url", []interface{}{req}, &response)
if err != nil {
return "", bosherr.WrapError(err, "Sending 'sync_dns_with_signed_url' to the agent")
}
return response.Value, nil
}
func (c *IntegrationAgentClient) SSH(cmd string, params action.SSHParams) error {
err := c.AgentRequest.Send("ssh", []interface{}{cmd, params}, &SSHResponse{})
if err != nil {
return bosherr.WrapError(err, "Sending 'ssh' to the agent")
}
return nil
}
func (c *IntegrationAgentClient) UpdateSettings(settings settings.UpdateSettings) error {
_, err := c.SendAsyncTaskMessage("update_settings", []interface{}{settings})
return err
}
func (c *IntegrationAgentClient) CompilePackageWithSignedURL(req action.CompilePackageWithSignedURLRequest) (compiledPackageRef map[string]interface{}, err error) {
responseRaw, err := c.SendAsyncTaskMessage("compile_package_with_signed_url", []interface{}{req})
responseValue, ok := responseRaw.(map[string]interface{})
if !ok {
return map[string]interface{}{}, bosherr.WrapErrorf(err, "Unable to parse compile_package response value: %#v", responseValue)
}
if err != nil {
return map[string]interface{}{}, bosherr.WrapError(err, "Sending 'compile_package' to the agent")
}
result, ok := responseValue["result"].(map[string]interface{})
if !ok {
return map[string]interface{}{}, bosherr.Errorf("Unable to parse 'compile_package' response from the agent: %#v", responseValue)
}
sha1, ok := result["sha1"].(string)
if !ok {
return map[string]interface{}{}, bosherr.Errorf("Unable to parse 'compile_package' response from the agent: %#v", responseValue)
}
return map[string]interface{}{
"result": map[string]string{
"sha1": sha1,
},
}, nil
}
func (c *IntegrationAgentClient) ApplyV1Spec(spec applyspec.V1ApplySpec) error {
_, err := c.SendAsyncTaskMessage("apply", []interface{}{spec})
return err
}