func (t *TestEnvironment) StartAgentTunnel(mbusUser, mbusPass string, mbusPort int) (agentclient.AgentClient, error) {
if t.sshTunnelProc != nil {
return nil, fmt.Errorf("Already running")
}
sshCmd := boshsys.Command{
Name: "vagrant",
Args: []string{
"ssh",
"--",
fmt.Sprintf("-L16868:127.0.0.1:%d", mbusPort),
},
Stdin: emptyReader{},
}
newTunnelProc, err := t.cmdRunner.RunComplexCommandAsync(sshCmd)
if err != nil {
return nil, err
}
t.sshTunnelProc = newTunnelProc
httpClient := httpclient.NewHTTPClient(httpclient.DefaultClient, t.logger)
mbusURL := fmt.Sprintf("https://%s:%s@localhost:16868", mbusUser, mbusPass)
client := http.NewAgentClient(mbusURL, "fake-director-uuid", 1*time.Second, 10, httpClient, t.logger)
for i := 1; i < 1000000; i++ {
t.logger.Debug("test environment", "Trying to contact agent via ssh tunnel...")
time.Sleep(1 * time.Second)
_, err := client.Ping()
if err == nil {
break
}
t.logger.Debug("test environment", err.Error())
}
return client, nil
}
func (f *factory) loadTarballProvider() bitarball.Provider {
if f.tarballProvider != nil {
return f.tarballProvider
}
tarballCacheBasePath := filepath.Join(f.workspaceRootPath, "downloads")
tarballCache := bitarball.NewCache(tarballCacheBasePath, f.fs, f.logger)
httpClient := bihttpclient.NewHTTPClient(bitarball.HTTPClient, f.logger)
sha1Calculator := bicrypto.NewSha1Calculator(f.fs)
f.tarballProvider = bitarball.NewProvider(tarballCache, f.fs, httpClient, sha1Calculator, 3, 500*time.Millisecond, f.logger)
return f.tarballProvider
}
func (f Factory) httpClient(config Config, taskReporter TaskReporter, fileReporter FileReporter) (Client, error) {
certPool, err := config.CACertPool()
if err != nil {
return Client{}, err
}
if certPool == nil {
f.logger.Debug(f.logTag, "Using default root CAs")
} else {
f.logger.Debug(f.logTag, "Using custom root CAs")
}
rawClient := boshhttp.CreateDefaultClient(certPool)
authAdjustment := NewAuthRequestAdjustment(
config.TokenFunc, config.Username, config.Password)
rawClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
if len(via) > 10 {
return bosherr.Error("Too many redirects")
}
// Since redirected requests are not retried,
// forcefully adjust auth token as this is the last chance.
err := authAdjustment.Adjust(req, true)
if err != nil {
return err
}
req.URL.Host = fmt.Sprintf("%s:%d", config.Host, config.Port)
req.Header.Del("Referer")
return nil
}
authedClient := NewAdjustableClient(rawClient, authAdjustment)
httpClient := boshhttp.NewHTTPClient(authedClient, f.logger)
endpoint := url.URL{
Scheme: "https",
Host: fmt.Sprintf("%s:%d", config.Host, config.Port),
}
return NewClient(endpoint.String(), httpClient, taskReporter, fileReporter, f.logger), nil
}
func (f Factory) httpClient(config Config) (Client, error) {
certPool, err := config.CACertPool()
if err != nil {
return Client{}, err
}
if certPool == nil {
f.logger.Debug(f.logTag, "Using default root CAs")
} else {
f.logger.Debug(f.logTag, "Using custom root CAs")
}
rawClient := boshhttp.CreateDefaultClient(certPool)
httpClient := boshhttp.NewHTTPClient(rawClient, f.logger)
endpoint := url.URL{
Scheme: "https",
Host: fmt.Sprintf("%s:%d", config.Host, config.Port),
User: url.UserPassword(config.Client, config.ClientSecret),
}
return NewClient(endpoint.String(), httpClient, f.logger), nil
}
mockCloud.EXPECT().DeleteDisk(oldDiskCID),
// start jobs & wait for running
mockAgentClient.EXPECT().Apply(applySpec),
mockAgentClient.EXPECT().GetState(),
mockAgentClient.EXPECT().Stop(),
mockAgentClient.EXPECT().Apply(applySpec),
mockAgentClient.EXPECT().RunScript("pre-start", map[string]interface{}{}),
mockAgentClient.EXPECT().Start(),
mockAgentClient.EXPECT().GetState().Return(agentRunningState, nil),
mockAgentClient.EXPECT().RunScript("post-start", map[string]interface{}{}),
)
}
var expectRegistryToWork = func() {
httpClient := bihttp.NewHTTPClient(bihttp.DefaultClient, logger)
endpoint := "http://*****:*****@127.0.0.1:6901/instances/fake-director-id/settings"
settingsBytes := []byte("fake-registry-contents") //usually json, but not required to be
response, err := httpClient.Put(endpoint, settingsBytes)
Expect(err).ToNot(HaveOccurred())
Expect(response.StatusCode).To(Equal(http.StatusCreated))
response, err = httpClient.Get(endpoint)
Expect(err).ToNot(HaveOccurred())
Expect(response.StatusCode).To(Equal(http.StatusOK))
responseBytes, err := ioutil.ReadAll(response.Body)
Expect(err).ToNot(HaveOccurred())
Expect(responseBytes).To(Equal([]byte("{\"settings\":\"fake-registry-contents\",\"status\":\"ok\"}")))
func (f *agentClientFactory) NewAgentClient(directorID, mbusURL string) agentclient.AgentClient {
httpClient := httpclient.NewHTTPClient(httpclient.DefaultClient, f.logger)
return NewAgentClient(mbusURL, directorID, f.getTaskDelay, 10, httpClient, f.logger)
}